Lazy services

composer.json

@@ -30,6 +30,7 @@
     },
     "require-dev": {
         "league/container": "^3.3",
+        "ocramius/proxy-manager": "^2.13",
         "phpbench/phpbench": "^1.0.0",
         "phpunit/phpunit": "^9.4",
         "roave/infection-static-analysis-plugin": "^1.6",
@@ -38,7 +39,8 @@
     },
     "suggest": {
         "yiisoft/injector": "^1.0@dev",
-        "phpbench/phpbench": "To run benchmarks."
+        "phpbench/phpbench": "To run benchmarks.",
+        "ocramius/proxy-manager": "Install this package if you want to use lazy loading."
     },
     "provide": {
         "psr/container-implementation": "1.0.0"

src/Container.php

@@ -5,18 +5,20 @@
 namespace Yiisoft\Di;
 
 use Closure;
+use ProxyManager\Factory\LazyLoadingValueHolderFactory;
 use Psr\Container\ContainerInterface;
 use Yiisoft\Di\Contracts\DeferredServiceProviderInterface;
 use Yiisoft\Di\Contracts\ServiceProviderInterface;
 use Yiisoft\Factory\Definition\ArrayDefinition;
+use Yiisoft\Factory\Definition\Decorator\LazyDefinitionDecorator;
+use Yiisoft\Factory\Definition\DefinitionInterface;
 use Yiisoft\Factory\Definition\DefinitionValidator;
 use Yiisoft\Factory\DependencyResolverInterface;
 use Yiisoft\Factory\Exception\CircularReferenceException;
 use Yiisoft\Factory\Exception\InvalidConfigException;
 use Yiisoft\Factory\Exception\NotFoundException;
 use Yiisoft\Factory\Exception\NotInstantiableException;
 use Yiisoft\Injector\Injector;
-
 use function array_key_exists;
 use function array_keys;
 use function assert;
@@ -35,7 +37,8 @@ final class Container extends AbstractContainerConfigurator implements Container
 {
     private const META_TAGS = 'tags';
     private const META_RESET = 'reset';
-    private const ALLOWED_META = [self::META_TAGS, self::META_RESET];
+    private const META_LAZY = 'lazy';
+    private const ALLOWED_META = [self::META_TAGS, self::META_RESET, self::META_LAZY];
 
     /**
      * @var array object definitions indexed by their types
@@ -63,6 +66,7 @@ final class Container extends AbstractContainerConfigurator implements Container
 
     private ?CompositeContainer $rootContainer = null;
     private DependencyResolverInterface $dependencyResolver;
+    private LazyLoadingValueHolderFactory $lazyFactory;
 
     /**
      * Container constructor.
@@ -185,6 +189,7 @@ protected function set(string $id, $definition): void
             $this->validateDefinition($definition, $id);
             $this->validateMeta($meta);
         }
+        $definition = DefinitionNormalizer::normalize($definition, $id);
 
         if (isset($meta[self::META_TAGS])) {
             if ($this->validate) {
@@ -195,6 +200,9 @@ protected function set(string $id, $definition): void
         if (isset($meta[self::META_RESET])) {
             $this->setResetter($id, $meta[self::META_RESET]);
         }
+        if (isset($meta[self::META_LAZY]) && $meta[self::META_LAZY] === true) {
+            $definition = $this->decorateLazy($id, $definition);
+        }
 
         unset($this->instances[$id]);
         $this->definitions[$id] = $definition;
@@ -368,9 +376,8 @@ private function buildInternal(string $id)
             return $this->buildPrimitive($id);
         }
         $this->processDefinition($this->definitions[$id]);
-        $definition = DefinitionNormalizer::normalize($this->definitions[$id], $id);
 
-        return $definition->resolve($this->dependencyResolver);
+        return $this->definitions[$id]->resolve($this->dependencyResolver);
     }
 
     /**
@@ -461,4 +468,26 @@ private function getVariableType($variable): string
 
         return gettype($variable);
     }
+
+    private function decorateLazy(string $id, DefinitionInterface $definition): DefinitionInterface
+    {
+        $factory = $this->getLazyLoadingValueHolderFactory();
+        if (class_exists($id) || interface_exists($id)) {
+            $class = $id;
+        } elseif ($definition instanceof ArrayDefinition) {
+            $class = $definition->getClass();
+        } else {
+            throw new \RuntimeException('Could not determinate object class');
+        }
+
+        return new LazyDefinitionDecorator($factory, $definition, $class);
+    }
+
+    private function getLazyLoadingValueHolderFactory(): LazyLoadingValueHolderFactory
+    {
+        if (!class_exists(LazyLoadingValueHolderFactory::class)) {
+            throw new \RuntimeException('You should install `ocramius/proxy-manager` if you want to use lazy services.');
+        }
+        return $this->lazyFactory ??= new LazyLoadingValueHolderFactory();
+    }
 }

tests/Unit/DefinitionParserTest.php

@@ -17,21 +17,25 @@ public function testParseCallableDefinition(): void
         $definition = [
             'definition' => $fn,
             'tags' => ['one', 'two'],
+            'lazy' => true,
         ];
-        [$definition, $meta] = (new DefinitionParser(['tags']))->parse($definition);
+        [$definition, $meta] = DefinitionParser::parse($definition);
+
         $this->assertSame($fn, $definition);
-        $this->assertSame(['tags' => ['one', 'two']], $meta);
+        $this->assertSame(['tags' => ['one', 'two'], 'lazy' => true], $meta);
     }
 
     public function testParseArrayCallableDefinition(): void
     {
         $definition = [
             'definition' => [StaticFactory::class, 'create'],
             'tags' => ['one', 'two'],
+            'lazy' => true,
         ];
-        [$definition, $meta] = (new DefinitionParser(['tags']))->parse($definition);
+        [$definition, $meta] = DefinitionParser::parse($definition);
+
         $this->assertSame([StaticFactory::class, 'create'], $definition);
-        $this->assertSame(['tags' => ['one', 'two']], $meta);
+        $this->assertSame(['tags' => ['one', 'two'], 'lazy' => true], $meta);
     }
 
     public function testParseArrayDefinition(): void
@@ -40,14 +44,16 @@ public function testParseArrayDefinition(): void
             'class' => EngineMarkOne::class,
             '__construct()' => [42],
             'tags' => ['one', 'two'],
+            'lazy' => true,
         ];
-        [$definition, $meta] = (new DefinitionParser(['tags']))->parse($definition);
+        [$definition, $meta] = DefinitionParser::parse($definition);
+
         $this->assertSame([
             EngineMarkOne::class,
             [42],
             [],
             DefinitionParser::IS_PREPARED_ARRAY_DEFINITION_DATA => true,
         ], $definition);
-        $this->assertSame(['tags' => ['one', 'two']], $meta);
+        $this->assertSame(['tags' => ['one', 'two'], 'lazy' => true], $meta);
     }
 }

tests/Unit/LazyServiceContainerTest.php

@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Di\Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use ProxyManager\Proxy\LazyLoadingInterface;
+use Yiisoft\Di\Container;
+use Yiisoft\Di\Tests\Support\EngineMarkOne;
+
+class LazyServiceContainerTest extends TestCase
+{
+    public function testIsTheSameObject(): void
+    {
+        $class = EngineMarkOne::class;
+        $number = 55;
+
+        $container = new Container([
+            EngineMarkOne::class => [
+                'class' => $class,
+                'setNumber()' => [$number],
+                'lazy' => true,
+            ],
+        ]);
+
+        /* @var \Yiisoft\Di\Tests\Support\EngineMarkOne $object */
+        $object = $container->get($class);
+
+        self::assertInstanceOf(LazyLoadingInterface::class, $object);
+        self::assertFalse($object->isProxyInitialized());
+        self::assertEquals($number, $object->getNumber());
+        self::assertTrue($object->isProxyInitialized());
+
+        /* @var \Yiisoft\Di\Tests\Support\EngineMarkOne $object */
+        $object = $container->get($class);
+
+        self::assertInstanceOf(LazyLoadingInterface::class, $object);
+        self::assertTrue($object->isProxyInitialized());
+    }
+
+    /**
+     * @dataProvider lazyDefinitionDataProvider
+     */
+    public function testLazy(array $definitions, string $id): void
+    {
+        $container = new Container($definitions);
+
+        $object = $container->get($id);
+
+        self::assertInstanceOf(LazyLoadingInterface::class, $object);
+    }
+
+    public function lazyDefinitionDataProvider(): array
+    {
+        return [
+            'class as key' => [
+                [EngineMarkOne::class => [
+                    'class' => EngineMarkOne::class,
+                    'lazy' => true,
+                ]],
+                EngineMarkOne::class,
+            ],
+            'alias as key' => [
+                ['mark_one' => [
+                    'class' => EngineMarkOne::class,
+                    'lazy' => true,
+                ]],
+                'mark_one',
+            ],
+            'dedicated array definition' => [
+                [EngineMarkOne::class => [
+                    'definition' => ['class' => EngineMarkOne::class],
+                    'lazy' => true,
+                ]],
+                EngineMarkOne::class,
+            ],
+            'dedicated callback definition' => [
+                [EngineMarkOne::class => [
+                    'definition' => fn () => new EngineMarkOne(),
+                    'lazy' => true,
+                ]],
+                EngineMarkOne::class,
+            ],
+        ];
+    }
+}