PHPackages                             pollen-solutions/argument-resolver - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. pollen-solutions/argument-resolver

ActiveLibrary[Utility & Helpers](/categories/utility)

pollen-solutions/argument-resolver
==================================

Pollen Solutions - Argument Resolve Component - Smart arguments resolving of callable

v1.0.2(4y ago)02461MITPHPPHP ^7.4 || ^8.0

Since Apr 16Pushed 3y ago1 watchersCompare

[ Source](https://github.com/pollen-solutions/argument-resolver)[ Packagist](https://packagist.org/packages/pollen-solutions/argument-resolver)[ Docs](https://www.presstify.com/pollen-solutions/argument-resolver/)[ RSS](/packages/pollen-solutions-argument-resolver/feed)WikiDiscussions master Synced 1mo ago

READMEChangelogDependencies (2)Versions (8)Used By (1)

Argument Resolver Component
===========================

[](#argument-resolver-component)

[![Latest Stable Version](https://camo.githubusercontent.com/5973b63ae1b1e81ea9caef0285da6cce0c4c2b00408a402e5d711a13fcca3362/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f706f6c6c656e2d736f6c7574696f6e732f617267756d656e742d7265736f6c7665722e7376673f7374796c653d666f722d7468652d6261646765)](https://packagist.org/packages/pollen-solutions/argument-resolver)[![MIT Licensed](https://camo.githubusercontent.com/daa52099573be5a50c320c4387496400f2f722e49f86a42db8d5778130d3582d/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d677265656e3f7374796c653d666f722d7468652d6261646765)](LICENSE.md)[![PHP Supported Versions](https://camo.githubusercontent.com/d9d71d0b69072c51e1ff7adfdb6270f896f75787500ce6437120e23727c081d1/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5048502d2533453d372e342d3838393242463f7374796c653d666f722d7468652d6261646765266c6f676f3d706870)](https://www.php.net/supported-versions.php)

Pollen Solutions **Argument Resolver** Component is a smart arguments resolving of callable library. It allows you to dynamically determine the arguments to pass to a function, an invokable class or a method.

Installation
------------

[](#installation)

```
composer require pollen-solutions/argument-resolver
```

Basic Usage
-----------

[](#basic-usage)

```
use Pollen\ArgumentResolver\ArgumentResolver;
use Pollen\ArgumentResolver\Resolvers\ParameterResolver;

$acmeCallable = static function (int $product_id, string $name, bool $in_stock, float $price, array $product_attrs) {
    var_dump($product_id, $in_stock, $price, $product_attrs);
    exit;
};

$parameters = [
    'product_id' => 1,
    'name'       => 'My beautiful sneaker',
    'in_stock'   => true,
    'price'      => 156.30,
    'product_attrs' => [
        'size'  => 12,
        'color' => 'pink'
    ]
];

$arguments = (new ArgumentResolver([new ParameterResolver($parameters)]))->resolve($acmeCallable);

$acmeCallable(...$arguments);
```

In below example, callable is a closure function.

It could be a class method :

```
use Pollen\ArgumentResolver\ArgumentResolver;
use Pollen\ArgumentResolver\Resolvers\ParameterResolver;

class AcmeClass
{
    public function storeProduct(int $product_id, string $name, bool $in_stock, float $price, array $product_attrs)
    {
        var_dump($product_id, $in_stock, $price, $product_attrs);
        exit;
    }
}

$acmeCallable = [new AcmeClass(), 'storeProduct'];

$parameters = [
    'product_id' => 1,
    'name'       => 'My beautiful sneaker',
    'in_stock'   => true,
    'price'      => 156.30,
    'product_attrs' => [
        'size'  => 12,
        'color' => 'pink'
    ]
];

$arguments = (new ArgumentResolver([new ParameterResolver($parameters)]))->resolve($acmeCallable);

$acmeCallable(...$arguments);
```

Also, it could be an invokable class :

```
use Pollen\ArgumentResolver\ArgumentResolver;
use Pollen\ArgumentResolver\Resolvers\ParameterResolver;

class AcmeClass
{
    public function __invoke(int $product_id, string $name, bool $in_stock, float $price, array $product_attrs)
    {
        var_dump($product_id, $in_stock, $price, $product_attrs);
        exit;
    }
}

$acmeCallable = new AcmeClass();

$parameters = [
    'product_id' => 1,
    'name'       => 'My beautiful sneaker',
    'in_stock'   => true,
    'price'      => 156.30,
    'product_attrs' => [
        'size'  => 12,
        'color' => 'pink'
    ]
];

$arguments = (new ArgumentResolver([new ParameterResolver($parameters)]))->resolve($acmeCallable);

$acmeCallable(...$arguments);
```

Resolvers
---------

[](#resolvers)

### ParameterResolver

[](#parameterresolver)

\-- @todo or see below --

### ContainerResolver

[](#containerresolver)

The container resolver is used to resolve the arguments of a callable provided by a container that implements \\Psr\\Container\\ContainerInterface.

```
use Pollen\Container\Container;
use Pollen\ArgumentResolver\ArgumentResolver;
use Pollen\ArgumentResolver\Resolvers\ContainerResolver;

class Foo {}

class Bar {}

$container = new Container();
$container->add(Foo::class, new Foo);
$container->add(Bar::class, new Bar);

$acmeCallable = static function (Foo $foo, Bar $bar) {
    var_dump($foo, $bar);
    exit;
};

$arguments = (new ArgumentResolver([new ContainerResolver($container)]))->resolve($acmeCallable);

$acmeCallable(...$arguments);
```

### RequestResolver

[](#requestresolver)

The request resolver is used to resolve arguments of a callable provided by an HTTP request that implements Psr\\Http\\Message\\ServerRequestInterface.

```
use Laminas\Diactoros\ServerRequestFactory;
use Pollen\ArgumentResolver\ArgumentResolver;
use Pollen\ArgumentResolver\Resolvers\RequestResolver;

// This code must be served by your app and visits :
// http://127.0.0.1/?product_id=1&name=My beautiful sneaker&in_stock=true&price=156.30&product_attrs[size]=12&product_attrs[color]=pink
$request = ServerRequestFactory::fromGlobals();
// also you can force $_GET attributes :
//$request = ServerRequestFactory::fromGlobals(null, [
//    'product_id' => 1,
//    'name'       => 'My beautiful sneaker',
//    'in_stock'   => true,
//    'price'      => 156.30,
//    'product_attrs' => [
//        'size'  => 12,
//        'color' => 'pink'
//    ]
//]);

$acmeCallable = static function (int $product_id, string $name, bool $in_stock, float $price, array $product_attrs) {
    var_dump($product_id, $in_stock, $price, $product_attrs);
    exit;
};

$arguments = (new ArgumentResolver([new RequestResolver($request)]))->resolve($acmeCallable);

$acmeCallable(...$arguments);
```

### RequestAttributeResolver

[](#requestattributeresolver)

The request attribute attribute resolver is used to resolve arguments of a callable provided through attributes of an HTTP request that implements Psr\\Http\\Message\\ServerRequestInterface.

```
use Laminas\Diactoros\ServerRequestFactory;
use Pollen\ArgumentResolver\ArgumentResolver;
use Pollen\ArgumentResolver\Resolvers\RequestAttributeResolver;

$request = ServerRequestFactory::fromGlobals();
$request = $request->withAttribute('product_id', 1);
$request = $request->withAttribute('name', 'My beautiful sneaker');
$request = $request->withAttribute('in_stock', true);
$request = $request->withAttribute('price', 156.30);
$request = $request->withAttribute('filters', [
    'size'  => 12,
    'color' => 'pink'
]);

$acmeCallable = static function (int $product_id, string $name, bool $in_stock, float $price, array $product_attrs) {
    var_dump($product_id, $in_stock, $price, $product_attrs);
    exit;
};

$arguments = (new ArgumentResolver([new RequestAttributeResolver($request)]))->resolve($acmeCallable);

$acmeCallable(...$arguments);
```

### Chained resolvers

[](#chained-resolvers)

```
use Pollen\Container\Container;
use Pollen\ArgumentResolver\ArgumentResolver;
use Pollen\ArgumentResolver\Resolvers\ContainerResolver;
use Pollen\ArgumentResolver\Resolvers\ParameterResolver;

class EntityManager {}

$container = new Container();
$container->add(EntityManager::class, new EntityManager);

$acmeCallable = static function (EntityManager $manager, int $product_id, string $name, bool $in_stock, float $price, array $product_attrs) {
    var_dump($manager, $product_id, $in_stock, $price, $product_attrs);
    exit;
};

$parameters = [
    'product_id' => 1,
    'name'       => 'My beautiful sneaker',
    'in_stock'   => true,
    'price'      => 156.30,
    'product_attrs' => [
        'size'  => 12,
        'color' => 'pink'
    ]
];

$arguments = (new ArgumentResolver([new ParameterResolver($parameters), new ContainerResolver($container)]))->resolve($acmeCallable);

$acmeCallable(...$arguments);
```

### Create a custom resolver

[](#create-a-custom-resolver)

You can create your own custom resolver. In this example, we are creating an HTTP request session based resolver. To works, a resolver must implements Pollen\\ArgumentResolver\\ResolverInterface.

```
use Pollen\ArgumentResolver\ArgumentResolver;
use Pollen\ArgumentResolver\ResolverInterface;

class SessionResolver implements ResolverInterface
{
    protected array $params;

    public function __construct()
    {
        $this->params = $_SESSION;
    }

    /**
     * @inheritDoc
     */
    public function resolve(ReflectionParameter $parameter): ?array
    {
        $key = $parameter->getName();
        if (!$value = $this->params[$key] ?? null) {
            return null;
        }

        if (!$this->matchType($parameter, $this->params[$key])) {
            return null;
        }

        return [$key, $value];
    }

    /**
     * @param ReflectionParameter $parameter
     * @param mixed $value
     *
     * @return bool
     */
    protected function matchType(ReflectionParameter $parameter, $value): bool
    {
        if (!$type = $parameter->getType()) {
            return true;
        }

        $typeName = $type->getName();

        if ('array' === $typeName) {
            return is_array($value);
        }

        if ('callable' === $typeName) {
            return is_callable($value);
        }

        if (!$type->isBuiltin()) {
            if (!is_object($value)) {
                return false;
            }

            try {
                $class = new ReflectionClass($typeName);
            } catch (ReflectionException $e) {
                return false;
            }

            return $class->isInstance($value);
        }

        switch ($typeName) {
            case 'bool':
                return is_bool($value);
            case 'float':
                return is_float($value);
            case 'int':
                return is_int($value);
            case 'string':
                return is_string($value);
            case 'iterable':
                return is_iterable($value);
        }

        return true;
    }
}

$_SESSION['product_id'] = 1;
$_SESSION['name'] = 'My beautiful sneaker';
$_SESSION['in_stock'] = true;
$_SESSION['price'] = 156.30;
$_SESSION['product_attrs'] = [
    'size'  => 12,
    'color' => 'pink',
];

$acmeCallable = static function (int $product_id, string $name, bool $in_stock, float $price, array $product_attrs) {
    var_dump($product_id, $in_stock, $price, $product_attrs);
    exit;
};

$arguments = (new ArgumentResolver([new SessionResolver()]))->resolve($acmeCallable);

$acmeCallable(...$arguments);
```

Credits
-------

[](#credits)

- Freely inspired by Rybakit work in [ArgumentsResolver](https://github.com/rybakit/arguments-resolver)

###  Health Score

27

—

LowBetter than 49% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity11

Limited adoption so far

Community9

Small or concentrated contributor base

Maturity58

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~0 days

Total

7

Last Release

1493d ago

Major Versions

v0.0.x-dev → v1.0.02022-04-16

### Community

Maintainers

![](https://www.gravatar.com/avatar/c1d9488545d6b446f8df86ec373a070e7fed1166fc47e1324d963e46d3d838d3?d=identicon)[presstify](/maintainers/presstify)

---

Top Contributors

[![jordy-manner](https://avatars.githubusercontent.com/u/733356?v=4)](https://github.com/jordy-manner "jordy-manner (6 commits)")

---

Tags

componentresolverargumentpollen-solutions

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/pollen-solutions-argument-resolver/health.svg)

```
[![Health](https://phpackages.com/badges/pollen-solutions-argument-resolver/health.svg)](https://phpackages.com/packages/pollen-solutions-argument-resolver)
```

###  Alternatives

[phpoffice/common

PHPOffice Common

23512.3M36](/packages/phpoffice-common)[dflydev/placeholder-resolver

Given a data source representing key => value pairs, resolve placeholders like ${foo.bar} to the value associated with the 'foo.bar' key in the data source.

14414.6M3](/packages/dflydev-placeholder-resolver)[sroze/argument-resolver

A lightweight utility to resolve method arguments based on types and names

1041.4k1](/packages/sroze-argument-resolver)[lochmueller/autoloader

Automatic components loading of ExtBase extensions to get more time for coffee in the company ;) This ext is not a PHP SPL autoloader or class loader - it is better! Loads CommandController, Xclass, Hooks, FlexForms, Slots, TypoScript, TypeConverter, BackendLayouts and take care of createing needed templates, TCA configuration or translations at the right location.

19364.9k5](/packages/lochmueller-autoloader)[tomatophp/filament-icons

Picker & Table Column & Icons Provider for FilamentPHP

3598.2k13](/packages/tomatophp-filament-icons)[contributte/menu-control

Menu control for Nette framework

29108.6k1](/packages/contributte-menu-control)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)