feat: add controller support with mixed respone

Author: wazabii8

README.md

@@ -32,7 +32,19 @@ composer require maplephp/emitron
 Emitron includes a robust request handler that executes PSR-15 middlewares in sequence, returning a fully PSR-7 compliant response.
 
 ```php
-use MaplePHP\Emitron\RequestHandler;use MaplePHP\Http\Environment;use MaplePHP\Http\ServerRequest;use MaplePHP\Http\Uri;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+use MaplePHP\Emitron\RequestHandler;
+use MaplePHP\Emitron\Emitters\HttpEmitter;
+use MaplePHP\Http\Environment;
+use MaplePHP\Http\ServerRequest;
+use MaplePHP\Http\Uri;
+use MaplePHP\Emitron\Middlewares\{
+    ContentLengthMiddleware,
+    GzipMiddleware,
+    HeadRequestMiddleware
+};
+use App\Controllers\MyController;
 
 // Use MaplePHP HTTP library or any other PSR-7 implementation
 $env = new Environment();
@@ -48,8 +60,23 @@ $middlewares = [
 ];
 
 // Run the middleware stack
-$handler = new RequestHandler($middlewares, $factory);
+
+
+$factory = new ResponseFactory($bodyStream);
+// $finalHandler = new ControllerRequestHandler($factory, [MyController::class, "index"]);
+$finalHandler = new ControllerRequestHandler($factory, function(RequestInterface $request, ResponseInterface $response) {
+    $response->getBody()->write("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+    return $response;
+});
+
+$handler = new RequestHandler($middlewares, $finalHandler);
 $response = $handler->handle($request);
+
+// Emit the execute headers and response correctly 
+//$emit = new CliEmitter($response, $request);
+$emit = new HttpEmitter();
+$emit->emit($response, $request);
+
 ```
 
 Each middleware conforms to `Psr\Http\Server\MiddlewareInterface`, allowing you to plug in your own or third-party middlewares with no additional setup.

src/Contracts/ControllerResponseInterface.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace MaplePHP\Emitron\Contracts;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+
+interface ControllerResponseInterface
+{
+    /**
+     * Controller response can be empty, string, array, object
+     *
+     * @param ServerRequestInterface $request
+     * @return mixed
+     */
+    public function handle(ServerRequestInterface $request, ResponseInterface $response): mixed;
+}

src/Contracts/KernelInterface.php

@@ -3,15 +3,17 @@
 namespace MaplePHP\Emitron\Contracts;
 
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamInterface;
 
 interface KernelInterface
 {
     /**
      * Run the emitter and init all routes, middlewares and configs
      *
      * @param ServerRequestInterface $request
+     * @param StreamInterface|null $stream
      * @return void
      */
-    public function run(ServerRequestInterface $request): void;
+    public function run(ServerRequestInterface $request, ?StreamInterface $stream): void;
 
 }

src/ControllerRequestHandler.php

@@ -1,20 +1,19 @@
 <?php
 namespace MaplePHP\Emitron;
 
-
-use FastRoute\Dispatcher;
 use MaplePHP\Container\Reflection;
-use MaplePHP\Core\Router\RouterDispatcher;
+use MaplePHP\Http\StreamFactory;
 use Psr\Http\Message\ResponseFactoryInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamInterface;
 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]
+        private readonly array|\Closure $controller
     ) {}
 
     public function handle(ServerRequestInterface $request): ResponseInterface
@@ -26,6 +25,10 @@ public function handle(ServerRequestInterface $request): ResponseInterface
         ]);
 
         $controller = $this->controller;
+        if(is_callable($controller)) {
+            return $controller($request, $response);
+        }
+
         if (!isset($controller[1])) {
             $controller[1] = '__invoke';
         }
@@ -46,21 +49,62 @@ public function handle(ServerRequestInterface $request): ResponseInterface
         $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);
 
+        return $this->createResponse($response, $result);
+    }
+
+
+    /**
+     * Will create a PSR valid Response instance form mixed result
+     *
+     * @param ResponseInterface $response
+     * @param mixed $result
+     * @return ResponseInterface
+     */
+    protected function createResponse(ResponseInterface $response, mixed $result): ResponseInterface
+    {
         if ($result instanceof ResponseInterface) {
             return $result;
         }
 
-        // If controller didn’t return a response:
-        // - treat it as “controller wrote to $response->getBody() somewhere”
-        // - or treat non-response as error
+        if($result instanceof StreamInterface) {
+            return $response->withBody($result);
+        }
+
+        if(is_array($result) || is_object($result)) {
+            return $this->createStream($response, json_encode($result, JSON_UNESCAPED_UNICODE))
+                ->withHeader("Content-Type", "application/json");
+        }
+
+        if(is_string($result) || is_numeric($result)) {
+            return $this->createStream($response, $result);
+        }
         return $response;
     }
 
