feat(router): support getting raw body from requests (#1093)

Co-authored-by: Brent Roose <[email protected]>

Author: innocenzi

src/Tempest/Router/src/Input/StdinInputStream.php

@@ -13,7 +13,7 @@ public function parse(): array
         $input = file_get_contents('php://input');
 
         if (json_validate($input)) {
-            return json_decode($input, true);
+            return json_decode($input, associative: true);
         }
 
         $inputStreamData = str($input)

src/Tempest/Router/src/IsRequest.php

@@ -11,6 +11,8 @@
 use Tempest\Validation\SkipValidation;
 
 use function Tempest\get;
+use function Tempest\Support\Arr\get_by_key;
+use function Tempest\Support\Arr\has;
 
 /** @phpstan-require-implements \Tempest\Router\Request */
 trait IsRequest
@@ -21,6 +23,9 @@ trait IsRequest
     #[SkipValidation]
     private(set) string $uri;
 
+    #[SkipValidation]
+    private(set) ?string $raw = null;
+
     #[SkipValidation]
     private(set) array $body = [];
 
@@ -48,12 +53,14 @@ public function __construct(
         array $body = [],
         array $headers = [],
         array $files = [],
+        ?string $raw = null,
     ) {
         $this->method = $method;
         $this->uri = $uri;
         $this->body = $body;
         $this->headers = RequestHeaders::normalizeFromArray($headers);
         $this->files = $files;
+        $this->raw = $raw;
 
         $this->path ??= $this->resolvePath();
         $this->query ??= $this->resolveQuery();
@@ -62,11 +69,11 @@ public function __construct(
     public function get(string $key, mixed $default = null): mixed
     {
         if (array_key_exists($key, $this->body)) {
-            return $this->body[$key];
+            return get_by_key($this->body, $key);
         }
 
         if (array_key_exists($key, $this->query)) {
-            return $this->query[$key];
+            return get_by_key($this->query, $key);
         }
 
         return $default;
@@ -116,13 +123,17 @@ public function has(string $key): bool
         return $this->hasQuery($key);
     }
 
-    public function hasBody(string $key): bool
+    public function hasBody(?string $key = null): bool
     {
-        return array_key_exists($key, $this->body);
+        if ($key) {
+            return has($this->body, $key);
+        }
+
+        return count($this->body) || ((bool) $this->raw);
     }
 
     public function hasQuery(string $key): bool
     {
-        return array_key_exists($key, $this->query);
+        return has($this->query, $key);
     }
 }

src/Tempest/Router/src/Mappers/PsrRequestToGenericRequestMapper.php

@@ -26,13 +26,10 @@ public function map(mixed $from, mixed $to): GenericRequest
     {
         /** @var PsrRequest $from */
         $data = (array) $from->getParsedBody();
+        $raw = $from->getBody()->getContents();
 
-        if (arr($from->getHeader('content-type'))->contains('application/json')) {
-            $bodyContents = $from->getBody()->getContents();
-
-            if (json_validate($bodyContents)) {
-                $data = [...$data, ...json_decode($bodyContents, true)];
-            }
+        if (arr($from->getHeader('content-type'))->contains('application/json') && json_validate($raw)) {
+            $data = [...$data, ...json_decode($raw, associative: true)];
         }
 
         $headersAsString = array_map(
@@ -50,6 +47,7 @@ public function map(mixed $from, mixed $to): GenericRequest
         return map([
             'method' => Method::from($from->getMethod()),
             'uri' => (string) $from->getUri(),
+            'raw' => $raw,
             'body' => $data,
             'headers' => RequestHeaders::normalizeFromArray($headersAsString),
             'path' => $from->getUri()->getPath(),

src/Tempest/Router/src/Request.php

@@ -17,6 +17,10 @@ interface Request
         get;
     }
 
+    public ?string $raw {
+        get;
+    }
+
     public array $body {
         get;
     }

tests/Integration/Mapper/PsrRequestToRequestMapperTest.php

@@ -4,19 +4,16 @@
 
 namespace Tests\Tempest\Integration\Mapper;
 
+use Laminas\Diactoros\ServerRequest;
+use Laminas\Diactoros\Stream;
 use Laminas\Diactoros\UploadedFile;
-use Tempest\Mapper\Exceptions\MissingValuesException;
+use Laminas\Diactoros\Uri;
 use Tempest\Router\GenericRequest;
 use Tempest\Router\Mappers\PsrRequestToGenericRequestMapper;
 use Tempest\Router\Request;
 use Tempest\Router\Upload;
-use Tests\Tempest\Fixtures\Modules\Books\Requests\CreateBookRequest;
-use Tests\Tempest\Fixtures\Modules\Posts\PostRequest;
 use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
 
-use function Tempest\map;
-use function Tempest\Support\arr;
-
 /**
  * @internal
  */
@@ -34,6 +31,25 @@ public function test_generic_request_is_used_when_interface_is_passed(): void
         $this->assertInstanceOf(GenericRequest::class, $request);
     }
 
+    public function test_raw(): void
+    {
+        $stream = new Stream(fopen('php://memory', 'r+'));
+        $stream->write(json_encode(['foo' => 'bar']));
+        $stream->rewind();
+
+        $request = new PsrRequestToGenericRequestMapper()->map(new ServerRequest(
+            uri: new Uri('/json-endpoint'),
+            method: 'POST',
+            body: $stream,
+            headers: [
+                'Content-Type' => 'application/json',
+            ],
+        ), to: Request::class);
+
+        $this->assertEquals(json_encode(['foo' => 'bar']), $request->raw);
+        $this->assertEquals(['foo' => 'bar'], $request->body);
+    }
+
     public function test_files(): void
     {
         $currentPath = __DIR__ . '/Fixtures/upload-current.txt';

tests/Integration/Route/RequestTest.php

@@ -4,6 +4,7 @@
 
 namespace Tests\Tempest\Integration\Route;
 
+use PHPUnit\Framework\Attributes\TestWith;
 use Tempest\Database\Id;
 use Tempest\Database\Migrations\CreateMigrationsTable;
 use Tempest\Http\Method;
@@ -176,6 +177,9 @@ public function test_has(): void
             uri: '/?bar',
             body: [
                 'foo' => false,
+                'nested' => [
+                    'baz' => 'quux',
+                ],
             ],
         );
 
@@ -188,5 +192,26 @@ public function test_has(): void
         $this->assertFalse($request->hasBody('unknown'));
         $this->assertFalse($request->hasQuery('unknown'));
         $this->assertFalse($request->has('unknown'));
+        $this->assertTrue($request->has('nested.baz'));
+        $this->assertFalse($request->has('nested.bar'));
+        $this->assertTrue($request->hasBody('nested.baz'));
+        $this->assertFalse($request->hasBody('nested.bar'));
+    }
+
+    #[TestWith([[], null, false])]
+    #[TestWith([[], '', false])]
+    #[TestWith([[], 'foo', true])]
+    #[TestWith([['foo' => 'bar'], null, true])]
+    #[TestWith([['foo' => 'bar'], 'foo', true])]
+    public function test_body(array $body, ?string $raw, bool $expected): void
+    {
+        $request = new GenericRequest(
+            method: Method::GET,
+            uri: '/?bar',
+            body: $body,
+            raw: $raw,
+        );
+
+        $this->assertSame($expected, $request->hasBody());
     }
 }