v3

Author: fenric

resources/definitions/middlewares/error_handling_middleware.php

@@ -10,7 +10,7 @@
 use Sunrise\Coder\CodecManagerInterface;
 use Sunrise\Coder\Dictionary\MediaType;
 use Sunrise\Coder\MediaTypeInterface;
-use Sunrise\Http\Router\Dictionary\LanguageCode;
+use Sunrise\Http\Router\Dictionary\Language;
 use Sunrise\Http\Router\Middleware\ErrorHandlingMiddleware;
 use Sunrise\Http\Router\OpenApi\Type;
 use Sunrise\Http\Router\View\ErrorView;
@@ -29,7 +29,7 @@
     'router.error_handling_middleware.produced_media_types' => [],
     'router.error_handling_middleware.default_media_type' => MediaType::JSON,
     'router.error_handling_middleware.produced_languages' => [],
-    'router.error_handling_middleware.default_language' => LanguageCode::English,
+    'router.error_handling_middleware.default_language' => Language::English,
     'router.error_handling_middleware.fatal_error_status_code' => null,
     'router.error_handling_middleware.fatal_error_message' => null,
 

resources/definitions/middlewares/payload_decoding_middleware.php

@@ -11,16 +11,12 @@
 
 return [
     'router.payload_decoding_middleware.codec_context' => [],
-    'router.payload_decoding_middleware.error_status_code' => null,
-    'router.payload_decoding_middleware.error_message' => null,
 
     'router.route_middlewares' => add([
         create(PayloadDecodingMiddleware::class)
             ->constructor(
                 codecManager: get(CodecManagerInterface::class),
                 codecContext: get('router.payload_decoding_middleware.codec_context'),
-                errorStatusCode: get('router.payload_decoding_middleware.error_status_code'),
-                errorMessage: get('router.payload_decoding_middleware.error_message'),
             )
     ]),
 ];

src/Dictionary/ErrorMessage.php

@@ -22,8 +22,10 @@ final class ErrorMessage
     public const MALFORMED_URI = 'The request URI is malformed and cannot be accepted by the server.';
     public const RESOURCE_NOT_FOUND = 'The requested resource was not found for this URI.';
     public const METHOD_NOT_ALLOWED = 'The requested method is not allowed for this resource.';
+    public const MISSING_MEDIA_TYPE = 'The request media type is missing.';
+    public const UNSUPPORTED_MEDIA_TYPE = 'The request media type is not supported by this resource.';
     public const INVALID_VARIABLE = 'The value of the variable {{{ variable_name }}} in the request URI "{{ route_uri }}" is invalid.';
-    public const INVALID_QUERY = 'The request parameters are invalid.';
+    public const INVALID_QUERY = 'The request query is invalid.';
     public const MISSING_HEADER = 'The request header "{{ header_name }}" is missing.';
     public const INVALID_HEADER = 'The request header "{{ header_name }}" is invalid.';
     public const MISSING_COOKIE = 'The cookie "{{ cookie_name }}" is missing.';

src/Dictionary/LanguageCode.php renamed to src/Dictionary/Language.php

@@ -18,7 +18,7 @@
 /**
  * @since 3.0.0
  */
-enum LanguageCode: string implements LanguageInterface
+enum Language: string implements LanguageInterface
 {
     case English = 'en';
 

src/Exception/HttpExceptionFactory.php

@@ -58,6 +58,30 @@ public static function methodNotAllowed(
         );
     }
 
