wip

api.php

     public function __toString();
 }
 
+// file: src/Psr/Http/Server/MiddlewareInterface.php
+
+interface MiddlewareInterface
+{
+    
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface;
+}
+
+// file: src/Psr/Http/Server/RequestHandlerInterface.php
+
+interface RequestHandlerInterface
+{
+    
+    public function handle(ServerRequestInterface $request): ResponseInterface;
+}
+
 // file: src/Nyholm/Psr7/Factory/Psr17Factory.php
 
 final class Psr17Factory implements RequestFactoryInterface, ResponseFactoryInterface, ServerRequestFactoryInterface, StreamFactoryInterface, UploadedFileFactoryInterface, UriFactoryInterface
     }
 }
 
-// file: src/Tqdev/PhpCrudApi/Middleware/Base/Handler.php
-
-interface Handler
-{
-    public function handle(ServerRequestInterface $request): ResponseInterface;
-}
-
 // file: src/Tqdev/PhpCrudApi/Middleware/Base/Middleware.php
 
-abstract class Middleware implements Handler
+abstract class Middleware implements MiddlewareInterface
 {
     protected $next;
     protected $responder;
         $this->properties = $properties;
     }
 
-    public function setNext(Handler $handler) /*: void*/
-    {
-        $this->next = $handler;
-    }
-
     protected function getArrayProperty(string $key, string $default): array
     {
         return array_filter(array_map('trim', explode(',', $this->getProperty($key, $default))));
 
 // file: src/Tqdev/PhpCrudApi/Middleware/Router/Router.php
 
-interface Router extends Handler
+interface Router extends RequestHandlerInterface
 {
     public function register(string $method, string $path, array $handler);
 
 
     public function load(Middleware $middleware) /*: void*/
     {
-        if (count($this->middlewares) > 0) {
-            $next = $this->middlewares[0];
-        } else {
-            $next = $this;
-        }
-        $middleware->setNext($next);
-        array_unshift($this->middlewares, $middleware);
+        array_push($this->middlewares, $middleware);
     }
 
     public function route(ServerRequestInterface $request): ResponseInterface
             $data = gzcompress(json_encode($this->routes, JSON_UNESCAPED_UNICODE));
             $this->cache->set('PathTree', $data, $this->ttl);
         }
-        $obj = $this;
-        if (count($this->middlewares) > 0) {
-            $obj = $this->middlewares[0];
-        }
-        return $obj->handle($request);
+        return $this->handle($request);
     }
 
     private function getRouteNumbers(ServerRequestInterface $request): array
 
     public function handle(ServerRequestInterface $request): ResponseInterface
     {
+        if (count($this->middlewares)) {
+            $handler = array_pop($this->middlewares);
+            return $handler->process($request, $this);
+        }
+
         $routeNumbers = $this->getRouteNumbers($request);
         if (count($routeNumbers) == 0) {
             return $this->responder->error(ErrorCode::ROUTE_NOT_FOUND, $request->getRequestTarget());
 
 class AjaxOnlyMiddleware extends Middleware
 {
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $method = $request->getMethod();
         $excludeMethods = $this->getArrayProperty('excludeMethods', 'OPTIONS,GET');
                 return $this->responder->error(ErrorCode::ONLY_AJAX_REQUESTS_ALLOWED, $method);
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         }
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $path = RequestUtils::getPathSegment($request, 1);
         $operation = RequestUtils::getOperation($request);
             VariableStore::set('authorization.tableHandler', $this->getProperty('tableHandler', ''));
             VariableStore::set('authorization.columnHandler', $this->getProperty('columnHandler', ''));
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         return base64_decode(strtr($parts[1], '-_', '+/'));
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         if (session_status() == PHP_SESSION_NONE) {
             session_start();
                 return $response;
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         return $found;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $method = $request->getMethod();
         $origin = count($request->getHeader('Origin')) ? $request->getHeader('Origin')[0] : '';
                 $response = $response->withHeader('Access-Control-Expose-Headers', $exposeHeaders);
             }
         } else {
-            $response = $this->next->handle($request);
+            $response = $next->handle($request);
         }
         if ($origin) {
             $allowCredentials = $this->getProperty('allowCredentials', 'true');
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         $tableName = RequestUtils::getPathSegment($request, 2);
             $result = call_user_func($beforeHandler, $operation, $tableName, $request, $environment);
             $request = $result ?: $request;
         }
-        $response = $this->next->handle($request);
+        $response = $next->handle($request);
         $afterHandler = $this->getProperty('afterHandler', '');
         if ($afterHandler !== '') {
             $result = call_user_func($afterHandler, $operation, $tableName, $response, $environment);
         return false;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $reverseProxy = $this->getProperty('reverseProxy', '');
         if ($reverseProxy) {
         if (!$this->isIpAllowed($ipAddress, $allowedIpAddresses)) {
             $response = $this->responder->error(ErrorCode::TEMPORARY_OR_PERMANENTLY_BLOCKED, '');
         } else {
-            $response = $this->next->handle($request);
+            $response = $next->handle($request);
         }
         return $response;
     }
         return (object) $context;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {
                 }
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         $params = RequestUtils::getParams($request);
             $request = RequestUtils::setParams($request, $params);
             VariableStore::set("joinLimits.maxRecords", $maxRecords);
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         return $parts[1];
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         if (session_status() == PHP_SESSION_NONE) {
             session_start();
                 return $this->responder->error(ErrorCode::AUTHENTICATION_REQUIRED, '');
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         return $request->withParsedBody($multi ? $records : $records[0]);
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $handler = $this->getProperty('handler', '');
         if ($handler !== '') {
                 }
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if ($operation == 'list') {
             }
             $request = RequestUtils::setParams($request, $params);
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         return (object) $context;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {
                 }
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         return null;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {
                 }
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 
         return $token;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $token = $this->getToken();
         $method = $request->getMethod();
                 return $this->responder->error(ErrorCode::BAD_OR_MISSING_XSRF_TOKEN, '');
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }
 

src/Nyholm/Psr7/ServerRequest.php

 <?php
 
-declare (strict_types = 1);
+declare(strict_types=1);
 
 namespace Nyholm\Psr7;
 
-use Psr\Http\Message\ServerRequestInterface;
-use Psr\Http\Message\StreamInterface;
-use Psr\Http\Message\UploadedFileInterface;
-use Psr\Http\Message\UriInterface;
+use Psr\Http\Message\{ServerRequestInterface, StreamInterface, UploadedFileInterface, UriInterface};
 
 /**
  * @author Michael Dowling and contributors to guzzlehttp/psr7

src/Tqdev/PhpCrudApi/Middleware/AjaxOnlyMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 
 class AjaxOnlyMiddleware extends Middleware
 {
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $method = $request->getMethod();
         $excludeMethods = $this->getArrayProperty('excludeMethods', 'OPTIONS,GET');
                 return $this->responder->error(ErrorCode::ONLY_AJAX_REQUESTS_ALLOWED, $method);
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/Tqdev/PhpCrudApi/Middleware/AuthorizationMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
         }
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $path = RequestUtils::getPathSegment($request, 1);
         $operation = RequestUtils::getOperation($request);
             VariableStore::set('authorization.tableHandler', $this->getProperty('tableHandler', ''));
             VariableStore::set('authorization.columnHandler', $this->getProperty('columnHandler', ''));
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

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

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

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

 <?php
 namespace Tqdev\PhpCrudApi\Middleware\Base;
 
+use Psr\Http\Server\MiddlewareInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 
-abstract class Middleware implements Handler
+abstract class Middleware implements MiddlewareInterface
 {
     protected $next;
     protected $responder;
         $this->properties = $properties;
     }
 
-    public function setNext(Handler $handler) /*: void*/
-    {
-        $this->next = $handler;
-    }
-
     protected function getArrayProperty(string $key, string $default): array
     {
         return array_filter(array_map('trim', explode(',', $this->getProperty($key, $default))));

src/Tqdev/PhpCrudApi/Middleware/BasicAuthMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
         return base64_decode(strtr($parts[1], '-_', '+/'));
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         if (session_status() == PHP_SESSION_NONE) {
             session_start();
                 return $response;
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/Tqdev/PhpCrudApi/Middleware/CorsMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
         return $found;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $method = $request->getMethod();
         $origin = count($request->getHeader('Origin')) ? $request->getHeader('Origin')[0] : '';
                 $response = $response->withHeader('Access-Control-Expose-Headers', $exposeHeaders);
             }
         } else {
-            $response = $this->next->handle($request);
+            $response = $next->handle($request);
         }
         if ($origin) {
             $allowCredentials = $this->getProperty('allowCredentials', 'true');

src/Tqdev/PhpCrudApi/Middleware/CustomizationMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         $tableName = RequestUtils::getPathSegment($request, 2);
             $result = call_user_func($beforeHandler, $operation, $tableName, $request, $environment);
             $request = $result ?: $request;
         }
-        $response = $this->next->handle($request);
+        $response = $next->handle($request);
         $afterHandler = $this->getProperty('afterHandler', '');
         if ($afterHandler !== '') {
             $result = call_user_func($afterHandler, $operation, $tableName, $response, $environment);

src/Tqdev/PhpCrudApi/Middleware/FirewallMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
         return false;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $reverseProxy = $this->getProperty('reverseProxy', '');
         if ($reverseProxy) {
         if (!$this->isIpAllowed($ipAddress, $allowedIpAddresses)) {
             $response = $this->responder->error(ErrorCode::TEMPORARY_OR_PERMANENTLY_BLOCKED, '');
         } else {
-            $response = $this->next->handle($request);
+            $response = $next->handle($request);
         }
         return $response;
     }

src/Tqdev/PhpCrudApi/Middleware/IpAddressMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
 use Tqdev\PhpCrudApi\Controller\Responder;
         return (object) $context;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {
                 }
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/Tqdev/PhpCrudApi/Middleware/JoinLimitsMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         $params = RequestUtils::getParams($request);
             $request = RequestUtils::setParams($request, $params);
             VariableStore::set("joinLimits.maxRecords", $maxRecords);
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/Tqdev/PhpCrudApi/Middleware/JwtAuthMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
         return $parts[1];
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         if (session_status() == PHP_SESSION_NONE) {
             session_start();
                 return $this->responder->error(ErrorCode::AUTHENTICATION_REQUIRED, '');
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/Tqdev/PhpCrudApi/Middleware/MultiTenancyMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
         return $request->withParsedBody($multi ? $records : $records[0]);
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $handler = $this->getProperty('handler', '');
         if ($handler !== '') {
                 }
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/Tqdev/PhpCrudApi/Middleware/PageLimitsMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
         $this->reflection = $reflection;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if ($operation == 'list') {
             }
             $request = RequestUtils::setParams($request, $params);
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

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

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use Tqdev\PhpCrudApi\Middleware\Base\Handler;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 
-interface Router extends Handler
+interface Router extends RequestHandlerInterface
 {
     public function register(string $method, string $path, array $handler);
 

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

 
     public function load(Middleware $middleware) /*: void*/
     {
-        if (count($this->middlewares) > 0) {
-            $next = $this->middlewares[0];
-        } else {
-            $next = $this;
-        }
-        $middleware->setNext($next);
-        array_unshift($this->middlewares, $middleware);
+        array_push($this->middlewares, $middleware);
     }
 
     public function route(ServerRequestInterface $request): ResponseInterface
             $data = gzcompress(json_encode($this->routes, JSON_UNESCAPED_UNICODE));
             $this->cache->set('PathTree', $data, $this->ttl);
         }
-        $obj = $this;
-        if (count($this->middlewares) > 0) {
-            $obj = $this->middlewares[0];
-        }
-        return $obj->handle($request);
+        return $this->handle($request);
     }
 
     private function getRouteNumbers(ServerRequestInterface $request): array
 
     public function handle(ServerRequestInterface $request): ResponseInterface
     {
+        if (count($this->middlewares)) {
+            $handler = array_pop($this->middlewares);
+            return $handler->process($request, $this);
+        }
+
         $routeNumbers = $this->getRouteNumbers($request);
         if (count($routeNumbers) == 0) {
             return $this->responder->error(ErrorCode::ROUTE_NOT_FOUND, $request->getRequestTarget());

src/Tqdev/PhpCrudApi/Middleware/SanitationMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
 use Tqdev\PhpCrudApi\Controller\Responder;
         return (object) $context;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {
                 }
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/Tqdev/PhpCrudApi/Middleware/ValidationMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
 use Tqdev\PhpCrudApi\Controller\Responder;
         return null;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $operation = RequestUtils::getOperation($request);
         if (in_array($operation, ['create', 'update', 'increment'])) {
                 }
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/Tqdev/PhpCrudApi/Middleware/XsrfMiddleware.php

 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
         return $token;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         $token = $this->getToken();
         $method = $request->getMethod();
                 return $this->responder->error(ErrorCode::BAD_OR_MISSING_XSRF_TOKEN, '');
             }
         }
-        return $this->next->handle($request);
+        return $next->handle($request);
     }
 }

src/clone.sh

 cp -R http-factory/src/* Psr/Http/Message
 rm -Rf http-factory
 
+git clone git@github.com:php-fig/http-server-handler
+mkdir -p Psr/Http/Server
+cp -R http-server-handler/src/* Psr/Http/Server
+rm -Rf http-server-handler
+
+git clone git@github.com:php-fig/http-server-middleware
+mkdir -p Psr/Http/Server
+cp -R http-server-middleware/src/* Psr/Http/Server
+rm -Rf http-server-middleware
+
 git clone git@github.com:Nyholm/psr7.git
 mkdir -p Nyholm/Psr7
 cp -R psr7/src/* Nyholm/Psr7