use type info in argument resolver

Author: DavidBadura

src/Metadata/Subscriber/ArgumentMetadata.php

@@ -4,12 +4,13 @@
 
 namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 
+use Symfony\Component\TypeInfo\Type;
+
 final class ArgumentMetadata
 {
     public function __construct(
         public readonly string $name,
-        public readonly string $type,
-        public readonly bool $allowsNull = false,
+        public readonly Type $type,
     ) {
     }
 }

src/Metadata/Subscriber/ArgumentTypeNotSupported.php

@@ -21,16 +21,4 @@ public static function missingType(string $class, string $method, string $argume
             ),
         );
     }
-
-    public static function onlyNamedTypeSupported(string $class, string $method, string $argumentName): self
-    {
-        return new self(
-            sprintf(
-                'Argument type for method "%s" in class "%s" is not supported. Argument "%s" must not have a union or intersection type.',
-                $method,
-                $class,
-                $argumentName,
-            ),
-        );
-    }
 }

src/Metadata/Subscriber/AttributeSubscriberMetadataFactory.php

@@ -14,13 +14,20 @@
 use ReflectionAttribute;
 use ReflectionClass;
 use ReflectionMethod;
-use ReflectionNamedType;
+use Symfony\Component\TypeInfo\TypeResolver\TypeResolver;
 
 use function array_key_exists;
 use function count;
 
 final class AttributeSubscriberMetadataFactory implements SubscriberMetadataFactory
 {
+    private readonly TypeResolver $typeResolver;
+
+    public function __construct()
+    {
+        $this->typeResolver = TypeResolver::create();
+    }
+
     /** @var array<class-string, SubscriberMetadata> */
     private array $subscriberMetadata = [];
 
@@ -171,18 +178,9 @@ private function subscribeMethod(ReflectionMethod $method): SubscribeMethodMetad
                 );
             }
 
-            if (!$type instanceof ReflectionNamedType) {
-                throw ArgumentTypeNotSupported::onlyNamedTypeSupported(
-                    $method->getDeclaringClass()->getName(),
-                    $method->getName(),
-                    $parameter->getName(),
-                );
-            }
-
             $arguments[] = new ArgumentMetadata(
                 $parameter->getName(),
-                $type->getName(),
-                $parameter->allowsNull(),
+                $this->typeResolver->resolve($type),
             );
         }
 

src/Subscription/Subscriber/ArgumentResolver/EventArgumentResolver.php

@@ -7,9 +7,6 @@
 use Patchlevel\EventSourcing\Message\Message;
 use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
 
-use function class_exists;
-use function is_a;
-
 final class EventArgumentResolver implements ArgumentResolver
 {
     public function resolve(ArgumentMetadata $argument, Message $message): object
@@ -19,6 +16,6 @@ public function resolve(ArgumentMetadata $argument, Message $message): object
 
     public function support(ArgumentMetadata $argument, string $eventClass): bool
     {
-        return class_exists($argument->type) && is_a($eventClass, $argument->type, true);
+        return $argument->type->isIdentifiedBy($eventClass);
     }
 }

src/Subscription/Subscriber/ArgumentResolver/LookupResolver.php

@@ -29,6 +29,6 @@ public function resolve(ArgumentMetadata $argument, Message $message): Lookup
 
     public function support(ArgumentMetadata $argument, string $eventClass): bool
     {
-        return $argument->type === Lookup::class;
+        return $argument->type->isIdentifiedBy(Lookup::class);
     }
 }

src/Subscription/Subscriber/ArgumentResolver/MessageArgumentResolver.php

@@ -16,6 +16,6 @@ public function resolve(ArgumentMetadata $argument, Message $message): Message
 
     public function support(ArgumentMetadata $argument, string $eventClass): bool
     {
-        return $argument->type === Message::class;
+        return $argument->type->isIdentifiedBy(Message::class);
     }
 }

src/Subscription/Subscriber/ArgumentResolver/RecordedOnArgumentResolver.php

@@ -18,6 +18,6 @@ public function resolve(ArgumentMetadata $argument, Message $message): DateTimeI
 
     public function support(ArgumentMetadata $argument, string $eventClass): bool
     {
-        return $argument->type === DateTimeImmutable::class;
+        return $argument->type->isIdentifiedBy(DateTimeImmutable::class);
     }
 }

tests/Unit/Metadata/Subscriber/AttributeSubscriberMetadataFactoryTest.php

@@ -25,6 +25,7 @@
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\TestCase;
 use Stringable;
+use Symfony\Component\TypeInfo\Type;
 
 #[CoversClass(AttributeSubscriberMetadataFactory::class)]
 final class AttributeSubscriberMetadataFactoryTest extends TestCase
