implement ServerRequestInterface

src/Controller.php

@@ -20,20 +20,29 @@
 use Chevere\Parameter\Interfaces\ArrayParameterInterface;
 use Chevere\Parameter\Interfaces\ArrayStringParameterInterface;
 use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\UploadedFileInterface;
 use function Chevere\Parameter\arguments;
 use function Chevere\Parameter\arrayp;
 use function Chevere\Parameter\arrayString;
 
 abstract class Controller extends BaseController implements ControllerInterface
 {
+    /**
+     * @var array<string, mixed>
+     */
+    public array $_attributes;
+
+    /**
+     * @var array<string, mixed>
+     */
+    public array $_serverParams;
+
     private ?ArgumentsInterface $_query = null;
 
     private ?ArgumentsInterface $_body = null;
 
-    /**
-     * @var ?array<ArgumentsInterface>
-     */
-    private ?array $_files = null;
+    private ?ArgumentsInterface $_files = null;
 
     public static function acceptQuery(): ArrayStringParameterInterface
     {
@@ -55,38 +64,20 @@ public function terminate(ResponseInterface $response): ResponseInterface
         return $response;
     }
 
-    final public function withQuery(array $query): static
-    {
-        $new = clone $this;
-        $new->_query = arguments($new::acceptQuery()->parameters(), $query);
-
-        return $new;
-    }
-
-    final public function withBody(array $body): static
+    final public function withServerRequest(ServerRequestInterface $serverRequest): static
     {
         $new = clone $this;
-        $new->_body = arguments($new::acceptBody()->parameters(), $body);
-
-        return $new;
-    }
-
-    final public function withFiles(array $files): static
-    {
-        $new = clone $this;
-        $array = [];
-        $parameters = $new->acceptFiles()->parameters();
-        foreach ($files as $key => $file) {
-            $key = strval($key);
-            $parameters->assertHas($key);
-            $collection = match (true) {
-                $parameters->requiredKeys()->contains($key) => $parameters->required($key),
-                default => $parameters->optional($key),
-            };
-            $arguments = arguments($collection->array(), $file);
-            $array[$key] = $arguments;
-        }
-        $new->_files = $array;
+        $new->_query = arguments(
+            $new::acceptQuery()->parameters(),
+            $serverRequest->getQueryParams()
+        );
+        $new->_body = arguments(
+            $new::acceptBody()->parameters(),
+            (array) ($serverRequest->getParsedBody() ?? [])
+        );
+        $new->_serverParams = $serverRequest->getServerParams();
+        $new->_attributes = $serverRequest->getAttributes();
+        $new->setFiles($serverRequest->getUploadedFiles());
 
         return $new;
     }
@@ -103,10 +94,20 @@ final public function body(): ArgumentsInterface
             ??= arguments(static::acceptBody()->parameters(), []);
     }
 
-    final public function files(): array
+    final public function files(): ArgumentsInterface
     {
         return $this->_files
-            ??= [];
+            ??= arguments(static::acceptFiles()->parameters(), []);
+    }
+
+    final public function serverParams(): array
+    {
+        return $this->_serverParams;
+    }
+
+    final public function attributes(): array
+    {
+        return $this->_attributes;
     }
 
     protected function assertRuntime(ReflectionActionInterface $reflection): void
@@ -115,4 +116,26 @@ protected function assertRuntime(ReflectionActionInterface $reflection): void
         $this->body();
         $this->files();
     }
+
+    /**
+     * @param array<string, UploadedFileInterface> $files
+     */
+    protected function setFiles(array $files): void
+    {
+        $arguments = [];
+        $parameters = $this->acceptFiles()->parameters();
+        foreach ($files as $key => $file) {
+            $key = strval($key);
+            $parameters->assertHas($key);
+            $array = [
+                'error' => $file->getError(),
+                'name' => $file->getClientFilename(),
+                'type' => $file->getClientMediaType(),
+                'size' => $file->getSize(),
+                'tmp_name' => $file->getStream()->getMetadata('uri'),
+            ];
+            $arguments[$key] = $array;
+        }
+        $this->_files = arguments($parameters, $arguments);
+    }
 }

src/Interfaces/ControllerInterface.php

@@ -18,6 +18,7 @@
 use Chevere\Parameter\Interfaces\ArrayParameterInterface;
 use Chevere\Parameter\Interfaces\ArrayStringParameterInterface;
 use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
 
 /**
  * Describes the component in charge of defining an Http Controller which adds methods for handling HTTP requests.
@@ -39,29 +40,37 @@ public static function acceptBody(): ArrayParameterInterface;
      */
     public static function acceptFiles(): ArrayParameterInterface;
 
-    /**
-     * @param array<int|string, string> $query
-     */
-    public function withQuery(array $query): static;
-
-    /**
-     * @param array<int|string, mixed> $body
-     */
-    public function withBody(array $body): static;
-
-    /**
-     * @param array<int|string, array<string, int|string>> $files
-     */
-    public function withFiles(array $files): static;
+    public function withServerRequest(ServerRequestInterface $serverRequest): static;
 
     public function query(): ArgumentsInterface;
 
     public function body(): ArgumentsInterface;
 
+    public function files(): ArgumentsInterface;
+
+    /**
+     * Retrieve server parameters.
+     *
+     * Retrieves data related to the incoming request environment,
+     * typically derived from PHP's $_SERVER superglobal. The data IS NOT
+     * REQUIRED to originate from $_SERVER.
+     *
+     * @return array<string, mixed>
+     */
+    public function serverParams(): array;
+
     /**
-     * @return array<ArgumentsInterface>
+     * Retrieve attributes derived from the request.
+     *
+     * The request "attributes" may be used to allow injection of any
+     * parameters derived from the request: e.g., the results of path
+     * match operations; the results of decrypting cookies; the results of
+     * deserializing non-form-encoded message bodies; etc. Attributes
+     * will be application and request specific.
+     *
+     * @return array<string, mixed>
      */
-    public function files(): array;
+    public function attributes(): array;
 
     /**
      * Define a method to handle terminated responses (e.g. set headers, redirects)