wip

src/Tqdev/PhpCrudApi/Api.php

 <?php
 namespace Tqdev\PhpCrudApi;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Cache\CacheFactory;
 use Tqdev\PhpCrudApi\Column\DefinitionService;
         $this->debug = $config->getDebug();
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $response = null;
         try {

src/Tqdev/PhpCrudApi/Controller/CacheController.php

 <?php
 namespace Tqdev\PhpCrudApi\Controller;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Cache\Cache;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
-use Tqdev\PhpCrudApi\Response;
 
 class CacheController
 {
         $this->responder = $responder;
     }
 
-    public function clear(ServerRequestInterface $request): Response
+    public function clear(ServerRequestInterface $request): ResponseInterface
     {
         return $this->responder->success($this->cache->clear());
     }

src/Tqdev/PhpCrudApi/Controller/ColumnController.php

 <?php
 namespace Tqdev\PhpCrudApi\Controller;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\DefinitionService;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class ColumnController
 {
         $this->definition = $definition;
     }
 
-    public function getDatabase(ServerRequestInterface $request): Response
+    public function getDatabase(ServerRequestInterface $request): ResponseInterface
     {
         $tables = [];
         foreach ($this->reflection->getTableNames() as $table) {
         return $this->responder->success($database);
     }
 
-    public function getTable(ServerRequestInterface $request): Response
+    public function getTable(ServerRequestInterface $request): ResponseInterface
     {
         $tableName = RequestUtils::getPathSegment($request, 2);
         if (!$this->reflection->hasTable($tableName)) {
         return $this->responder->success($table);
     }
 
-    public function getColumn(ServerRequestInterface $request): Response
+    public function getColumn(ServerRequestInterface $request): ResponseInterface
     {
         $tableName = RequestUtils::getPathSegment($request, 2);
         $columnName = RequestUtils::getPathSegment($request, 3);
         return $this->responder->success($column);
     }
 
-    public function updateTable(ServerRequestInterface $request): Response
+    public function updateTable(ServerRequestInterface $request): ResponseInterface
     {
         $tableName = RequestUtils::getPathSegment($request, 2);
         if (!$this->reflection->hasTable($tableName)) {
         return $this->responder->success($success);
     }
 
-    public function updateColumn(ServerRequestInterface $request): Response
+    public function updateColumn(ServerRequestInterface $request): ResponseInterface
     {
         $tableName = RequestUtils::getPathSegment($request, 2);
         $columnName = RequestUtils::getPathSegment($request, 3);
         return $this->responder->success($success);
     }
 
-    public function addTable(ServerRequestInterface $request): Response
+    public function addTable(ServerRequestInterface $request): ResponseInterface
     {
         $tableName = $request->getParsedBody()->name;
         if ($this->reflection->hasTable($tableName)) {
         return $this->responder->success($success);
     }
 
-    public function addColumn(ServerRequestInterface $request): Response
+    public function addColumn(ServerRequestInterface $request): ResponseInterface
     {
         $tableName = RequestUtils::getPathSegment($request, 2);
         if (!$this->reflection->hasTable($tableName)) {
         return $this->responder->success($success);
     }
 
-    public function removeTable(ServerRequestInterface $request): Response
+    public function removeTable(ServerRequestInterface $request): ResponseInterface
     {
         $tableName = RequestUtils::getPathSegment($request, 2);
         if (!$this->reflection->hasTable($tableName)) {
         return $this->responder->success($success);
     }
 
-    public function removeColumn(ServerRequestInterface $request): Response
+    public function removeColumn(ServerRequestInterface $request): ResponseInterface
     {
         $tableName = RequestUtils::getPathSegment($request, 2);
         $columnName = RequestUtils::getPathSegment($request, 3);

src/Tqdev/PhpCrudApi/Controller/OpenApiController.php

 <?php
 namespace Tqdev\PhpCrudApi\Controller;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\OpenApi\OpenApiService;
-use Tqdev\PhpCrudApi\Response;
 
 class OpenApiController
 {
         $this->responder = $responder;
     }
 
-    public function openapi(ServerRequestInterface $request): Response
+    public function openapi(ServerRequestInterface $request): ResponseInterface
     {
         return $this->responder->success($this->openApi->get());
     }

src/Tqdev/PhpCrudApi/Controller/RecordController.php

 <?php
 namespace Tqdev\PhpCrudApi\Controller;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\Record\RecordService;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class RecordController
 {
         $this->responder = $responder;
     }
 
-    public function _list(ServerRequestInterface $request): Response
+    public function _list(ServerRequestInterface $request): ResponseInterface
     {
         $table = RequestUtils::getPathSegment($request, 2);
         $params = RequestUtils::getParams($request);
         return $this->responder->success($this->service->_list($table, $params));
     }
 
-    public function read(ServerRequestInterface $request): Response
+    public function read(ServerRequestInterface $request): ResponseInterface
     {
         $table = RequestUtils::getPathSegment($request, 2);
         if (!$this->service->hasTable($table)) {
         }
     }
 
-    public function create(ServerRequestInterface $request): Response
+    public function create(ServerRequestInterface $request): ResponseInterface
     {
         $table = RequestUtils::getPathSegment($request, 2);
         if (!$this->service->hasTable($table)) {
         }
     }
 
-    public function update(ServerRequestInterface $request): Response
+    public function update(ServerRequestInterface $request): ResponseInterface
     {
         $table = RequestUtils::getPathSegment($request, 2);
         if (!$this->service->hasTable($table)) {
         }
     }
 
-    public function delete(ServerRequestInterface $request): Response
+    public function delete(ServerRequestInterface $request): ResponseInterface
     {
         $table = RequestUtils::getPathSegment($request, 2);
         if (!$this->service->hasTable($table)) {
         }
     }
 
-    public function increment(ServerRequestInterface $request): Response
+    public function increment(ServerRequestInterface $request): ResponseInterface
     {
         $table = RequestUtils::getPathSegment($request, 2);
         if (!$this->service->hasTable($table)) {

src/Tqdev/PhpCrudApi/Controller/Responder.php

 <?php
 namespace Tqdev\PhpCrudApi\Controller;
 
+use Psr\Http\Message\ResponseInterface;
 use Tqdev\PhpCrudApi\Record\Document\ErrorDocument;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
-use Tqdev\PhpCrudApi\Response;
+use Tqdev\PhpCrudApi\ResponseFactory;
 
 class Responder
 {
-    public function error(int $error, string $argument, $details = null): Response
+    public function error(int $error, string $argument, $details = null): ResponseInterface
     {
         $errorCode = new ErrorCode($error);
         $status = $errorCode->getStatus();
         $document = new ErrorDocument($errorCode, $argument, $details);
-        return new Response($status, $document);
+        return ResponseFactory::fromObject($status, $document);
     }
 
-    public function success($result): Response
+    public function success($result): ResponseInterface
     {
-        return new Response(Response::OK, $result);
+        return ResponseFactory::fromObject(ResponseFactory::OK, $result);
     }
 
 }

src/Tqdev/PhpCrudApi/Middleware/AjaxOnlyMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class AjaxOnlyMiddleware extends Middleware
 {
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $method = $request->getMethod();
         $excludeMethods = $this->getArrayProperty('excludeMethods', 'OPTIONS,GET');

src/Tqdev/PhpCrudApi/Middleware/AuthorizationMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\FilterInfo;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class AuthorizationMiddleware extends Middleware
 {
         }
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $path = RequestUtils::getPathSegment($request, 1);
         $operation = RequestUtils::getOperation($request);

src/Tqdev/PhpCrudApi/Middleware/Base/Handler.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware\Base;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use Tqdev\PhpCrudApi\Response;
 
 interface Handler
 {
-    public function handle(ServerRequestInterface $request): Response;
+    public function handle(ServerRequestInterface $request): ResponseInterface;
 }

src/Tqdev/PhpCrudApi/Middleware/BasicAuthMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class BasicAuthMiddleware extends Middleware
 {
         return base64_decode(strtr($parts[1], '-_', '+/'));
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         if (session_status() == PHP_SESSION_NONE) {
             session_start();
             if ($authenticationMode == 'required') {
                 $response = $this->responder->error(ErrorCode::AUTHENTICATION_REQUIRED, '');
                 $realm = $this->getProperty('realm', 'Username and password required');
-                $response->addHeader('WWW-Authenticate', "Basic realm=\"$realm\"");
+                $response = $response->withHeader('WWW-Authenticate', "Basic realm=\"$realm\"");
                 return $response;
             }
         }

src/Tqdev/PhpCrudApi/Middleware/CorsMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
-use Tqdev\PhpCrudApi\Response;
+use Tqdev\PhpCrudApi\ResponseFactory;
 
 class CorsMiddleware extends Middleware
 {
         return $found;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $method = $request->getMethod();
         $origin = count($request->getHeader('Origin')) ? $request->getHeader('Origin')[0] : '';
         if ($origin && !$this->isOriginAllowed($origin, $allowedOrigins)) {
             $response = $this->responder->error(ErrorCode::ORIGIN_FORBIDDEN, $origin);
         } elseif ($method == 'OPTIONS') {
-            $response = new Response(Response::OK, '');
+            $response = ResponseFactory::fromStatus(ResponseFactory::OK);
             $allowHeaders = $this->getProperty('allowHeaders', 'Content-Type, X-XSRF-TOKEN, X-Authorization');
             if ($allowHeaders) {
-                $response->addHeader('Access-Control-Allow-Headers', $allowHeaders);
+                $response = $response->withHeader('Access-Control-Allow-Headers', $allowHeaders);
             }
             $allowMethods = $this->getProperty('allowMethods', 'OPTIONS, GET, PUT, POST, DELETE, PATCH');
             if ($allowMethods) {
-                $response->addHeader('Access-Control-Allow-Methods', $allowMethods);
+                $response = $response->withHeader('Access-Control-Allow-Methods', $allowMethods);
             }
             $allowCredentials = $this->getProperty('allowCredentials', 'true');
             if ($allowCredentials) {
-                $response->addHeader('Access-Control-Allow-Credentials', $allowCredentials);
+                $response = $response->withHeader('Access-Control-Allow-Credentials', $allowCredentials);
             }
             $maxAge = $this->getProperty('maxAge', '1728000');
             if ($maxAge) {
-                $response->addHeader('Access-Control-Max-Age', $maxAge);
+                $response = $response->withHeader('Access-Control-Max-Age', $maxAge);
             }
             $exposeHeaders = $this->getProperty('exposeHeaders', '');
             if ($exposeHeaders) {
-                $response->addHeader('Access-Control-Expose-Headers', $exposeHeaders);
+                $response = $response->withHeader('Access-Control-Expose-Headers', $exposeHeaders);
             }
         } else {
             $response = $this->next->handle($request);
         if ($origin) {
             $allowCredentials = $this->getProperty('allowCredentials', 'true');
             if ($allowCredentials) {
-                $response->addHeader('Access-Control-Allow-Credentials', $allowCredentials);
+                $response = $response->withHeader('Access-Control-Allow-Credentials', $allowCredentials);
             }
-            $response->addHeader('Access-Control-Allow-Origin', $origin);
+            $response = $response->withHeader('Access-Control-Allow-Origin', $origin);
         }
         return $response;
     }

src/Tqdev/PhpCrudApi/Middleware/CustomizationMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class CustomizationMiddleware extends Middleware
 {
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         $tableName = RequestUtils::getPathSegment($request, 2);
         $beforeHandler = $this->getProperty('beforeHandler', '');
         $environment = (object) array();
         if ($beforeHandler !== '') {
-            call_user_func($beforeHandler, $operation, $tableName, $request, $environment);
+            $result = call_user_func($beforeHandler, $operation, $tableName, $request, $environment);
+            $request = $result ?: $request;
         }
         $response = $this->next->handle($request);
         $afterHandler = $this->getProperty('afterHandler', '');
         if ($afterHandler !== '') {
-            call_user_func($afterHandler, $operation, $tableName, $response, $environment);
+            $result = call_user_func($afterHandler, $operation, $tableName, $response, $environment);
+            $response = $result ?: $response;
         }
         return $response;
     }

src/Tqdev/PhpCrudApi/Middleware/FirewallMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
-use Tqdev\PhpCrudApi\Response;
 
 class FirewallMiddleware extends Middleware
 {
         return false;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $reverseProxy = $this->getProperty('reverseProxy', '');
         if ($reverseProxy) {

src/Tqdev/PhpCrudApi/Middleware/IpAddressMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class IpAddressMiddleware extends Middleware
 {
         return (object) $context;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {

src/Tqdev/PhpCrudApi/Middleware/JoinLimitsMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Communication\VariableStore;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class JoinLimitsMiddleware extends Middleware
 {
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         $params = RequestUtils::getParams($request);

src/Tqdev/PhpCrudApi/Middleware/JwtAuthMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class JwtAuthMiddleware extends Middleware
 {
         return $parts[1];
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         if (session_status() == PHP_SESSION_NONE) {
             session_start();

src/Tqdev/PhpCrudApi/Middleware/MultiTenancyMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Record\Condition\Condition;
 use Tqdev\PhpCrudApi\Record\Condition\NoCondition;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class MultiTenancyMiddleware extends Middleware
 {
         return $request->withParsedBody($multi ? $records : $records[0]);
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $handler = $this->getProperty('handler', '');
         if ($handler !== '') {

src/Tqdev/PhpCrudApi/Middleware/PageLimitsMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class PageLimitsMiddleware extends Middleware
 {
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if ($operation == 'list') {

src/Tqdev/PhpCrudApi/Middleware/Router/Router.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware\Router;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Middleware\Base\Handler;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
-use Tqdev\PhpCrudApi\Response;
 
 interface Router extends Handler
 {
 
     public function load(Middleware $middleware);
 
-    public function route(ServerRequestInterface $request): Response;
+    public function route(ServerRequestInterface $request): ResponseInterface;
 }

src/Tqdev/PhpCrudApi/Middleware/Router/SimpleRouter.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware\Router;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Cache\Cache;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\Record\PathTree;
-use Tqdev\PhpCrudApi\Response;
 
 class SimpleRouter implements Router
 {
         array_unshift($this->middlewares, $middleware);
     }
 
-    public function route(ServerRequestInterface $request): Response
+    public function route(ServerRequestInterface $request): ResponseInterface
     {
         if ($this->registration) {
             $data = gzcompress(json_encode($this->routes, JSON_UNESCAPED_UNICODE));
         return $this->routes->match($path);
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $routeNumbers = $this->getRouteNumbers($request);
         if (count($routeNumbers) == 0) {

src/Tqdev/PhpCrudApi/Middleware/SanitationMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class SanitationMiddleware extends Middleware
 {
         return (object) $context;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {

src/Tqdev/PhpCrudApi/Middleware/ValidationMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\RequestUtils;
-use Tqdev\PhpCrudApi\Response;
 
 class ValidationMiddleware extends Middleware
 {
         $this->reflection = $reflection;
     }
 
-    private function callHandler($handler, $record, string $operation, ReflectedTable $table) /*: Response?*/
+    private function callHandler($handler, $record, string $operation, ReflectedTable $table) /*: ResponseInterface?*/
     {
         $context = (array) $record;
         $details = array();
         return null;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {

src/Tqdev/PhpCrudApi/Middleware/XsrfMiddleware.php

 <?php
 namespace Tqdev\PhpCrudApi\Middleware;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
-use Tqdev\PhpCrudApi\Response;
 
 class XsrfMiddleware extends Middleware
 {
         return $token;
     }
 
-    public function handle(ServerRequestInterface $request): Response
+    public function handle(ServerRequestInterface $request): ResponseInterface
     {
         $token = $this->getToken();
         $method = $request->getMethod();

src/Tqdev/PhpCrudApi/Record/ErrorCode.php

 <?php
 namespace Tqdev\PhpCrudApi\Record;
 
-use Tqdev\PhpCrudApi\Response;
+use Tqdev\PhpCrudApi\ResponseFactory;
 
 class ErrorCode
 {
     const PAGINATION_FORBIDDEN = 1019;
 
     private $values = [
-        9999 => ["%s", Response::INTERNAL_SERVER_ERROR],
-        1000 => ["Route '%s' not found", Response::NOT_FOUND],
-        1001 => ["Table '%s' not found", Response::NOT_FOUND],
-        1002 => ["Argument count mismatch in '%s'", Response::UNPROCESSABLE_ENTITY],
-        1003 => ["Record '%s' not found", Response::NOT_FOUND],
-        1004 => ["Origin '%s' is forbidden", Response::FORBIDDEN],
-        1005 => ["Column '%s' not found", Response::NOT_FOUND],
-        1006 => ["Table '%s' already exists", Response::CONFLICT],
-        1007 => ["Column '%s' already exists", Response::CONFLICT],
-        1008 => ["Cannot read HTTP message", Response::UNPROCESSABLE_ENTITY],
-        1009 => ["Duplicate key exception", Response::CONFLICT],
-        1010 => ["Data integrity violation", Response::CONFLICT],
-        1011 => ["Authentication required", Response::UNAUTHORIZED],
-        1012 => ["Authentication failed for '%s'", Response::FORBIDDEN],
-        1013 => ["Input validation failed for '%s'", Response::UNPROCESSABLE_ENTITY],
-        1014 => ["Operation forbidden", Response::FORBIDDEN],
-        1015 => ["Operation '%s' not supported", Response::METHOD_NOT_ALLOWED],
-        1016 => ["Temporary or permanently blocked", Response::FORBIDDEN],
-        1017 => ["Bad or missing XSRF token", Response::FORBIDDEN],
-        1018 => ["Only AJAX requests allowed for '%s'", Response::FORBIDDEN],
-        1019 => ["Pagination forbidden", Response::FORBIDDEN],
+        9999 => ["%s", ResponseFactory::INTERNAL_SERVER_ERROR],
+        1000 => ["Route '%s' not found", ResponseFactory::NOT_FOUND],
+        1001 => ["Table '%s' not found", ResponseFactory::NOT_FOUND],
+        1002 => ["Argument count mismatch in '%s'", ResponseFactory::UNPROCESSABLE_ENTITY],
+        1003 => ["Record '%s' not found", ResponseFactory::NOT_FOUND],
+        1004 => ["Origin '%s' is forbidden", ResponseFactory::FORBIDDEN],
+        1005 => ["Column '%s' not found", ResponseFactory::NOT_FOUND],
+        1006 => ["Table '%s' already exists", ResponseFactory::CONFLICT],
+        1007 => ["Column '%s' already exists", ResponseFactory::CONFLICT],
+        1008 => ["Cannot read HTTP message", ResponseFactory::UNPROCESSABLE_ENTITY],
+        1009 => ["Duplicate key exception", ResponseFactory::CONFLICT],
+        1010 => ["Data integrity violation", ResponseFactory::CONFLICT],
+        1011 => ["Authentication required", ResponseFactory::UNAUTHORIZED],
+        1012 => ["Authentication failed for '%s'", ResponseFactory::FORBIDDEN],
+        1013 => ["Input validation failed for '%s'", ResponseFactory::UNPROCESSABLE_ENTITY],
+        1014 => ["Operation forbidden", ResponseFactory::FORBIDDEN],
+        1015 => ["Operation '%s' not supported", ResponseFactory::METHOD_NOT_ALLOWED],
+        1016 => ["Temporary or permanently blocked", ResponseFactory::FORBIDDEN],
+        1017 => ["Bad or missing XSRF token", ResponseFactory::FORBIDDEN],
+        1018 => ["Only AJAX requests allowed for '%s'", ResponseFactory::FORBIDDEN],
+        1019 => ["Pagination forbidden", ResponseFactory::FORBIDDEN],
     ];
 
     public function __construct(int $code)

src/Tqdev/PhpCrudApi/Response.php

-<?php
-namespace Tqdev\PhpCrudApi;
-
-class Response
-{
-    const OK = 200;
-    const UNAUTHORIZED = 401;
-    const FORBIDDEN = 403;
-    const NOT_FOUND = 404;
-    const METHOD_NOT_ALLOWED = 405;
-    const CONFLICT = 409;
-    const UNPROCESSABLE_ENTITY = 422;
-    const INTERNAL_SERVER_ERROR = 500;
-    private $status;
-    private $headers;
-    private $body;
-
-    public function __construct(int $status, $body)
-    {
-        $this->status = $status;
-        $this->headers = array();
-        $this->parseBody($body);
-    }
-
-    private function parseBody($body)
-    {
-        if ($body === '') {
-            $this->body = '';
-        } else {
-            $data = json_encode($body, JSON_UNESCAPED_UNICODE);
-            $this->addHeader('Content-Type', 'application/json');
-            $this->addHeader('Content-Length', strlen($data));
-            $this->body = $data;
-        }
-    }
-
-    public function getStatus(): int
-    {
-        return $this->status;
-    }
-
-    public function getBody(): string
-    {
-        return $this->body;
-    }
-
-    public function addHeader(string $key, string $value)
-    {
-        $this->headers[$key] = $value;
-    }
-
-    public function getHeader(string $key): string
-    {
-        if (isset($this->headers[$key])) {
-            return $this->headers[$key];
-        }
-        return null;
-    }
-
-    public function getHeaders(): array
-    {
-        return $this->headers;
-    }
-
-    public function output()
-    {
-        http_response_code($this->getStatus());
-        foreach ($this->headers as $key => $value) {
-            header("$key: $value");
-        }
-        echo $this->getBody();
-    }
-
-    public function addExceptionHeaders(\Throwable $e)
-    {
-        $this->addHeader('X-Exception-Name', get_class($e));
-        $this->addHeader('X-Exception-Message', $e->getMessage());
-        $this->addHeader('X-Exception-File', $e->getFile() . ':' . $e->getLine());
-    }
-
-    public function __toString(): string
-    {
-        $str = "$this->status\n";
-        foreach ($this->headers as $key => $value) {
-            $str .= "$key: $value\n";
-        }
-        if ($this->body !== '') {
-            $str .= "\n";
-            $str .= "$this->body\n";
-        }
-        return $str;
-    }
-}

src/index.php

 use Tqdev\PhpCrudApi\Api;
 use Tqdev\PhpCrudApi\Config;
 use Tqdev\PhpCrudApi\RequestFactory;
+use Tqdev\PhpCrudApi\ResponseUtils;
 
 // do not reformat the following line
 spl_autoload_register(function ($class) {include str_replace('\\', '/', __DIR__ . "/$class.php");});
 $request = RequestFactory::fromGlobals();
 $api = new Api($config);
 $response = $api->handle($request);
-$response->output();
+ResponseUtils::output($response);

test.php

 use Tqdev\PhpCrudApi\Config;
 use Tqdev\PhpCrudApi\Database\GenericDB;
 use Tqdev\PhpCrudApi\RequestFactory;
+use Tqdev\PhpCrudApi\ResponseUtils;
 
 spl_autoload_register(function ($class) {
     include str_replace('\\', '/', "src\\$class.php");
         $exp = $parts[$i + 1];
         $api = new Api($config);
         $_SERVER['REMOTE_ADDR'] = 'TEST_IP';
-        $out = $api->handle(RequestFactory::fromString($in));
+        $out = ResponseUtils::toString($api->handle(RequestFactory::fromString($in)));
         if ($recording) {
             $parts[$i + 1] = $out;
         } else if ($out != $exp) {

tests/config/base.php

     },
     'customization.afterHandler' => function ($operation, $tableName, $response, $environment) {
         if ($tableName == 'kunsthåndværk' && $operation == 'increment') {
-            $response->addHeader('X-Time-Taken', 0.006/*microtime(true)*/ - $environment->start);
+            return $response->withHeader('X-Time-Taken', 0.006/*microtime(true)*/ - $environment->start);
         }
     },
     'debug' => false,

tests/functional/001_records/041_cors_pre_flight.log

 200
 Access-Control-Allow-Headers: Content-Type, X-XSRF-TOKEN, X-Authorization
 Access-Control-Allow-Methods: OPTIONS, GET, PUT, POST, DELETE, PATCH
-Access-Control-Allow-Credentials: true
 Access-Control-Max-Age: 1728000
+Access-Control-Allow-Credentials: true
 Access-Control-Allow-Origin: http://example.com