PHPackages                             bermudaphp/di-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. [PSR & Standards](/categories/psr-standards)
4. /
5. bermudaphp/di-resolver

AbandonedArchivedLibrary[PSR & Standards](/categories/psr-standards)

bermudaphp/di-resolver
======================

A powerful and flexible parameter resolution library for PHP that automatically resolves function and method parameters from various sources

v1.0(1y ago)251MITPHPPHP ^8.4CI passing

Since Jun 29Pushed 1y ago1 watchersCompare

[ Source](https://github.com/bermudaphp/di-resolver)[ Packagist](https://packagist.org/packages/bermudaphp/di-resolver)[ RSS](/packages/bermudaphp-di-resolver/feed)WikiDiscussions master Synced today

READMEChangelog (1)Dependencies (6)Versions (2)Used By (1)

Parameter Resolver
==================

[](#parameter-resolver)

[![Tests](https://github.com/bermudaphp/di-resolver/actions/workflows/tests.yml/badge.svg)](https://github.com/bermudaphp/di-resolver/actions/workflows/tests.yml)[![PHP Version](https://camo.githubusercontent.com/80c4564163cef31b2a66baaeb95a5bf4a418bcb5242a5ae707b94c2f4811e742/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5048502d382e342532422d626c7565)](https://php.net)[![License](https://camo.githubusercontent.com/f8df3091bbe1149f398a5369b2c39e896766f9f6efba3477c63e9b4aa940ef14/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d677265656e)](LICENSE)

**[🇷🇺 Русская версия](README.RU.md)**

A powerful and flexible parameter resolution library for PHP that automatically resolves function and method parameters from various sources including arrays, DI containers, and configuration.

Features
--------

[](#features)

- **Multiple Resolution Strategies**: Resolve parameters by name, position, type, or attributes
- **DI Container Integration**: Seamless integration with PSR-11 containers
- **Attribute Support**: Native PHP 8+ attributes (`#[Config]`, `#[Inject]`)
- **Union Types**: Full support for PHP 8 union types
- **Extensible Architecture**: Easy to add custom resolvers
- **Zero Dependencies**: Core functionality requires no external dependencies
- **High Performance**: Optimized resolver chain with early termination

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

[](#installation)

```
composer require bermudaphp/di-resolver
```

Quick Start
-----------

[](#quick-start)

```
use Bermuda\ParameterResolver\ParameterResolver;
use Bermuda\ParameterResolver\ArrayResolver;
use Bermuda\ParameterResolver\DefaultValueResolver;

// Create resolver with basic resolvers
$resolver = new ParameterResolver([
    new ArrayResolver(),           // Resolve from provided array
    new DefaultValueResolver()     // Use default values
]);

// Define a function
function greetUser(string $name, string $greeting = 'Hello', ?int $age = null) {
    return "$greeting, $name" . ($age ? " (age: $age)" : "");
}

// Resolve parameters
$reflection = new ReflectionFunction('greetUser');
$parameters = $reflection->getParameters();

$resolvedParams = $resolver->resolve($parameters, [
    'name' => 'John',
    'age' => 25
]);

// Result: ['John', 'Hello', 25]
echo greetUser(...$resolvedParams); // "Hello, John (age: 25)"
```

Core Resolvers
--------------

[](#core-resolvers)

### ArrayResolver

[](#arrayresolver)

Resolves parameters by name or position from provided array:

```
$resolver = new ArrayResolver();

// By name
$params = ['username' => 'john', 'email' => 'john@example.com'];

// By position
$params = [0 => 'john', 1 => 'john@example.com'];
```

### ArrayTypedResolver

[](#arraytypedresolver)

Resolves parameters by object type scanning:

```
$resolver = new ArrayTypedResolver();

$params = [
    'userService' => new UserService(),
    'logger' => new Logger()
];

function processUser(UserService $service, Logger $logger) {
    // Parameters resolved automatically by type
}
```

### ContainerResolver

[](#containerresolver)

Resolves from PSR-11 DI containers with attribute support:

```
use Bermuda\DI\Attribute\Config;
use Bermuda\DI\Attribute\Inject;

$resolver = new ContainerResolver($container);

function createUser(
    #[Config('database.host')] string $dbHost,
    #[Inject('user.repository')] UserRepository $repo,
    UserService $service  // Resolved by type from container
) {
    // All parameters resolved automatically
}
```

### DefaultValueResolver

[](#defaultvalueresolver)

Uses parameter default values:

```
function processData(array $data, bool $validate = true, ?string $format = null) {
    // $validate will be true, $format will be null if not provided
}
```

### NullableResolver

[](#nullableresolver)

Resolves nullable parameters to null:

```
function optionalService(?LoggerInterface $logger = null) {
    // $logger will be null if not resolvable
}
```

DI Container Integration
------------------------

[](#di-container-integration)

### Full Integration Example

[](#full-integration-example)

```
use Bermuda\ParameterResolver\ParameterResolver;

// Create resolver with all standard resolvers
$resolver = ParameterResolver::createDefaults($container);

class UserController
{
    public function createUser(
        #[Config('app.name')] string $appName,
        #[Inject('user.validator')] UserValidator $validator,
        UserRepository $repository,           // From container by type
        array $userData,                      // From provided parameters
        bool $sendEmail = true,               // Default value
        ?LoggerInterface $logger = null       // Nullable fallback
    ) {
        // All parameters resolved automatically
        $user = new User($userData);

        if ($validator->validate($user)) {
            $repository->save($user);

            if ($sendEmail && $logger) {
                $logger->info("User created in $appName");
            }
        }

        return $user;
    }
}

// Usage
$method = new ReflectionMethod(UserController::class, 'createUser');
$resolvedParams = $resolver->resolve(
    $method->getParameters(),
    ['userData' => $_POST, 'sendEmail' => false]
);

$controller = new UserController();
$user = $controller->createUser(...$resolvedParams);
```

Configuration Management
------------------------

[](#configuration-management)

The `Config` attribute supports dot notation and various data sources:

```
use Bermuda\DI\Attribute\Config;

// Simple config access
function connectDatabase(#[Config('database.host')] string $host) {}

// With default values
function getApiKey(#[Config('api.key', 'default-key')] string $key) {}

// Disable dot notation
function getLiteralKey(#[Config('app.debug', explodeDots: false)] bool $debug) {}

// Deep nesting
function getNestedValue(
    #[Config('services.external.api.endpoints.users')] string $endpoint
) {}
```

### ArrayAccess Support

[](#arrayaccess-support)

```
$config = new ArrayObject([
    'database' => ['host' => 'localhost', 'port' => 3306]
]);

$container->set('config', $config);

function connect(#[Config('database.host')] string $host) {
    // Works with ArrayAccess objects
}
```

Advanced Usage
--------------

[](#advanced-usage)

### Custom Resolvers

[](#custom-resolvers)

```
class EnvironmentResolver implements ParameterResolverInterface
{
    public function resolve(
        ReflectionParameter $parameter,
        array $providedParameters = [],
        array $resolvedParameters = []
    ): ?array {
        $envVar = 'APP_' . strtoupper($parameter->getName());
        $value = $_ENV[$envVar] ?? null;

        return $value !== null ? [$parameter->getPosition(), $value] : null;
    }
}

// Add to resolver chain
$resolver = new ParameterResolver([
    new EnvironmentResolver(),
    new ArrayResolver(),
    new DefaultValueResolver()
]);
```

### Union Type Support

[](#union-type-support)

```
function flexibleHandler(string|UserService $handler, int|float $value) {
    // Resolves first matching type from union
}

$params = [
    'UserService' => new UserService(),  // Matches UserService from union
    'value' => 42                        // Matches int from union
];
```

### Resolver Priorities

[](#resolver-priorities)

```
$resolver = new ParameterResolver([
    new ArrayResolver(),           // Priority 1: Explicit parameters
    new ArrayTypedResolver(),      // Priority 2: Type matching
    new ContainerResolver($container), // Priority 3: DI container
    new DefaultValueResolver(),    // Priority 4: Default values
    new NullableResolver()         // Priority 5: Nullable fallback
]);
```

Error Handling
--------------

[](#error-handling)

```
use Bermuda\ParameterResolver\ParameterResolutionException;

try {
    $resolvedParams = $resolver->resolve($parameters, $providedParams);
} catch (ParameterResolutionException $e) {
    echo "Failed to resolve parameter: " . $e->parameter->getName();
    echo "Provided parameters: " . print_r($e->providedParameters, true);
    echo "Already resolved: " . print_r($e->resolvedParameters, true);
}
```

Performance Tips
----------------

[](#performance-tips)

1. **Order resolvers by frequency** - put most commonly used resolvers first
2. **Use typed parameters** when possible for faster ArrayTypedResolver matching
3. **Avoid deep nesting** in Config paths for better performance
4. **Cache reflection objects** when resolving the same signatures repeatedly

Requirements
------------

[](#requirements)

- PHP 8.4 or higher

License
-------

[](#license)

MIT License. See [LICENSE](LICENSE) for details.

###  Health Score

32

—

LowBetter than 69% of packages

Maintenance49

Moderate activity, may be stable

Popularity7

Limited adoption so far

Community9

Small or concentrated contributor base

Maturity54

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

Unknown

Total

1

Last Release

369d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/20490712?v=4)[Andrey Shelamkoff](/maintainers/Shelamkoff)[@Shelamkoff](https://github.com/Shelamkoff)

---

Top Contributors

[![Shelamkoff](https://avatars.githubusercontent.com/u/20490712?v=4)](https://github.com/Shelamkoff "Shelamkoff (111 commits)")

---

Tags

dependency-injectiondiparameter-resolversphpphp84reflectionresolverPSR-11configdependency-injectionreflectiondiattributesparameter-resolutionparameter-resolver

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/bermudaphp-di-resolver/health.svg)

```
[![Health](https://phpackages.com/badges/bermudaphp-di-resolver/health.svg)](https://phpackages.com/packages/bermudaphp-di-resolver)
```

###  Alternatives

[php-di/php-di

The dependency injection container for humans

2.9k55.5M1.2k](/packages/php-di-php-di)[laminas/laminas-servicemanager

Factory-Driven Dependency Injection Container

16058.7M810](/packages/laminas-laminas-servicemanager)[infocyph/intermix

A lightweight PHP DI container, invoker, serializer, and utility toolkit.

137.7k2](/packages/infocyph-intermix)[slince/di

A flexible dependency injection container

20272.1k6](/packages/slince-di)

PHPackages © 2026

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