PHPackages                             kouchik/http-kernel - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [HTTP & Networking](/categories/http)
4. /
5. kouchik/http-kernel

ActiveLibrary[HTTP & Networking](/categories/http)

kouchik/http-kernel
===================

A simple, elegant, and easy-to-understand PHP HTTP kernel inspired by Slim framework.

92PHP

Since Dec 22Pushed 4mo ago1 watchersCompare

[ Source](https://github.com/kouchik-labs/http-kernel)[ Packagist](https://packagist.org/packages/kouchik/http-kernel)[ RSS](/packages/kouchik-http-kernel/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependenciesVersions (1)Used By (0)

HTTP Kernel
===========

[](#http-kernel)

A lightweight, elegant PSR-7 / PSR-15 HTTP kernel used as the core routing and middleware engine inside the Kouchik framework.

This package provides a simple and intuitive way to handle HTTP requests, routing, middleware, and dependency injection, inspired by Slim.

---

Installation
------------

[](#installation)

Install via Composer:

```
composer require kouchik/http-kernel
```

---

Basic Usage
-----------

[](#basic-usage)

```
require __DIR__ . '/../vendor/autoload.php';

use Kouchik\HttpKernel\Application;
use Kouchik\HttpKernel\Router;
use DI\ContainerBuilder;
use Laminas\Diactoros\Response;
use Psr\Http\Message\ServerRequestInterface as Request;

$builder = new ContainerBuilder();
$container = $builder->build();

$router = new Router();
$app = new Application($router, $container);

$app->get('/welcome', function (Request $request) {
    $response = new Response();
    $response->getBody()->write('Welcome!');
    return $response;
});
```

---

Controllers
-----------

[](#controllers)

You can organize your routes using controllers for better structure and readability.

```
// src/Controllers/HomeController.php
namespace App\Controllers;

use Psr\Http\Message\ServerRequestInterface as Request;
use Laminas\Diactoros\Response;

class HomeController
{
    public function welcome(Request $request)
    {
        $response = new Response();
        $response->getBody()->write('Welcome via Controller!');
        return $response;
    }
}
```

Register the controller method as a route:

```
// index.php
use App\Controllers\HomeController;

$app->get('/welcome', [HomeController::class, 'welcome']);
```

---

Middlewares
-----------

[](#middlewares)

Middlewares can modify the request/response flow or perform tasks such as authentication.

```
// src/Middleware/AuthMiddleware.php
namespace App\Middleware;

use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Server\RequestHandlerInterface as Handler;
use Psr\Http\Message\ResponseInterface;
use Laminas\Diactoros\Response;

class AuthMiddleware
{
    public function process(Request $request, Handler $handler): ResponseInterface
    {
        if ($request->getHeaderLine('X-Auth-Token') !== 'secret-token') {
            $response = new Response();
            $response->getBody()->write('Unauthorized');
            return $response->withStatus(401);
        }

        return $handler->handle($request);
    }
}
```

Attach middleware:

```
use App\Middleware\AuthMiddleware;

$app->add(AuthMiddleware::class);
```

---

Dynamic Route Parameters
------------------------

[](#dynamic-route-parameters)

HTTP Kernel supports dynamic route parameters.

```
$app->get('/user/{id}', function (Request $request, $id) {
    $response = new Response();
    $response->getBody()->write('User ID: ' . $id);
    return $response;
});
```

---

Dependency Injection
--------------------

[](#dependency-injection)

HTTP Kernel uses **PHP-DI** for dependency injection.

### Define a service

[](#define-a-service)

```
// src/Services/GreetingService.php
namespace App\Services;

class GreetingService
{
    public function greet(string $name): string
    {
        return "Hello, {$name}!";
    }
}
```

### Register and inject it

[](#register-and-inject-it)

```
use App\Services\GreetingService;

$builder->addDefinitions([
    GreetingService::class => \DI\create(GreetingService::class),
]);

$app->get('/greet/{name}', function (
    Request $request,
    $name,
    GreetingService $greetingService
) {
    $response = new Response();
    $response->getBody()->write($greetingService->greet($name));
    return $response;
});
```

---

Route Groups
------------

[](#route-groups)

Routes can be grouped and assigned shared middleware.

```
$app->group('/api', function () use ($app) {
    $app->get('/users', function (Request $request) {
        $response = new Response();
        $response->getBody()->write('User List');
        return $response;
    });

    $app->get('/posts', function (Request $request) {
        $response = new Response();
        $response->getBody()->write('Post List');
        return $response;
    });
})->add(AuthMiddleware::class);
```

---

Testing
-------

[](#testing)

HTTP Kernel is easy to test using PHPUnit.

```