+    public static function missingMediaType(
+        ?string $message = null,
+        ?int $code = null,
+        ?Throwable $previous = null,
+    ): HttpException {
+        return new HttpException(
+            $message ?? ErrorMessage::MISSING_MEDIA_TYPE,
+            $code ?? StatusCodeInterface::STATUS_BAD_REQUEST,
+            $previous,
+        );
+    }
+
+    public static function unsupportedMediaType(
+        ?string $message = null,
+        ?int $code = null,
+        ?Throwable $previous = null,
+    ): HttpException {
+        return new HttpException(
+            $message ?? ErrorMessage::UNSUPPORTED_MEDIA_TYPE,
+            $code ?? StatusCodeInterface::STATUS_UNSUPPORTED_MEDIA_TYPE,
+            $previous,
+        );
+    }
+
     public static function invalidVariable(
         ?string $message = null,
         ?int $code = null,

src/Middleware/PayloadDecodingMiddleware.php

@@ -13,15 +13,20 @@
 
 namespace Sunrise\Http\Router\Middleware;
 
+use LogicException;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 use Sunrise\Coder\CodecManagerInterface;
 use Sunrise\Coder\Exception\CodecException;
-use Sunrise\Http\Router\Exception\HttpException;
+use Sunrise\Http\Router\Dictionary\HeaderName;
 use Sunrise\Http\Router\Exception\HttpExceptionFactory;
 use Sunrise\Http\Router\ServerRequest;
+use Sunrise\Http\Router\StringableMediaType;
+
+use function array_map;
+use function sprintf;
 
 /**
  * @since 3.0.0
@@ -34,31 +39,42 @@ final class PayloadDecodingMiddleware implements MiddlewareInterface
     public function __construct(
         private readonly CodecManagerInterface $codecManager,
         private readonly array $codecContext = [],
-        private readonly ?int $errorStatusCode = null,
-        private readonly ?string $errorMessage = null,
     ) {
     }
 
     /**
      * @inheritDoc
-     *
-     * @throws HttpException If the request's payload couldn't be decoded.
      */
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
     {
         $serverRequest = ServerRequest::create($request);
+        $route = $serverRequest->getRoute();
+        $serverConsumedMediaTypes = $route->getConsumedMediaTypes();
+
+        // The server expects nothing from the client, just keep going...
+        if ($serverConsumedMediaTypes === []) {
+            return $handler->handle($request);
+        }
 
         $clientProducedMediaType = $serverRequest->getClientProducedMediaType();
         if ($clientProducedMediaType === null) {
-            return $handler->handle($request);
+            throw HttpExceptionFactory::missingMediaType();
         }
 
         if (!$serverRequest->serverConsumesMediaType($clientProducedMediaType)) {
-            return $handler->handle($request);
+            throw HttpExceptionFactory::unsupportedMediaType()
+                ->addHeaderField(HeaderName::ACCEPT, ...array_map(
+                    StringableMediaType::create(...),
+                    $serverConsumedMediaTypes,
+                ));
         }
 
         if (!$this->codecManager->supportsMediaType($clientProducedMediaType)) {
-            return $handler->handle($request);
+            throw new LogicException(sprintf(
+                'The route "%s" expects the media type "%s" that is not supported by the codec manager.',
+                $route->getName(),
+                $clientProducedMediaType->getIdentifier(),
+            ));
         }
 
         try {
@@ -69,15 +85,9 @@ public function process(ServerRequestInterface $request, RequestHandlerInterface
                 $this->codecContext,
             );
         } catch (CodecException $e) {
-            throw HttpExceptionFactory::invalidBody(
-                $this->errorMessage,
-                $this->errorStatusCode,
-                previous: $e,
-            );
+            throw HttpExceptionFactory::invalidBody(previous: $e);
         }
 
-        return $handler->handle(
-            $request->withParsedBody($parsedBody)
-        );
+        return $handler->handle($request->withParsedBody($parsedBody));
     }
 }

tests/Dictionary/LanguageCodeTest.php renamed to tests/Dictionary/LanguageTest.php

@@ -5,12 +5,12 @@
 namespace Sunrise\Http\Router\Tests\Dictionary;
 
 use PHPUnit\Framework\TestCase;
-use Sunrise\Http\Router\Dictionary\LanguageCode;
+use Sunrise\Http\Router\Dictionary\Language;
 
-final class LanguageCodeTest extends TestCase
+final class LanguageTest extends TestCase
 {
     public function testCode(): void
     {
-        self::assertSame('en', LanguageCode::English->getCode());
+        self::assertSame('en', Language::English->getCode());
     }
 }