Merge pull request #189 from TomHAnderson/feature/ghost-in-the-container

TomHAnderson · web-flow · commit 7738edf522a5 · 2025-12-22T19:52:03.000-07:00
Use LazyGhosts in containers
diff --git a/src/Filter/FilterFactory.php b/src/Filter/FilterFactory.php
@@ -16,6 +16,7 @@
 use GraphQL\Type\Definition\ScalarType;
 use GraphQL\Type\Definition\Type;
 use League\Event\EventDispatcher;
+use ReflectionClass;
 
 use function array_filter;
 use function array_keys;
@@ -88,10 +89,15 @@ public function get(
         $fields = $this->addFields($targetEntity, $allowedFilters);
         $fields = array_merge($fields, $this->addAssociations($targetEntity, $allowedFilters));
 
-        $inputObject = new GraphQLInputObjectType([
-            'name' => $typeName,
-            'fields' => static fn () => $fields,
-        ]);
+        $inputObject = (new ReflectionClass(GraphQLInputObjectType::class))
+            ->newLazyGhost(static function (GraphQLInputObjectType $object) use ($typeName, $fields): void {
+                $object->__construct(
+                    [
+                        'name' => $typeName,
+                        'fields' => static fn () => $fields,
+                    ],
+                );
+            });
 
         $this->typeContainer->set($typeName, $inputObject);
 
diff --git a/src/Hydrator/HydratorContainer.php b/src/Hydrator/HydratorContainer.php
@@ -12,6 +12,7 @@
 use Laminas\Hydrator\NamingStrategy\MapNamingStrategy;
 use Laminas\Hydrator\Strategy\StrategyInterface;
 use Override;
+use ReflectionClass;
 
 use function assert;
 use function class_implements;
@@ -44,26 +45,39 @@ public function get(string $id): mixed
             return parent::get($id);
         }
 
-        $entity   = $this->entityTypeContainer->get($id);
-        $metadata = $entity->getMetadata();
-        $hydrator = new DoctrineObject($this->entityManager, $metadata['byValue']);
+        $self = $this;
+        // Compose hydrators as Lazy Ghosts
+        $hydrator = (new ReflectionClass(DoctrineObject::class))
+            ->newLazyGhost(static function (DoctrineObject $object) use ($self, $id): void {
+                $entityManager = $self->entityManager;
+                $entity        = $self->entityTypeContainer->get($id);
+                $metadata      = $entity->getMetadata();
+                $byValue       = $metadata['byValue'];
 
-        // Create field strategy and assign to hydrator
-        foreach ($metadata['fields'] as $fieldName => $fieldMetadata) {
-            assert(
-                in_array(StrategyInterface::class, class_implements($fieldMetadata['hydratorStrategy'])),
-                'Strategy must implement ' . StrategyInterface::class,
-            );
+                $object->__construct(
+                    $entityManager,
+                    $byValue,
+                );
 
-            $hydrator->addStrategy($fieldName, $this->get($fieldMetadata['hydratorStrategy']));
-        }
+                // Create field strategy and assign to hydrator
+                foreach ($metadata['fields'] as $fieldName => $fieldMetadata) {
+                    assert(
+                        in_array(StrategyInterface::class, class_implements($fieldMetadata['hydratorStrategy'])),
+                        'Strategy must implement ' . StrategyInterface::class,
+                    );
 
-        // Create naming strategy for aliases and assign to hydrator
-        if ($entity->getExtractionMap()) {
-            $hydrator->setNamingStrategy(
-                MapNamingStrategy::createFromExtractionMap($entity->getExtractionMap()),
-            );
-        }
+                    $object->addStrategy($fieldName, $self->get($fieldMetadata['hydratorStrategy']));
+                }
+
+                // Create naming strategy for aliases and assign to hydrator
+                if (! $entity->getExtractionMap()) {
+                    return;
+                }
+
+                $object->setNamingStrategy(
+                    MapNamingStrategy::createFromExtractionMap($entity->getExtractionMap()),
+                );
+            });
 
         $this->set($id, $hydrator);
 
diff --git a/src/Input/InputFactory.php b/src/Input/InputFactory.php
@@ -13,6 +13,7 @@
 use GraphQL\Type\Definition\InputObjectField;
 use GraphQL\Type\Definition\InputObjectType;
 use GraphQL\Type\Definition\Type;
+use ReflectionClass;
 
 use function count;
 use function in_array;
