Dependency injection on nested resources

[loureirorg]

I'm trying to load QueryBuilder in a nested controller via dependency injection, but it doesn't work.

For example, this nested resource: GET /books/1/comments

I tried this controller:

// CommentController.php
public function index(CommentIndexQuery $query) 
{
    return $query->get();
}

With this QueryBuilder:

class CommentIndexQuery extends QueryBuilder 
{
    public function __construct(Request $request, Book $book) 
    {
        $query = $book->comments();

        parent::__construct($query, $request);
    }
}

But it didn't work. $book always returns an empty model, resulting in a [] HTTP response.

Current solution

What works for me is to manually load the query builder and manually pass the nested model:

// CommentController.php
public function index(Request $request, Book $book) 
{
    $query = new CommentIndexQuery($request, $book);

    return $query->get();
}

Although this works, it would be great to use dependency injection to load the query builder. Am I doing it wrong, or there's no way to currently do this?

[loureirorg]

Here's my solution in case anyone is interested:

<?php
// app/Providers/QueryBuilderRouteBindingServiceProvider.php

namespace App\Providers;

use Illuminate\Container\Container;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Http\Request;
use Illuminate\Routing\ImplicitRouteBinding;
use Illuminate\Routing\Route;
use Illuminate\Support\ServiceProvider;
use ReflectionClass;
use ReflectionMethod;
use Spatie\QueryBuilder\QueryBuilder;

class QueryBuilderRouteBindingServiceProvider extends ServiceProvider
{
    public function boot() : void
    {
        $this->registerRouteBindingResolver();
    }

    public function registerRouteBindingResolver() : void
    {
        $this->app->beforeResolving(QueryBuilder::class, function($className) {
            $this->app->bind($className, $this->factoryRouteBindingResolver($className));
        });
    }

    protected function factoryRouteBindingResolver(string $className) : callable
    {
        return function() use ($className) {
            $reflection = new ReflectionClass($className);

            $arguments = $this->resolveDependenciesWithRouteBinding($reflection->getConstructor(), request());

            return $reflection->newInstanceArgs($arguments);
        };
    }

    protected function resolveDependenciesWithRouteBinding(ReflectionMethod $method, Request $request) : array
    {
        $controllerRoute = $request->route();

        $methodRoute = (new Route(
            methods: $controllerRoute->methods,
            uri: $controllerRoute->uri,
            action: [$method->class, $method->name],
        ))
            ->withTrashed($controllerRoute->allowsTrashedBindings())
            ->setContainer($this->getContainer())
            ->bind($request);

        ImplicitRouteBinding::resolveForRoute($this->getContainer(), $methodRoute);

        return $methodRoute->resolveMethodDependencies(
            $methodRoute->parametersWithoutNulls(),
            $method,
        );
    }

    /** @return Application|Container */
    protected function getContainer() : mixed
    {
        return $this->app;
    }
}

Then, add on config/app.php:

/*
 * Application Service Providers...
 */
  /* ... */
  App\Providers\QueryBuilderRouteBindingServiceProvider::class,

---

About this solution

With QueryBuilderRouteBinding, you can load data from the router via dependency injection.

Example, loading a model:

class CommentIndexQuery extends QueryBuilder 
{
    public function __construct(Request $request, Book $book) 
    {
        $query = $book->comments();

        parent::__construct($query, $request);
    }
}

This specific type of dependency injection that loads data from the router, including models, is called "Route Model Binding".

That's what this solution does. It provides a "Route Model Binding" for extended QueryBuilder classes.

[loureirorg]

I'm writing here the path I took to implement this code just in case I need to revisit it in the future or if anyone is interested in understanding the code.

1st Attempt: Laravel Container

My first thought was to use Laravel Containers.

We could do something like this:

// AppServiceProvider.php
public function register()
{
    $this->app->bind(QueryBuilder::class, function () {
        // return an instance of the query builder. Ex. `new BookIndexQuery(...);`
    });
}

The problem with this solution is that we have to analyze the class constructor parameters and manually inject them.

It seemed a lot of work to me.

2nd Attempt: Contextual Binding

Instead of binding to the query builder class, what if we monitor just its parameters? More specifically, the models.

We could do it with Contextual Binding:

// AppServiceProvider.php
public function register()
{
    $this->app
        ->when(QueryBuilder::class)
        ->needs(Model::class)
        ->give(function ($app) {
            // then, return the model instance with the specified key. Ex. `Model::find(id)`
        });
}

I like this approach; it looks simple and clean, but unfortunately, it doesn't work.

We can't use Model on needs. The needs method doesn't support parent classes, just the classes themselves. In other words, we have to declare [User::class, Book::class, ...] instead of Model::class. Same thing with the when method.

A solution for this could be to find all model classes by calling get_declared_classes() and filtering with is_subclass_of($className, $parentClassName). Then, we would pass the whole array into needs.

