What are your thoughts about supporting the PSR-7 request and response interfaces in the Request/Response strategy instead of a hard dependency on Symfony HTTP foundation?

@kayladnls @localheinz @hannesvdvreken

Will have documentation ready ASAP. For now, here is a quick example bootstrap using Zend\Diactoros.

https://gist.github.com/philipobenito/b3977c5b5e30fe386c76

route 3.1

I'm curious if I'm doing something wrong, if I have a misconfiguration somewhere or if this is expected. Calling getNamedRoute('the-route-name')->getPath() from the RouteCollection returns the route name, with wildcards, is this expected behaviour?

Example route: $route->get('/the-route/{id:number}/', Action::class.'::index')->setName('the-route-name');

Currently I feel like I'm hacking around it by doing:

        if (strpos($this->route->getNamedRoute($name)->getPath(), '{') !== false) {
            return substr($this->route->getNamedRoute($name)->getPath(), 0,
                strrpos($this->route->getNamedRoute($name)->getPath(), "{"));
        } else {
            return $this->route->getNamedRoute($name)->getPath();
        }

But that's because I'm just unsure if I should be getting the route path with the wildcards or not...

Please provide login for instantiating Controllers with DI Container, because right now I have to write my own strategy and implement a logic for $route->getCallable() which make call inside from file Route.php line 87

My code flow:

class HomeController extends BaseController
{
  public function home($request, $response) {
    return $response;
  }
}

