Defined custom NotFoundMiddleware for rest routes

module/Core/src/Action/RedirectMiddleware.php

@@ -67,8 +67,8 @@ class RedirectMiddleware implements MiddlewareInterface
         try {
             $longUrl = $this->urlShortener->shortCodeToUrl($shortCode);
 
-            // If provided shortCode does not belong to a valid long URL, dispatch next middleware, which is 404
+            // If provided shortCode does not belong to a valid long URL, dispatch next middleware, which will trigger
-            // middleware
+            // a not-found error
             if (! isset($longUrl)) {
                 return $out($request, $response);
             }

module/Rest/config/middleware-pipeline.config.php

@@ -13,13 +13,12 @@ return [
             'priority' => 5,
         ],
 
-        'rest-error' => [
+        'rest-not-found' => [
             'path' => '/rest',
             'middleware' => [
-                Middleware\Error\ResponseTypeMiddleware::class,
+                Middleware\NotFoundMiddleware::class,
             ],
-            'error'    => true,
+            'priority' => -1,
-            'priority' => -10000,
         ],
     ],
 ];

module/Rest/config/routes.config.php

@@ -23,7 +23,7 @@ return [
             'allowed_methods' => ['GET', 'OPTIONS'],
         ],
         [
-            'name' => 'rest-lActionist-shortened-url',
+            'name' => 'rest-list-shortened-url',
             'path' => '/rest/short-codes',
             'middleware' => Action\ListShortcodesMiddleware::class,
             'allowed_methods' => ['GET'],

module/Rest/config/services.config.php

@@ -19,8 +19,8 @@ return [
 
             Middleware\CrossDomainMiddleware::class => InvokableFactory::class,
             Middleware\CheckAuthenticationMiddleware::class => AnnotatedFactory::class,
-
+            Middleware\ResponseTypeMiddleware::class => AnnotatedFactory::class,
-            Middleware\Error\ResponseTypeMiddleware::class => AnnotatedFactory::class,
+            Middleware\NotFoundMiddleware::class => AnnotatedFactory::class,
         ],
     ],
 

module/Rest/src/Middleware/CheckAuthenticationMiddleware.php

@@ -69,7 +69,9 @@ class CheckAuthenticationMiddleware implements MiddlewareInterface
         // If current route is the authenticate route or an OPTIONS request, continue to the next middleware
         /** @var RouteResult $routeResult */
         $routeResult = $request->getAttribute(RouteResult::class);
-        if ((isset($routeResult) && $routeResult->getMatchedRouteName() === 'rest-authenticate')
+        if (! isset($routeResult)
+            || $routeResult->isFailure()
+            || $routeResult->getMatchedRouteName() === 'rest-authenticate'
             || $request->getMethod() === 'OPTIONS'
         ) {
             return $out($request, $response);

module/Rest/src/Middleware/NotFoundMiddleware.php

@@ -0,0 +1,62 @@
+<?php
+namespace Shlinkio\Shlink\Rest\Middleware;
+
+use Acelaya\ZsmAnnotatedServices\Annotation\Inject;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+use Shlinkio\Shlink\Rest\Util\RestUtils;
+use Zend\Diactoros\Response\JsonResponse;
+use Zend\I18n\Translator\TranslatorInterface;
+use Zend\Stratigility\MiddlewareInterface;
+
+class NotFoundMiddleware implements MiddlewareInterface
+{
+    /**
+     * @var TranslatorInterface
+     */
+    private $translator;
+
+    /**
+     * NotFoundMiddleware constructor.
+     * @param TranslatorInterface $translator
+     *
+     * @Inject({"translator"})
+     */
+    public function __construct(TranslatorInterface $translator)
+    {
+        $this->translator = $translator;
+    }
+
+    /**
+     * Process an incoming request and/or response.
+     *
+     * Accepts a server-side request and a response instance, and does
+     * something with them.
+     *
+     * If the response is not complete and/or further processing would not
+     * interfere with the work done in the middleware, or if the middleware
+     * wants to delegate to another process, it can use the `$out` callable
+     * if present.
+     *
+     * If the middleware does not return a value, execution of the current
+     * request is considered complete, and the response instance provided will
+     * be considered the response to return.
+     *
+     * Alternately, the middleware may return a response instance.
+     *
+     * Often, middleware will `return $out();`, with the assumption that a
+     * later middleware will return a response.
+     *
+     * @param Request $request
+     * @param Response $response
+     * @param null|callable $out
+     * @return null|Response
+     */
+    public function __invoke(Request $request, Response $response, callable $out = null)
+    {
+        return new JsonResponse([
+            'error' => RestUtils::NOT_FOUND_ERROR,
+            'message' => $this->translator->translate('Requested route does not exist.'),
+        ], 404);
+    }
+}

module/Rest/src/Middleware/ResponseTypeMiddleware.php

@@ -1,15 +1,16 @@
 <?php
-namespace Shlinkio\Shlink\Rest\Middleware\Error;
+namespace Shlinkio\Shlink\Rest\Middleware;
 
 use Acelaya\ZsmAnnotatedServices\Annotation\Inject;
 use Psr\Http\Message\ResponseInterface as Response;
 use Psr\Http\Message\ServerRequestInterface as Request;
 use Shlinkio\Shlink\Rest\Util\RestUtils;
 use Zend\Diactoros\Response\JsonResponse;
+use Zend\Expressive\Router\RouteResult;
 use Zend\I18n\Translator\TranslatorInterface;
-use Zend\Stratigility\ErrorMiddlewareInterface;
+use Zend\Stratigility\MiddlewareInterface;
 
-class ResponseTypeMiddleware implements ErrorMiddlewareInterface
+class ResponseTypeMiddleware implements MiddlewareInterface
 {
     /**
      * @var TranslatorInterface
@@ -35,31 +36,37 @@ class ResponseTypeMiddleware implements ErrorMiddlewareInterface
      * delegate to `$out`.
      *
      * @see MiddlewareInterface
-     * @param mixed $error
      * @param Request $request
      * @param Response $response
      * @param null|callable $out
      * @return null|Response
      */
-    public function __invoke($error, Request $request, Response $response, callable $out = null)
+    public function __invoke(Request $request, Response $response, callable $out = null)
     {
         $accept = $request->getHeader('Accept');
         if (! empty(array_intersect(['application/json', 'text/json', 'application/x-json'], $accept))) {
-            $status = $this->determineStatus($response);
+            $status = $this->determineStatus($request, $response);
             $errorData = $this->determineErrorCode($request, $status);
 
             return new JsonResponse($errorData, $status);
         }
 
-        return $out($request, $response, $error);
+        return $out($request, $response);
     }
 
     /**
+     * @param Request $request
      * @param Response $response
      * @return int
      */
-    protected function determineStatus(Response $response)
+    protected function determineStatus(Request $request, Response $response)
     {
+        /** @var RouteResult $routeResult */
+        $routeResult = $request->getAttribute(RouteResult::class);
+        if ($routeResult->isFailure()) {
+            return 404;
+        }
+
         $status = $response->getStatusCode();
         return $status >= 400 ? $status : 500;
     }