Add query() route method for the HTTP QUERY verb (RFC 10008)

The HTTP QUERY method was recently published as RFC 10008 on the
IETF Standards Track. It is a safe, cacheable method that carries
its query in the request body, enabling expressive queries without
the URL-length and cacheability trade-offs of GET vs. POST.

Support for QUERY is landing across the ecosystem
(https://www.rfc-editor.org/rfc/rfc10008), so this adds a query()
helper as a sibling of the existing get()/post()/put()/patch()/
delete()/options() route methods on RouteCollectorProxyInter
implemented via the existing map() mechanism:
```
$app->query('/search', function (Request $request, Response $response) {
        $criteria = (string) $request->getBody();
        // ...run the query described in the request body...
        return $response;
    });
```
`$app->query()` is equivalent to `$app->map(['QUERY'], ...)` and is not added to any(), so existing any() routes are unaffected.

Author: thinkliveid

CHANGELOG.md

@@ -6,6 +6,8 @@
 
 ### Added
 
+- Add `query()` route helper for the HTTP `QUERY` method ([RFC 10008](https://www.rfc-editor.org/rfc/rfc10008))
+
 ### Changed
 
 ### Removed

Slim/Interfaces/RouteCollectorProxyInterface.php

@@ -90,6 +90,16 @@ public function delete(string $pattern, $callable): RouteInterface;
      */
     public function options(string $pattern, $callable): RouteInterface;
 
+    /**
+     * Add QUERY route
+     *
+     * @param string $pattern The route URI pattern
+     * @param callable|array{class-string, string}|string $callable The route callback routine
+     *
+     * @link https://www.rfc-editor.org/rfc/rfc10008
+     */
+    public function query(string $pattern, $callable): RouteInterface;
+
     /**
      * Add route for any HTTP method
      *

Slim/Routing/RouteCollectorProxy.php

@@ -151,6 +151,14 @@ public function options(string $pattern, $callable): RouteInterface
         return $this->map(['OPTIONS'], $pattern, $callable);
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function query(string $pattern, $callable): RouteInterface
+    {
+        return $this->map(['QUERY'], $pattern, $callable);
+    }
+
     /**
      * {@inheritdoc}
      */

tests/AppTest.php

@@ -241,6 +241,38 @@ public function testAnyRoute(): void
         }
     }
 
+    public function testQueryRoute(): void
+    {
+        $streamProphecy = $this->prophesize(StreamInterface::class);
+        $streamProphecy->__toString()->willReturn('Hello World');
+
+        $responseProphecy = $this->prophesize(ResponseInterface::class);
+        $responseProphecy->getBody()->willReturn($streamProphecy->reveal());
+
+        $responseFactoryProphecy = $this->prophesize(ResponseFactoryInterface::class);
+        $responseFactoryProphecy->createResponse()->willReturn($responseProphecy->reveal());
+
+        $uriProphecy = $this->prophesize(UriInterface::class);
+        $uriProphecy->getPath()->willReturn('/');
+
+        $requestProphecy = $this->prophesize(ServerRequestInterface::class);
+        $requestProphecy->getMethod()->willReturn('QUERY');
+        $requestProphecy->getUri()->willReturn($uriProphecy->reveal());
+        $requestProphecy->getAttribute(RouteContext::ROUTING_RESULTS)->willReturn(null);
+        $requestProphecy->withAttribute(Argument::type('string'), Argument::any())->will(function ($args) {
+            $this->getAttribute($args[0])->willReturn($args[1]);
+            return $this;
+        });
+
+        $app = new App($responseFactoryProphecy->reveal());
+        $app->query('/', function (ServerRequestInterface $request, ResponseInterface $response) {
+            return $response;
+        });
+        $response = $app->handle($requestProphecy->reveal());
+
+        $this->assertSame('Hello World', (string) $response->getBody());
+    }
+
     /********************************************************************************
      * Route collector proxy methods
      *******************************************************************************/

tests/Routing/RouteCollectorProxyTest.php

@@ -317,6 +317,39 @@ public function testOptions()
         $this->assertSame($pattern, $route->getPattern());
     }
 
+    public function testQuery()
+    {
+        $responseFactoryProphecy = $this->prophesize(ResponseFactoryInterface::class);
+        $callableResolverProphecy = $this->prophesize(CallableResolverInterface::class);
+
+        $pattern = '/';
+        $callable = function () {
+        };
+
+        $routeProphecy = $this->prophesize(RouteInterface::class);
+        $routeProphecy
+            ->getPattern()
+            ->willReturn($pattern)
+            ->shouldBeCalledOnce();
+
+        $routeCollectorProphecy = $this->prophesize(RouteCollectorInterface::class);
+        $routeCollectorProphecy
+            ->map(['QUERY'], $pattern, Argument::is($callable))
+            ->willReturn($routeProphecy->reveal())
+            ->shouldBeCalledOnce();
+
+        $routeCollectorProxy = new RouteCollectorProxy(
+            $responseFactoryProphecy->reveal(),
+            $callableResolverProphecy->reveal(),
+            null,
+            $routeCollectorProphecy->reveal()
+        );
+
+        $route = $routeCollectorProxy->query($pattern, $callable);
+
+        $this->assertSame($pattern, $route->getPattern());
+    }
+
     public function testAny()
     {
         $responseFactoryProphecy = $this->prophesize(ResponseFactoryInterface::class);