abstract class BaseController
{
  use \League\Container\ContainerAwareTrait;
}
`

Hi,

I have been using your fastroute extension and am enjoying it very much.

I was wondering if you would be interested in a Pull Request which adds a method to pass a configuration array?

    /**
     * Add a collection of routes from a configuration
     * array
     *
     * @param  array $routes
     * @param  \League\Route\Strategy\StrategyInterface $strategy
     * @throws \League\Route\Exception\EmptyRoutingPassedException
     * @throws \League\Route\Exception\MalformedRouteConfigurationException
     */
    public function addRoutesFromConfig(
        array $routes = [],
        Strategy\StrategyInterface $strategy = null
    ) {
        // Check if the array is empty
        if (true === empty($routes)) {
            throw new EmptyRoutingPassedException;
        }

        // Loop through each modules routing data
        foreach ($routes as $module => $route) {
            foreach($route as $name => $body) {
                // Check configuration is passed correctly
                if (
                    false === isset($body['method'])
                    || false === isset($body['pattern'])
                    || false === isset($body['controller'])
                ) {
                    throw new MalformedRouteConfigurationException(
                        sprintf(
                            'The route [%s] in the [%s] section has not been configured correctly',
                            $name,
                            $module
                        )
                    );
                }

                $this->addRoute($body['method'], $body['pattern'], $body['controller'], $strategy);
            }
        }
    }

and then called like:

$routes = [
    'demo_page' => [
        'pattern'    => '/demo/{name}',
        'controller' => 'Demo\Controller\DemoController::index',
        'method'     => 'GET',
    ],
];


$router = new RouteCollection();
$router->setStrategy(new RequestResponseStrategy);
$router->addRoutesFromConfig($routes);

In terms of the exceptions, not sure if they are the best place for them as they are not Http exceptions but more argument exceptions?

READ FURTHER DOWN THREAD FOR UPDATED FUNCTIONALITY

After small discussion, closes #113

Ended up not bringing in an external middleware runner, really wasn't worth it.

As this PR stands

• You can add middleware to the collection to run before or after any matched route.
• You can add middleware to a route group that will only run when a route within that group is matched.
• You can add middleware directly to a route meaning that it will only run if that route is matched.

<?php

$route = new League\Route\RouteCollection;

$route->before(/* callable */);
$route->after(/* callable */);

$route
    ->get('/something', function ($request, $response) {})
    ->before(/* callable */)
    ->after(/* callable */)
;

$route->group('/group', function ($route) {
    $route->get('/', function ($request, $response) {})
        ->before(/* callable */)
        ->after(/* callable */)
    ;
})
    ->before(/* callable */) 
    ->after(/* callable */)
;

As things stand, middleware will be invoked in the following order.

1. Before middleware registered on the collection.
2. Before middleware registered on the group.
3. Before middleware registered on the route.
4. The route callable.
5. After middleware registered on the collection.
6. After middleware registered on the group.
7. After middleware registered on the route.

I'd like some input on how we might swap 5 and 7 around whilst maintaining the order they were actually registered within that section.

Is there a way to add a catch all route that deals with every request that doesn't match one of the other specified routes.

Something like this:

$router->addRoute(
    'GET', '/foo',
    function(Request $request, Response $response)
    {
        // handles GET /foo
    }
);

$router->addCatchAllRoute(function(Request $request, Response $response)
{
    // handles everything else, e.g. POST /foo
});

The MethodArgumentStrategy allows you to inject anything into the controller method.

class HelloController
{
    protected $repository;

    public function __construct(Repository $repository)
    {
        $this->repository = $repository;
    }

    public function index(Validator $validator, Request $request)
    {
         $filter = $request->get('filter');

         $validator->validate(compact('filter'));
         ...
    }
}

But with this simple change you can do this:

class HelloController
{
    protected $repository;

    public function __construct(Repository $repository)
    {
        $this->repository = $repository;
    }

    public function show(ViewFactory $view, $name)
    {
         $user = $this->repository->findByName($name);
         return $view->render('user/show.twig', compact('user'));
    }
}

$router = new League\Route\RouteCollection();
$router->setStrategy(new MethodArgumentStrategy());

$router->get('/user/{name}', 'UserController::show');

$response = $router->getDispatcher()->dispatch('GET', '/users/username');

Was just about to start using this. Even though I feel like it is very bloated, still the features look great.

I wanted my application to be based solely on middleware, and avoid controllers, because I want to force myself to write all functionality in the most re-usable way, and middleware appears to be a good fit. So I write a function that would take a config, and map endpoint + method combination to a middleware pipe. And I understand that I cannot have middleware be lazy-loaded by retrieving it out of the DI container, because MiddlewareAwareInterface#middleware() does not accept string, which is what the key would need to be.

This is a deal-breaker for me. Other libraries, such as Broker, do this, and it's very convenient. I think this is definitely a feature worth adding.

Simple example of this not working:

$test = new Test();
$router = new League\Route\RouteCollection;
$router->addRoute('GET', '/', [$test, 'index']);

$request    = Request::createFromGlobals();
$dispatcher = $router->getDispatcher();

try {
    $response   = $dispatcher->dispatch($request->getMethod(), $request->getPathInfo());
    $response->send();
} catch(Exception $e) {
    echo $e->getMessage();
}

class Test
{
    public function index(Request $req, Response $resp) 
    {
        $resp->setContent("Testing");
        return $resp;
    }
}

Errors:

Warning: Illegal offset type in /var/www/source/vendor/league/route/src/RouteCollection.php on line 84

Warning: Illegal offset type in /var/www/source/vendor/league/route/src/RouteCollection.php on line 84

Warning: Illegal offset type in /var/www/source/vendor/league/route/src/Dispatcher.php on line 69

Warning: Illegal offset type in /var/www/source/vendor/league/route/src/Dispatcher.php on line 70

Catchable fatal error: Argument 2 passed to League\Route\Dispatcher::handleFound() must implement interface League\Route\Strategy\StrategyInterface, null given, called in /var/www/source/vendor/league/route/src/Dispatcher.php on line 73 and defined in /var/www/source/vendor/league/route/src/Dispatcher.php on line 85

Doing the following works as expected though:

$router->addRoute('GET', '/', 'test::index');

Both ways are valid callables, so this not working is weird.

I have a route group prefixed with /api/v1 and some routes defined inside. I also have the strategy set for the route group to the bundled JsonStrategy.

Lets say the routes defined inside the /api/v1 route group are a GET route on / and a GET route on /welcome. The routes work fine, but if I try to call a route such as /api/v1/test, it will throw a NotFoundException, which is expected as the route is undefined, however the exception is not caught when the route is dispatched. I was under the impression that by setting a JsonStrategy on a route (or route group), exceptions would be caught and a json response would be returned.

I thought it might have been where those routes were undefined, so I tried it by setting the strategy on an individual route, and then throwing a NotFoundException from within the controller function, and it will fail with an uncaught exception. Here is some example code to illustrate my problem: -- file: index.php

<?php

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

require '../vendor/autoload.php';

$container = new League\Container\Container;

$container->share('response', Zend\Diactoros\Response::class);
$container->share('request', function () {
    return Zend\Diactoros\ServerRequestFactory::fromGlobals(
        $_SERVER, $_GET, $_POST, $_COOKIE, $_FILES
    );
});

$container->share('emitter', Zend\Diactoros\Response\SapiEmitter::class);

$route = new League\Route\RouteCollection($container);

$route->map('GET', '/', function (ServerRequestInterface $request, ResponseInterface $response) {
    $response->getBody()->write(json_encode(['message' => 'hey']));

    throw new \League\Route\Http\Exception\NotFoundException();

    return $response;
})->setStrategy(new \League\Route\Strategy\JsonStrategy());

$response = $route->dispatch($container->get('request'), $container->get('response'));
$container->get('emitter')->emit($response);

I have also tried setting a route group and setting the strategy for the group: -- file: index.php

<?php

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

require '../vendor/autoload.php';

$container = new League\Container\Container;

$container->share('response', Zend\Diactoros\Response::class);
$container->share('request', function () {
    return Zend\Diactoros\ServerRequestFactory::fromGlobals(
        $_SERVER, $_GET, $_POST, $_COOKIE, $_FILES
    );
});

$container->share('emitter', Zend\Diactoros\Response\SapiEmitter::class);

$route = new League\Route\RouteCollection($container);

$route->group('/api/v1', function($route) {
    $route->map('GET', '/', function (ServerRequestInterface $request, ResponseInterface $response) {
        $response->getBody()->write(json_encode(['message' => 'hey']));

        return $response;
    });
})->setStrategy(new \League\Route\Strategy\JsonStrategy());

$response = $route->dispatch($container->get('request'), $container->get('response'));
$container->get('emitter')->emit($response);

It seems after looking in the dispatch function for the RouteCollection, it catches the exception, but I added some debugging to the exception handling and $this->getStrategy() is returning an instance of ApplicationStrategy would would just rethrow the exception. Perhaps I am missing something with setting up the strategies for the routes.

Any insight would be greatly appreciated.

https://github.com/thephpleague/route/blob/b2d82a8b212787f10244e6fa8f94c939560d23bd/src/Http/Exception.php#L30

This breaks on PHP 7+ when a non-\Exception throwable is thrown (e.g. TypeError; see also the type hierarchy).

For best compatibility, the type declaration should be removed. If needs be, ?\Exception / ?\Throwable could be defined via PHPDoc.

Since it's removing a restriction, I don't think this should be considered as a BC break.

On a side note, not sure why it needs to keep a copy of the message: https://github.com/thephpleague/route/blob/b2d82a8b212787f10244e6fa8f94c939560d23bd/src/Http/Exception.php#L20 and https://github.com/thephpleague/route/blob/b2d82a8b212787f10244e6fa8f94c939560d23bd/src/Http/Exception.php#L35

An effective stopgap solution for my use-case:

class InternalServerErrorException extends \League\Route\Http\Exception
{
    protected $status = 500;
    protected $message = 'Internal Server Error';

    /**
     * @throws \ReflectionException
     * @noinspection MagicMethodsValidityInspection
     * @noinspection PhpMissingParentConstructorInspection
     */
    public function __construct(Throwable $previous = null)
    {
        $reflector = new \ReflectionMethod(\Exception::class, '__construct');
        $reflector->invoke($this, $this->message, 0, $previous);
    }
}

We have an implementation of RequestHandlerInterface for every route in our app. We currently have to register them on the router like this (simplified for example):

$helloRequestHandler = new HelloRequestHandler(); // implements RequestHandlerInterface

$router = new Router();
$router->get('/hello', [$helloRequestHandler, 'handle']);

Since RequestHandlerInterface is an interface from PSR-15, and this package supports PSR-15 (middlewares), it would be cool if the router could automatically detect the 'handle' method on the request handlers, so we could just register them like:

$helloRequestHandler = new HelloRequestHandler(); // implements RequestHandlerInterface

$router = new Router();
$router->get('/hello', $helloRequestHandler);

(Or when injecting a dependency container into the router, as a FQN / service name without the ::handle)

Is this something that you would consider approving if I created a PR for this?

Hi,

Im trying to migrate to league/route:^5.0, however it requires "psr/simple-cache": ^1.0 where i depend on ^3.0. is it possible to widen the constraints to cover all simple-cache versions e.g.:

{
    "psr/simple-cache": "^1.0|^2.0|^3.0"
}

Correct me if I'm wrong, but the middleware stack is only executed when a route is matched. Is there a reason for this?

Given that the middleware stack runs before a matched route's callable, it would seem to make more sense that the stack is executed regardless of whether a route is matched. Perhaps I'm missing something.

My use case is a middleware that will always check for HTTP auth - regardless of whether a route is matched or not.

Thanks