Resolver

, _(*1)

Resolver is a dependency auto resolver for PHP 7 and 8. Supports PSR-11 ContainerInterface., _(*2)

Installation

composer require acelot/resolver

Why?

Imagine that you have a controller:, _(*3)

class UsersController
{
    public function __construct(UsersService $service)
    {
        // ...
    }
}

As you can see the controller requires UsersService in constructor. To resolve this dependency you can just pass the new instance of UsersService. Let's do this:, _(*4)

$service = new UsersService();
$controller = new UsersController($service);

It doesn't work, because UsersService, in turn, requires UsersRepository to access the data., _(*5)

class UsersService
{
    public function __construct(UsersRepository $repository)
    {
        // ...
    }
}

Okay, let's create the repository instance!, _(*6)

$repository = new UsersRepository();
$service = new UsersService($repository);
$controller = new UsersController($service);

Sadly, it still doesn't work, because we encountering the new dependency! The repository, surprisingly, requires a database connection :), _(*7)

class UsersRepository
{
    public function __construct(Database $db)
    {
        // ...
    }
}

You say "Eat this!"., _(*8)

$db = new Database('connection string here');
$repository = new UsersRepository($db);
$service = new UsersService($repository);
$controller = new UsersController($service);

Success! We have finally created the instance of UsersController! Now imagine that you have ten or hundred controllers like this?! With Resolver you can greatly simplify creation of classes. In what turns this code using Resolver:, _(*9)

$resolver = new Resolver([
    Database::class => ObjectDefinition::define(Database::class)->withArgument('connectionString', 'connection string here')
]);

$controller = $resolver->resolve(UsersController::class);

And it's all., _(*10)

How it works?

Resolver resolves the classes by using Reflection. Through reflection the Resolver finds out all dependencies of the class and all dependencies of dependencies and so on. When Resolver reaches the deepest dependency it starts creating instances of these one by one until the top class. The resolved classes are stored in local array to avoid re-resolving., _(*11)

Available definitions

FactoryDefinition (short alias factory())
ObjectDefinition (short alias object())
ValueDefinition (short alias value())

Resolved definitions can be shared between calls via ->shared() method. This method available in FactoryDefinition and ObjectDefinition. ValueDefinition is shared always by design., _(*12)

Resolver (c) by Valeriy Protopopov., _(*13)

Resolver is licensed under a MIT license., _(*14)