@@ -189,14 +190,14 @@ public function profileCreated(ProfileCreated $profileCreated, string $aggregate
             [
                 ProfileVisited::class => new SubscribeMethodMetadata(
                     'profileVisited',
-                    [new ArgumentMetadata('message', Message::class)],
+                    [new ArgumentMetadata('message', Type::object(Message::class))],
                 ),
 
                 ProfileCreated::class => new SubscribeMethodMetadata(
                     'profileCreated',
                     [
-                        new ArgumentMetadata('profileCreated', ProfileCreated::class),
-                        new ArgumentMetadata('aggregateId', 'string'),
+                        new ArgumentMetadata('profileCreated', Type::object(ProfileCreated::class)),
+                        new ArgumentMetadata('aggregateId', Type::string()),
                     ],
                 ),
             ],
@@ -220,7 +221,7 @@ public function profileVisited(ProfileVisited|null $message): void
         self::assertEquals(
             [
                 ProfileVisited::class => new SubscribeMethodMetadata('profileVisited', [
-                    new ArgumentMetadata('message', ProfileVisited::class, true),
+                    new ArgumentMetadata('message', Type::nullable(Type::object(ProfileVisited::class))),
                 ]),
             ],
             $metadata->subscribeMethods,
@@ -245,38 +246,6 @@ public function profileVisited($message): void
         $metadataFactory->metadata($subscriber::class);
     }
 
-    public function testUnionTypeNotSupported(): void
-    {
-        $this->expectException(ArgumentTypeNotSupported::class);
-
-        $subscriber = new #[Subscriber('foo', RunMode::FromBeginning)]
-        class {
-            #[Subscribe(ProfileVisited::class)]
-            public function profileVisited(ProfileVisited|ProfileCreated $event): void
-            {
-            }
-        };
-
-        $metadataFactory = new AttributeSubscriberMetadataFactory();
-        $metadataFactory->metadata($subscriber::class);
-    }
-
-    public function testIntersectionTypeNotSupported(): void
-    {
-        $this->expectException(ArgumentTypeNotSupported::class);
-
-        $subscriber = new #[Subscriber('foo', RunMode::FromBeginning)]
-        class {
-            #[Subscribe(ProfileVisited::class)]
-            public function profileVisited(ProfileVisited&Stringable $event): void
-            {
-            }
-        };
-
-        $metadataFactory = new AttributeSubscriberMetadataFactory();
-        $metadataFactory->metadata($subscriber::class);
-    }
-
     public function testSubscribeAllWithExplicitSubscribeMethod(): void
     {
         $this->expectException(DuplicateSubscribeMethod::class);

tests/Unit/Subscription/Subscriber/ArgumentResolver/EventArgumentResolverTest.php

@@ -12,6 +12,7 @@
 use Patchlevel\EventSourcing\Tests\Unit\Fixture\ProfileVisited;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\TypeInfo\Type;
 
 #[CoversClass(EventArgumentResolver::class)]
 final class EventArgumentResolverTest extends TestCase
@@ -22,14 +23,14 @@ public function testSupport(): void
 
         self::assertTrue(
             $resolver->support(
-                new ArgumentMetadata('foo', ProfileCreated::class, false),
+                new ArgumentMetadata('foo', Type::object(ProfileCreated::class)),
                 ProfileCreated::class,
             ),
         );
 
         self::assertFalse(
             $resolver->support(
-                new ArgumentMetadata('foo', ProfileVisited::class, false),
+                new ArgumentMetadata('foo', Type::object(ProfileVisited::class)),
                 ProfileCreated::class,
             ),
         );
@@ -45,7 +46,7 @@ public function testResolve(): void
         self::assertSame(
             $event,
             $resolver->resolve(
-                new ArgumentMetadata('foo', ProfileVisited::class, false),
+                new ArgumentMetadata('foo', Type::object(ProfileVisited::class)),
                 $message,
             ),
         );

tests/Unit/Subscription/Subscriber/ArgumentResolver/LookupResolverTest.php

@@ -16,6 +16,7 @@
 use Patchlevel\EventSourcing\Tests\Unit\Fixture\ProfileVisited;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\TypeInfo\Type;
 
 #[CoversClass(LookupResolver::class)]
 final class LookupResolverTest extends TestCase
@@ -29,14 +30,14 @@ public function testSupport(): void
 
         self::assertTrue(
             $resolver->support(
-                new ArgumentMetadata('lookup', Lookup::class, false),
+                new ArgumentMetadata('lookup', Type::object(Lookup::class)),
                 ProfileCreated::class,
             ),
         );
 
         self::assertFalse(
             $resolver->support(
-                new ArgumentMetadata('foo', ProfileCreated::class, false),
+                new ArgumentMetadata('foo', Type::object(ProfileCreated::class)),
                 ProfileCreated::class,
             ),
         );
@@ -56,7 +57,7 @@ public function testResolve(): void
         );
 
         $lookup = $resolver->resolve(
-            new ArgumentMetadata('foo', Lookup::class, false),
+            new ArgumentMetadata('foo', Type::object(Lookup::class)),
             $message,
         );