feat: add Controller Request Handler and routing contracts

Author: wazabii8

src/AbstractKernel.php

@@ -26,6 +26,7 @@
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\StreamInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 
 abstract class AbstractKernel implements KernelInterface
 {
@@ -118,24 +119,29 @@ public function getDispatchConfig(): DispatchConfigInterface
      *
      * @param ServerRequestInterface $request
      * @param StreamInterface $stream
+     * @param RequestHandlerInterface $finalHandler
      * @param array $middlewares
      * @return ResponseInterface
      * @throws \ReflectionException
      */
     protected function initRequestHandler(
         ServerRequestInterface $request,
         StreamInterface $stream,
+        RequestHandlerInterface $finalHandler,
         array $middlewares = []
-    ) : ResponseInterface {
-        $factory = new ResponseFactory($stream);
+    ): ResponseInterface {
+
         $this->bindInterfaces([
-            "ContainerInterface" => $this->container, "RequestInterface" => $request,
-            "ServerRequestInterface" => $request, "StreamInterface" => $stream,
+            "ContainerInterface" => $this->container,
+            "RequestInterface" => $request,
+            "ServerRequestInterface" => $request,
+            "StreamInterface" => $stream,
         ]);
+
         $middlewares = array_merge($this->userMiddlewares, $middlewares);
-        $handler = new RequestHandler($middlewares, $factory);
+        $handler = new RequestHandler($middlewares, $finalHandler);
         $response = $handler->handle($request);
-        $this->bindInterfaces(["ResponseInterface" => $response]);
+
         return $response;
     }
 

src/Contracts/DispatchConfigInterface.php

@@ -3,7 +3,7 @@
 namespace MaplePHP\Emitron\Contracts;
 
 use Exception;
-use MaplePHP\Unitary\Interfaces\RouterDispatchInterface;
+use MaplePHP\Unitary\Interfaces\RouterDispatchInterface as UnitaryRouterDispatchInterface;
 
 interface DispatchConfigInterface
 {
@@ -35,9 +35,9 @@ public function setProps(array $props): self;
     /**
      * Get current exit code as int or null if not set
      *
-     * @return RouterDispatchInterface
+     * @return RouterDispatchInterface|UnitaryRouterDispatchInterface
      */
-    public function getRouter(): RouterDispatchInterface;
+    public function getRouter(): RouterDispatchInterface|UnitaryRouterDispatchInterface;
 
     /**
      * Add exit after execution of the app has been completed

src/Contracts/RouterDispatchInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace MaplePHP\Emitron\Contracts;
+
+interface RouterDispatchInterface
+{
+    /**
+     * Dispatch matched router
+     *
+     * @param callable $call
+     * @return bool
+     */
+    public function dispatch(callable $call): bool;
+}

src/Contracts/RouterInterface.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace MaplePHP\Emitron\Contracts;
+
+interface RouterInterface extends RouterDispatchInterface
+{
+    /**
+     * Map one or more needles to controller
+     */
+    public function map(string|array $methods, string $pattern, array $controller): void;
+}

src/ControllerRequestHandler.php

@@ -0,0 +1,68 @@
+<?php
+namespace MaplePHP\Emitron;
+
+
+use MaplePHP\Container\Reflection;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+final class ControllerRequestHandler implements RequestHandlerInterface
+{
+    public function __construct(
+        private readonly ResponseFactoryInterface $factory,
+        private readonly array $controller, // [$class, $method] or [$class]
+    ) {}
+
+    public function handle(ServerRequestInterface $request): ResponseInterface
+    {
+        $response = $this->factory->createResponse();
+        $this->appendInterfaces([
+            "ResponseInterface" => $response,
+        ]);
+
+        $controller = $this->controller;
+        if (!isset($controller[1])) {
+            $controller[1] = '__invoke';
+        }
+
+        if (count($controller) !== 2) {
+            $response->getBody()->write("ERROR: Invalid controller handler.\n");
+            return $response;
+        }
+
+        [$class, $method] = $controller;
+
+        if (!method_exists($class, $method)) {
+            $response->getBody()->write("ERROR: Could not load Controller {$class}::{$method}().\n");
+            return $response;
+        }
+
+        // Your DI wiring
+        $reflect = new Reflection($class);
+        $classInst = $reflect->dependencyInjector();
+
+
+        // This should INVOKE the method and return its result (ResponseInterface or something else)
+        $result = $reflect->dependencyInjector($classInst, $method);
+
+        if ($result instanceof ResponseInterface) {
+            return $result;
+        }
+
+        // If controller didn’t return a response, you can decide a convention:
+        // - treat it as “controller wrote to $response->getBody() somewhere”
+        // - or treat non-response as error
+        return $response;
+    }
+
+
+    protected function appendInterfaces(array $bindings)
+    {
+        Reflection::interfaceFactory(function (string $className) use ($bindings) {
+            return $bindings[$className] ?? null;
+        });
+    }
+
+}

src/DispatchConfig.php

@@ -18,13 +18,15 @@
 use MaplePHP\Emitron\Configs\ConfigPropsFactory;
 use MaplePHP\Emitron\Contracts\ConfigPropsInterface;
 use MaplePHP\Emitron\Contracts\DispatchConfigInterface;
-use MaplePHP\Unitary\Interfaces\RouterDispatchInterface;
-use MaplePHP\Unitary\Interfaces\RouterInterface;
+use MaplePHP\Unitary\Interfaces\RouterDispatchInterface as UnitaryRouterDispatchInterface;
+use MaplePHP\Unitary\Interfaces\RouterInterface as UnitaryRouterInterface;
+use MaplePHP\Emitron\Contracts\RouterInterface;
+use MaplePHP\Emitron\Contracts\RouterDispatchInterface;
 
 class DispatchConfig implements DispatchConfigInterface
 {
     private string $dir;
-    private ?RouterInterface $router = null;
+    private RouterInterface|UnitaryRouterInterface|null $router = null;
     protected ConfigPropsInterface $props;
 
     /**
@@ -100,12 +102,12 @@ public function setProps(array $props): self
     /**
      * Get current exit code as int or null if not set
      *
-     * @return RouterDispatchInterface
+     * @return UnitaryRouterInterface|RouterDispatchInterface
      */
-    public function getRouter(): RouterDispatchInterface
+    public function getRouter(): UnitaryRouterInterface|RouterDispatchInterface
     {
         if ($this->router === null) {
-            return new class () implements RouterDispatchInterface {
+            return new class () implements UnitaryRouterDispatchInterface, RouterDispatchInterface {
                 public function dispatch(callable $call): bool
                 {
                     $call(['handler' => []], [], [], '');
@@ -127,7 +129,7 @@ public function setRouter(callable $call): self
     {
         $inst = clone $this;
         $inst->router = $call($this->dir);
-        if (!($inst->router instanceof RouterInterface)) {
+        if (!($inst->router instanceof RouterInterface || $inst->router instanceof UnitaryRouterInterface)) {
             throw new Exception('Router must implement RouterInterface and "return" a it!');
         }
         return $inst;

src/Emitters/HttpEmitter.php

@@ -22,13 +22,14 @@ class HttpEmitter implements EmitterInterface
      */
     public function emit(ResponseInterface $response, ServerRequestInterface $request): void
     {
+
         $body = $response->getBody();
         $status = $response->getStatusCode();
         $method = strtoupper($request->getMethod());
         $skipBody = in_array($status, [204, 304]) || ($status >= 100 && $status < 200) || $method === 'HEAD';
 
         // Default to 204 No Content if nobody was written
-        if (!$response->getBody()->getSize() && $this->isSuccessfulResponse()) {
+        if (!$response->getBody()->getSize() && $this->isSuccessfulResponse($response)) {
             $response = $response->withStatus(204);
             $response->getBody()->write("No Content\n");
         }

src/Kernel.php

@@ -15,6 +15,7 @@
 namespace MaplePHP\Emitron;
 
 use MaplePHP\Container\Reflection;
+use MaplePHP\Http\ResponseFactory;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\StreamInterface;
@@ -33,34 +34,41 @@ public function run(ServerRequestInterface $request, ?StreamInterface $stream =
     {
         $this->dispatchConfig->getRouter()->dispatch(function ($data, $args, $middlewares) use ($request, $stream) {
 
+            [$data, $args, $middlewares] = $this->reMap($data, $args, $middlewares);
+
             if (!isset($data['handler'])) {
-                throw new InvalidArgumentException("The router dispatch method arg 1 is missing the 'handler' key.");
+                throw new InvalidArgumentException("Missing 'handler' key.");
             }
 
             $this->container->set("request", $request);
             $this->container->set("args", $args);
             $this->container->set("configuration", $this->getDispatchConfig());
 
-            $response = $this->initRequestHandler($request, $this->getBody($stream), $middlewares);
+            $bodyStream = $this->getBody($stream);
+            $factory = new ResponseFactory($bodyStream);
 
-            $controller = $data['handler'];
-            if (!isset($controller[1])) {
-                $controller[1] = '__invoke';
-            }
-            if (count($controller) === 2) {
-                [$class, $method] = $controller;
-                if (method_exists($class, $method)) {
-                    $reflect = new Reflection($class);
-                    $classInst = $reflect->dependencyInjector();
-                    // Can replace the active Response instance through Command instance
-                    $hasNewResponse = $reflect->dependencyInjector($classInst, $method);
-                    $response = ($hasNewResponse instanceof ResponseInterface) ? $hasNewResponse : $response;
+            $finalHandler = new ControllerRequestHandler($factory, $data['handler']);
+
+            $response = $this->initRequestHandler(
+                request: $request,
+                stream: $bodyStream,
+                finalHandler: $finalHandler,
+                middlewares: $middlewares
+            );
 
-                } else {
-                    $response->getBody()->write("\nERROR: Could not load Controller class {$class} and method {$method}()\n");
-                }
-            }
             $this->createEmitter()->emit($response, $request);
         });
     }
+
+
+    function reMap($data, $args, $middlewares) {
+
+        if(isset($data[1]) && $middlewares instanceof ServerRequestInterface) {
+            $item = $data[1];
+            return [
+                ["handler" => $item['controller']], $_REQUEST, ($item['data'] ?? [])
+            ];
+        }
+        return [$data, $args, $middlewares];
+    }
 }

src/RequestHandler.php

@@ -3,35 +3,30 @@
 namespace MaplePHP\Emitron;
 
 use MaplePHP\Container\Reflection;
-use Psr\Http\Message\ResponseFactoryInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 
-class RequestHandler implements RequestHandlerInterface
+final class RequestHandler implements RequestHandlerInterface
 {
     private int $index = 0;
+
+    /** @var list<MiddlewareInterface> */
     private array $middlewareQueue;
-    private ResponseFactoryInterface $responseSource;
 
-    public function __construct(array $middlewares, ResponseFactoryInterface $responseFactory)
-    {
+    public function __construct(
+        array $middlewares,
+        private readonly RequestHandlerInterface $finalHandler
+    ) {
         $this->middlewareQueue = $middlewares;
-        $this->responseSource = $responseFactory;
     }
 
-    /**
-     * Process middlewares and middleware that is a string class then it will use the
-     * dependency injector in the constructor.
-     *
-     * @param ServerRequestInterface $request
-     * @return ResponseInterface
-     * @throws \ReflectionException
-     */
     public function handle(ServerRequestInterface $request): ResponseInterface
     {
+        // End of chain -> call controller (or whatever final handler you set)
         if (!isset($this->middlewareQueue[$this->index])) {
-            return $this->responseSource->createResponse(200);
+            return $this->finalHandler->handle($request);
         }
 
         $middleware = $this->middlewareQueue[$this->index];
@@ -41,6 +36,7 @@ public function handle(ServerRequestInterface $request): ResponseInterface
             $reflect = new Reflection($middleware);
             $middleware = $reflect->dependencyInjector();
         }
+
         return $middleware->process($request, $this);
     }
 }