+    /**
+     * A helper method to create a new stream instance
+     *
+     * @param ResponseInterface $response
+     * @param mixed $result
+     * @return ResponseInterface
+     */
+    protected function createStream(ResponseInterface $response, mixed $result): ResponseInterface
+    {
+        $streamFactory = new StreamFactory();
+        $stream = $streamFactory->createStream($result);
+        return $response->withBody($stream);
+
+    }
 
+    /**
+     * Append interface helper method
+     *
+     * @param array $bindings
+     * @return void
+     */
     protected function appendInterfaces(array $bindings)
     {
         Reflection::interfaceFactory(function (string $className) use ($bindings) {

src/Kernel.php

@@ -14,8 +14,6 @@
 
 namespace MaplePHP\Emitron;
 
-use FastRoute\Dispatcher;
-use MaplePHP\Core\Router\RouterDispatcher;
 use MaplePHP\Http\ResponseFactory;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\StreamInterface;
@@ -35,7 +33,7 @@ public function run(ServerRequestInterface $request, ?StreamInterface $stream =
 
         $this->dispatchConfig->getRouter()->dispatch(function ($data, $args, $middlewares) use ($request, $stream) {
 
-            $dispatchCode = $data[0] ?? RouterDispatcher::FOUND;
+            //$dispatchCode = $data[0] ?? RouterDispatcher::FOUND;
 
             [$data, $args, $middlewares] = $this->reMap($data, $args, $middlewares);
 
@@ -60,13 +58,15 @@ public function run(ServerRequestInterface $request, ?StreamInterface $stream =
                 middlewares: $middlewares
             );
 
+            /*
             if ($dispatchCode === Dispatcher::NOT_FOUND) {
                 $response = $response->withStatus(404);
             }
 
             if ($dispatchCode === Dispatcher::METHOD_NOT_ALLOWED) {
                 $response = $response->withStatus(405);
             }
+             */
 
             $this->createEmitter()->emit($response, $request);
         });

src/Middlewares/OutputMiddleware.php

@@ -24,6 +24,7 @@ public function __construct(
 
     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->finalHandler->handle($request);

src/RequestHandler.php

@@ -1,54 +1,60 @@
 <?php
 
+use MaplePHP\Emitron\ControllerRequestHandler;
 use MaplePHP\Emitron\Emitters\HttpEmitter;
 use MaplePHP\Emitron\Middlewares\ContentLengthMiddleware;
 use MaplePHP\Emitron\Middlewares\GzipMiddleware;
 use MaplePHP\Emitron\Middlewares\HeadRequestMiddleware;
-use MaplePHP\Emitron\Middlewares\OutputMiddleware;
 use MaplePHP\Emitron\RequestHandler;
 use MaplePHP\Http\Environment;
 use MaplePHP\Http\ResponseFactory;
 use MaplePHP\Http\ServerRequest;
 use MaplePHP\Http\Stream;
 use MaplePHP\Http\Uri;
 use MaplePHP\Unitary\{Config\TestConfig, Expect, TestCase};
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
 
 $config = TestConfig::make()->withName("emitron");
 group($config->withSubject("Testing middleware and emitter"), function (TestCase $case) {
 
-    $stream = new Stream(Stream::TEMP);
-    $stream->write("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras eleifend ligula vel diam tincidunt finibus. In dapibus dictum lectus a malesuada.");
+
+
 
     // It will reverse the order
     $middlewares = [
         new ContentLengthMiddleware(),
         new GzipMiddleware(),
-        new OutputMiddleware($stream),
         new HeadRequestMiddleware(),
     ];
 
     $env = new Environment();
     $uri = new Uri($env->getUriParts());
     $request = new ServerRequest($uri, $env);
 
-    // Do not exist in CLI so need to mock it
+    // This is something that is usually set by the browser
+    // So this does not exist in CLI so need to mock it
     $request = $request->withHeader("Accept-Encoding", "gzip");
 
-    $factory = new ResponseFactory();
-    $factory->createResponse();
-    $handler = new RequestHandler($middlewares, $factory);
-    $response = $handler->handle($request);
+    $stream = new Stream(Stream::TEMP);
+    $factory = new ResponseFactory($stream);
+    $factory->createResponse(200, "OK");
 
+    $finalHandler = new ControllerRequestHandler($factory, function(RequestInterface $req, ResponseInterface $res) {
+        $res->getBody()->write("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras eleifend ligula vel diam tincidunt finibus. In dapibus dictum lectus a malesuada.");
+        return $res;
+    });
 
+    $handler = new RequestHandler($middlewares, $finalHandler);
+    $response = $handler->handle($request);
     $emit = new HttpEmitter();
 
     ob_start();
-    $emit->emit($response->withBody($stream), $request);
+    $emit->emit($response, $request);
     $out = ob_get_clean();
 
-
     $case->validate($out, function (Expect $expect) {
-        $expect->isLength(143);
+        $expect->isLength(119);
     });
 
     $headers = $response->getHeaders();