That sounded like a good idea, but the problem with this solution is that get_declared_classes() doesn't work with autoloading (PSR4). It doesn't return the classes until we call them, resulting in an empty array of models.

3rd Attempt: Monitoring the parent class with beforeResolving

After getting stuck with the "I can't pass a parent class on Laravel Container", I started looking for ways to circumvent this issue.

I looked at the Containers code and found that Laravel triggers a beforeResolving event when resolving dependencies.

Luckily, beforeResolving accepts parent classes, so we can use it to monitor when Laravel tries to resolve any children of QueryBuilder::class and register app->when(...)->needs(...) in realtime.

Something like this:

$this->app->beforeResolving(QueryBuilder::class, function ($className) {
    $this->app->when($className)->needs(Model::class)->give(/*...*/);
});

That works for when, but we still have to deal with needs. So, we can't use this as a solution for contextual binding.

4th Attempt: Back to the first attempt: Bind the query builder class

So, we can't use Contextual Bindings for what we want. That's a bummer.

But what about the initial idea? We can resolve the query builder class instead of its parameters.

This:

// AppServiceProvider.php
public function register()
{
    $this->app->bind(QueryBuilder::class, function () {
        // return an instance of the query builder. Ex. `new BookIndexQuery(...);`
    });
}

A problem with this is that bind can't accept a parent class like QueryBuilder, just the classes themselves. Luckily, we already found a solution with beforeResolving.

We do this:

// AppServiceProvider.php
$this->app->beforeResolving(QueryBuilder::class, function($className) {
    $this->app->bind($className, function () {
        // return an instance of the query builder. Ex. `new BookIndexQuery(...);`
    });
});

Now, we have to manually create the object instance. And we have to manually resolve the dependencies declared on the parameters.

At this moment, I realized that Laravel does the same thing we are trying to accomplish. On controllers, when we define a method, we can request a Model via dependency injection.

5th Attempt: The Laravel Controller way

I got curious about how Laravel injects models into controllers, so I started investigating it. I found that in Laravel, the router is responsible for the dependency injection in the controller.

The code that does the manual injection is called ImplicitRouteBinding.

The way it works is that it first gets the parameters of the controller's method. If the parameter is a model class, it fetches from the database. It uses the HTTP request, the URL format, the settings in the router file, and the parameter name to find the given record. If the parameter is not a model, it uses the standard container resolve.

Based on this idea, I thought of doing this:

// AppServiceProvider.php
$this->app->beforeResolving(QueryBuilder::class, function($className) {
    $this->app->bind($className, function () {
        $arguments = /* ... */;
        return new $className($arguments);
    });
});

Filling the $arguments variable is the hard part. We must read the class constructor parameters and manually resolve them, one by one, fetching them from the database when they are models.

I started writing the logic to resolve the arguments, but it started getting complex.

6th Attempt: Re-using Laravel's logic with ImplicitRouteBinding

Getting the HTTP data is easy with request()->route()->parameters. For example /books/{book}/comments would return an array like ['book' => 1].

But resolving book => 1 into Book::find(1) is not easy. There are many things to consider. Is it {book} or {book:slug} or {id}? What about soft-deletes or specific settings per route?

So instead of re-inventing the wheel, I looked at Laravel's core code to see if I could re-use the "Route Model Binding" logic.

After a while, I found the method Laravel uses for the route-model binding: ImplicitRouteBinding::resolveForRoute($container, $route).

Its arguments are easy to get:

• $container: this is the $this->app or app();
• $route: this is a route object (ex. request()->route());

This method doesn't return anything, but it resolves the $route->parameters, transforming book => 1 into Book::find(1) for example.

Unfortunately, this didn't work right away. The helper uses the controller method signature to resolve the models, and we need to use the query builder class constructor instead.

To fix it, we need to change the method assigned to $route. Instead of the controller method, we use the constructor of our query builder class.

But changing the route object can lead to side effects on the application. So instead of changing it, we create a new Route object: we copy all the relevant data from $route, and define our constructor as the action:

$controllerRoute = $request->route();

$methodRoute = (new Route(
    methods: $controllerRoute->methods,
    uri: $controllerRoute->uri,
    action: [$className, '__construct'],
))
    ->withTrashed($controllerRoute->allowsTrashedBindings())
    ->setContainer($this->app)
    ->bind(request());

After that, ImplicitRouteBinding works like a charm.

The ImplicitRouteBinding does 99% of the work we need. Everything else is mostly a wrapper for it.

Finishing up

Now that we have the model binding resolved in $route->parameters, we need to resolve the other dependencies of the method.

Resolving dependencies of a method is an easy task, but Laravel has a helper for this: resolveMethodDependencies($parameters, $method).

This helper reads the $method signature and resolves its dependencies. If the parameter is in the $parameters list, it gets its value from there. As we have the models resolved in $parameters, we end up with a list of all the method arguments ready to be called.

After that, we instantiate the class and return it.

And that's how this was implemented.