@@ -41,21 +42,26 @@ public function __construct(
      */
     public function get(string $id, array $requiredFields = [], array $optionalFields = []): InputObjectType
     {
-        $fields       = [];
-        $targetEntity = $this->entityTypeContainer->get($id);
-
-        if (! count($requiredFields) && ! count($optionalFields)) {
-            $this->addAllFieldsAsRequired($targetEntity, $fields);
-        } else {
-            $this->addRequiredFields($targetEntity, $requiredFields, $fields);
-            $this->addOptionalFields($targetEntity, $optionalFields, $fields);
-        }
-
-        return new InputObjectType([
-            'name' => $targetEntity->getTypeName() . '_Input_' . uniqid(),
-            'description' => $targetEntity->getDescription(),
-            'fields' => static fn () => $fields,
-        ]);
+        $self = $this;
+
+        return (new ReflectionClass(InputObjectType::class))
+            ->newLazyGhost(static function (InputObjectType $object) use ($self, $id, $requiredFields, $optionalFields): void {
+                $fields       = [];
+                $targetEntity = $self->entityTypeContainer->get($id);
+
+                if (! count($requiredFields) && ! count($optionalFields)) {
+                    $self->addAllFieldsAsRequired($targetEntity, $fields);
+                } else {
+                    $self->addRequiredFields($targetEntity, $requiredFields, $fields);
+                    $self->addOptionalFields($targetEntity, $optionalFields, $fields);
+                }
+
+                $object->__construct([
+                    'name' => $targetEntity->getTypeName() . '_Input_' . uniqid(),
+                    'description' => $targetEntity->getDescription(),
+                    'fields' => static fn () => $fields,
+                ]);
+            });
     }
 
     /**
diff --git a/src/Type/Entity/Entity.php b/src/Type/Entity/Entity.php
@@ -6,7 +6,6 @@
 
 use ApiSkeletons\Doctrine\ORM\GraphQL\Config;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Container;
-use ApiSkeletons\Doctrine\ORM\GraphQL\Driver;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Event\EntityDefinition;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Filter\FilterFactory;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\HydratorContainer;
@@ -20,14 +19,13 @@
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\MappingException;
 use Exception;
-use GraphQL\Error\Error;
 use GraphQL\Type\Definition\ObjectType;
 use Laminas\Hydrator\HydratorInterface;
 use League\Event\EventDispatcher;
+use ReflectionClass;
 
 use function array_keys;
 use function array_merge;
-use function assert;
 use function count;
 use function in_array;
 use function ksort;
@@ -60,8 +58,6 @@ public function __construct(
         string $typeName,
         private string|null $eventName = null,
     ) {
-        assert($container instanceof Driver);
-
         $this->config                   = $container->get(Config::class);
         $this->entityManager            = $container->get(EntityManager::class);
         $this->entityTypeContainer      = $container->get(EntityTypeContainer::class);
@@ -71,14 +67,7 @@ public function __construct(
         $this->hydratorContainer        = $container->get(HydratorContainer::class);
         $this->resolveCollectionFactory = $container->get(ResolveCollectionFactory::class);
         $this->typeContainer            = $container->get(TypeContainer::class);
-
-        if (! isset($container->get('metadata')[$typeName])) {
-            throw new Error(
-                'Entity ' . $typeName . ' is not mapped in the GraphQL metadata',
-            );
-        }
-
-        $this->metadata = $container->get('metadata')[$typeName];
+        $this->metadata                 = $container->get('metadata')[$typeName];
     }
 
     public function getHydrator(): HydratorInterface
@@ -184,7 +173,12 @@ public function getObjectType(): ObjectType
         }
 
         /** @psalm-suppress InvalidArgument */
-        $this->objectType = new ObjectType($arrayObject->getArrayCopy());
+        $this->objectType = (new ReflectionClass(ObjectType::class))
+            ->newLazyGhost(static function (ObjectType $object) use ($arrayObject): void {
+                $object->__construct(
+                    $arrayObject->getArrayCopy(),
+                );
+            });
 
         return $this->objectType;
     }
diff --git a/src/Type/Entity/EntityTypeContainer.php b/src/Type/Entity/EntityTypeContainer.php
@@ -5,10 +5,10 @@
 namespace ApiSkeletons\Doctrine\ORM\GraphQL\Type\Entity;
 
 use ApiSkeletons\Doctrine\ORM\GraphQL\Container;
-use ApiSkeletons\Doctrine\ORM\GraphQL\Driver;
+use GraphQL\Error\Error;
 use Override;
+use ReflectionClass;
 
-use function assert;
 use function strtolower;
 
 /**
@@ -20,7 +20,6 @@ class EntityTypeContainer extends Container
     public function __construct(
         protected readonly Container $container,
     ) {
-        assert($container instanceof Driver);
     }
 
     /**
@@ -45,7 +44,26 @@ public function get(string $id, string|null $eventName = null): mixed
             return $this->register[$key];
         }
 
-        $this->set($key, new Entity($this->container, $id, $eventName));
+        if (! $this->has($id)) {
+            throw new Error(
+                'Entity ' . $id . ' is not mapped in the GraphQL metadata',
+            );
+        }
+
+        $container = $this->container;
+
+        // Use a Lazy Ghost object
+        $this->set(
+            $key,
+            (new ReflectionClass(Entity::class))
+                ->newLazyGhost(static function (Entity $object) use ($container, $id, $eventName): void {
+                    $object->__construct(
+                        $container,
+                        $id,
+                        $eventName,
+                    );
+                }),
+        );
 
         return $this->get($id, $eventName);
     }
