Dotkernel is a Headless Platform
for building modern web applications
Dotkernel is a collection of applications (skeletons) that use a middleware-first architecture built on top of the Mezzio microframework using Laminas components. The goal is to provide a pre-configured environment for applications ranging from presentation sites, to enterprise-level APIs and everything in between.
What is the Dotkernel Headless Platform?
The Dotkernel Headless Platform is made up of Open Source components aimed at businesses that need custom solutions. It supports microservices, to enterprise-grade APIs. Its modern, future-proof architecture is based on middleware and PSRs.
Unmatched flexibility
Unlimited scalability
Lightning-fast performance
Easier maintenance and onboarding
Headless Platform
Built from independent applications that can be integrated
into a unified platform that is better than the sum of its parts.
* API
* ADMIN
PHP
Packagist
License
Issues
Stars
Dotkernel Admin is an application (skeleton) intended for quickly setting up an administration site for your platform. It's a fast and reliable way to manage records in your database with a simple table-based approach, and also to build reports and graphs to monitor your platform.
* LIGHT
PHP
Packagist
License
Issues
Stars
Dotkernel Light is a PSR-15 compliant application (skeleton) using Mezzio microframework and Laminas components. It was created for learning purposes. It’s a minimal project for a simple website, like a presentation site.
Extending the power of
Mezzio
Containers
Dotkernel is built around the PSR-11 dependency container. We have chosen Laminas Service Manager as our default implementation.
Get Started with
Templating
By default, no middleware in Mezzio is templated. For Dotkernel’s Frontend skeleton, we have chosen Twig as the default templating engine.
Get started with
HTTP messages
Mezzio, and consequently Dotkernel, is built around the PSR-7 standard. It uses Laminas Diactoros as the PSR-7 implementation.HTTP Request Handlers
Dotkernel follows the PSR-15 (HTTP Request Handlers) specifications, by implementing the laminas-httphandlerrunner package.
Get started with
Database and object mapping
The Doctrine Project’s PHP libraries with their flexible and stable features are at the core of our database storage and object mapping.
Get started with
Doctrine Orm and DBAL
Dotkernel
Components
- dot-authentication
core authentication interfaces - dot-auth-social
wrapper for thephpleague/oauth2-client to authenticate users though Facebook
- dot-authorization
core authorization interfaces - dot-rbac
RBAC authorization implementation - dot-rbac-guard
RBAC for authorizing sections of an application
- dot-controller
controller-like middleware for mezzio
laminas-form
validate and display forms
- dot-session
extends laminas-session - dot-flashmessenger
short lived session messages - dot-cache
extends symfony/cache
- dot-mail
extends symfony/mailer
- doctrine/orm
object-relational-mapper for PHP - doctrine/dbal
database abstraction layer with features for database schema introspection and management - dot-data-fixtures
extends doctrine/data-fixtures to populate tables
- dot-navigation
easy menu configuration and parsing
- dot-twigrenderer
extend the twig renderer with useful extensions and laminas-view helpers
- dot-annotated-services
create and inject services with dependecies through annotations - dot-event
extends laminas-eventmanager - dot-helpers
- dot-cli
extends laminas-cli for building console applications - dot-doctrine-metadata
extends mezzio/mezzio-hal for extracting and rendering Doctrine entities - dot-response-header
middleware for setting and overwriting custom response headers
- dot-user-agent-sniffer
provides details about a device by parsing a user agent - dot-debugbar
extends maximebf/php-debugbar to collect session data, log messages, debug database queries etc. - dot-geoip
extends maxmind/GeoIP2-php to provide geographical details about an IP address
Blog posts
Useful reads
Designed and built by Apidemia
Control, Scalability & Performance
Dotkernel is an Open Source project created and led by the dev team @Apidemia, initially as an internal tool to handle complex architectures, now freely open, our way of giving back to the community.