Introduce #[Autowire]

To inject services in #[Type] methods.

Author: jerowork

docs/todo.md

@@ -6,7 +6,7 @@ This library is still work in progress, and misses some valuable features:
 - ~~Allow simple lists (array type)~~
 - ~~Make AST serializable (cacheable)~~
 - ~~Handle `DateTime` and `DateTimeImmutable`~~
+- ~~Inject autowiring services~~
 - Connection, edge, nodes (see https://relay.dev/graphql/connections.htm)
 - GraphQL interfaces, inheritance
-- Inject autowiring services
 - Subscriptions

src/Attribute/Autowire.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Jerowork\GraphqlAttributeSchema\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PARAMETER)]
+final readonly class Autowire
+{
+    /**
+     * @param string|class-string $service
+     */
+    public function __construct(
+        public ?string $service = null,
+    ) {}
+}

src/Parser/Node/Child/AutowireNode.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Jerowork\GraphqlAttributeSchema\Parser\Node\Child;
+
+use Jerowork\GraphqlAttributeSchema\Parser\Node\ArraySerializable;
+
+/**
+ * @phpstan-type AutowireNodePayload array{
+ *     service: string|class-string,
+ *     propertyName: string,
+ * }
+ *
+ * @implements ArraySerializable<AutowireNodePayload>
+ */
+final readonly class AutowireNode implements ArraySerializable
+{
+    public function __construct(
+        public string $service,
+        public string $propertyName,
+    ) {}
+
+    public function toArray(): array
+    {
+        return [
+            'service' => $this->service,
+            'propertyName' => $this->propertyName,
+        ];
+    }
+
+    public static function fromArray(array $payload): AutowireNode
+    {
+        return new self(
+            $payload['service'],
+            $payload['propertyName'],
+        );
+    }
+}

src/Parser/Node/Child/FieldNode.php

@@ -9,13 +9,17 @@
 
 /**
  * @phpstan-import-type ArgNodePayload from ArgNode
+ * @phpstan-import-type AutowireNodePayload from AutowireNode
  * @phpstan-import-type TypePayload from Type
  *
  * @phpstan-type FieldNodePayload array{
  *     type: TypePayload,
  *     name: string,
  *     description: null|string,
- *     argNodes: list<ArgNodePayload>,
+ *     argumentNodes: list<array{
+ *          node: class-string<ArgNode|AutowireNode>,
+ *          payload: ArgNodePayload|AutowireNodePayload
+ *     }>,
  *     fieldType: string,
  *     methodName: null|string,
  *     propertyName: null|string,
@@ -27,13 +31,13 @@
 final readonly class FieldNode implements ArraySerializable
 {
     /**
-     * @param list<ArgNode> $argNodes
+     * @param list<ArgNode|AutowireNode> $argumentNodes
      */
     public function __construct(
         public Type $type,
         public string $name,
         public ?string $description,
-        public array $argNodes,
+        public array $argumentNodes,
         public FieldNodeType $fieldType,
         public ?string $methodName,
         public ?string $propertyName,
@@ -42,11 +46,19 @@ public function __construct(
 
     public function toArray(): array
     {
+        $argumentNodes = [];
+        foreach ($this->argumentNodes as $argumentNode) {
+            $argumentNodes[] = [
+                'node' => $argumentNode::class,
+                'payload' => $argumentNode->toArray(),
+            ];
+        }
+
         return [
             'type' => $this->type->toArray(),
             'name' => $this->name,
             'description' => $this->description,
-            'argNodes' => array_map(fn($argNode) => $argNode->toArray(), $this->argNodes),
+            'argumentNodes' => $argumentNodes,
             'fieldType' => $this->fieldType->value,
             'methodName' => $this->methodName,
             'propertyName' => $this->propertyName,
@@ -56,11 +68,23 @@ public function toArray(): array
 
     public static function fromArray(array $payload): FieldNode
     {
+        $argumentNodes = [];
+        foreach ($payload['argumentNodes'] as $argumentNode) {
+            $argumentPayload = $argumentNode['payload'];
+            if ($argumentNode['node'] === ArgNode::class) {
+                /** @var ArgNodePayload $argumentPayload */
+                $argumentNodes[] = ArgNode::fromArray($argumentPayload);
+            } else {
+                /** @var AutowireNodePayload $argumentPayload */
+                $argumentNodes[] = AutowireNode::fromArray($argumentPayload);
+            }
+        }
+
         return new self(
             Type::fromArray($payload['type']),
             $payload['name'],
             $payload['description'],
-            array_map(fn($argNodePayload) => ArgNode::fromArray($argNodePayload), $payload['argNodes']),
+            $argumentNodes,
             FieldNodeType::from($payload['fieldType']),
             $payload['methodName'],
             $payload['propertyName'],

src/Parser/NodeParser/Child/ArgNodeParser.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Jerowork\GraphqlAttributeSchema\Parser\NodeParser\Child;
+
+use Jerowork\GraphqlAttributeSchema\Attribute\Arg;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\Child\ArgNode;
+use Jerowork\GraphqlAttributeSchema\Parser\NodeParser\GetTypeTrait;
+use Jerowork\GraphqlAttributeSchema\Parser\NodeParser\ParseException;
+use ReflectionParameter;
+
+final readonly class ArgNodeParser
+{
+    use GetTypeTrait;
+
+    /**
+     * @throws ParseException
+     */
+    public function parse(ReflectionParameter $parameter, ?Arg $attribute): ArgNode
+    {
+        $type = $this->getType($parameter->getType(), $attribute);
+
+        if ($type === null) {
+            throw ParseException::invalidParameterType($parameter->getName());
+        }
+
+        return new ArgNode(
+            $type,
+            $attribute->name ?? $parameter->getName(),
+            $attribute?->description,
+            $parameter->getName(),
+        );
+    }
+}

src/Parser/NodeParser/Child/AutowireNodeParser.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Jerowork\GraphqlAttributeSchema\Parser\NodeParser\Child;
+
+use Jerowork\GraphqlAttributeSchema\Attribute\Autowire;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\Child\AutowireNode;
+use Jerowork\GraphqlAttributeSchema\Parser\NodeParser\ParseException;
+use ReflectionParameter;
+use ReflectionNamedType;
+
+final readonly class AutowireNodeParser
+{
+    /**
+     * @throws ParseException
+     */
+    public function parse(ReflectionParameter $parameter, Autowire $attribute): AutowireNode
+    {
+        if ($attribute->service !== null) {
+            return new AutowireNode(
+                $attribute->service,
+                $parameter->getName(),
+            );
+        }
+
+        if (!$parameter->getType() instanceof ReflectionNamedType) {
+            throw ParseException::invalidAutowiredParameterType($parameter->getName());
+        }
+
+        return new AutowireNode(
+            $parameter->getType()->getName(),
+            $parameter->getName(),
+        );
+    }
+}

src/Parser/NodeParser/Child/ClassFieldNodesParser.php

@@ -22,7 +22,7 @@
     private const array RESERVED_METHOD_NAMES = ['__construct'];
 
     public function __construct(
-        private MethodArgNodesParser $methodArgNodesParser,
+        private MethodArgumentNodesParser $methodArgNodesParser,
     ) {}
 
     /**

src/Parser/NodeParser/Child/MethodArgNodesParser.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Jerowork\GraphqlAttributeSchema\Parser\NodeParser\Child;
+
+use Jerowork\GraphqlAttributeSchema\Attribute\Arg;
+use Jerowork\GraphqlAttributeSchema\Attribute\Autowire;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\Child\ArgNode;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\Child\AutowireNode;
+use Jerowork\GraphqlAttributeSchema\Parser\NodeParser\ParseException;
+use ReflectionMethod;
+use ReflectionParameter;
+
+final readonly class MethodArgumentNodesParser
+{
+    public function __construct(
+        private AutowireNodeParser $autowireNodeParser,
+        private ArgNodeParser $argNodeParser,
+    ) {}
+
+    /**
+     * @throws ParseException
+     *
+     * @return list<ArgNode|AutowireNode>
+     */
+    public function parse(ReflectionMethod $method, bool $includeAutowireNodes = true): array
+    {
+        $argumentNodes = [];
+
+        foreach ($method->getParameters() as $parameter) {
+            if ($includeAutowireNodes) {
+                $autowireAttribute = $this->getAttribute($parameter, Autowire::class);
+
+                if ($autowireAttribute !== null) {
+                    $argumentNodes[] = $this->autowireNodeParser->parse($parameter, $autowireAttribute);
+
+                    continue;
+                }
+            }
+
+            $argAttribute = $this->getAttribute($parameter, Arg::class);
+
+            $argumentNodes[] = $this->argNodeParser->parse($parameter, $argAttribute);
+        }
+
+        return $argumentNodes;
+    }
+
+    /**
+     * @template T of object
+     *
+     * @param class-string<T> $attributeName
+     *
+     * @return T
+     */
+    private function getAttribute(ReflectionParameter $parameter, string $attributeName): ?object
+    {
+        $attributes = $parameter->getAttributes($attributeName);
+
+        if ($attributes === []) {
+            return null;
+        }
+
+        return array_pop($attributes)->newInstance();
+    }
+}

src/Parser/NodeParser/Child/MethodArgumentNodesParser.php

@@ -5,9 +5,10 @@
 namespace Jerowork\GraphqlAttributeSchema\Parser\NodeParser;
 
 use Jerowork\GraphqlAttributeSchema\Attribute\Mutation;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\Child\ArgNode;
 use Jerowork\GraphqlAttributeSchema\Parser\Node\MutationNode;
 use Jerowork\GraphqlAttributeSchema\Parser\Node\Node;
-use Jerowork\GraphqlAttributeSchema\Parser\NodeParser\Child\MethodArgNodesParser;
+use Jerowork\GraphqlAttributeSchema\Parser\NodeParser\Child\MethodArgumentNodesParser;
 use ReflectionClass;
 use Override;
 
@@ -21,7 +22,7 @@
     private const string RESOLVER_SUFFIX = 'Mutation';
 
     public function __construct(
-        private MethodArgNodesParser $methodArgNodesParser,
+        private MethodArgumentNodesParser $methodArgumentNodesParser,
     ) {}
 
     #[Override]
@@ -42,11 +43,14 @@ public function parse(ReflectionClass $class): Node
             throw ParseException::invalidReturnType($class->getName(), $method->getName());
         }
 
+        /** @var list<ArgNode> $argumentNodes */
+        $argumentNodes = $this->methodArgumentNodesParser->parse($method, false);
+
         return new MutationNode(
             $class->getName(),
             $this->retrieveNameForResolver($class, $attribute, self::RESOLVER_SUFFIX),
             $attribute->getDescription(),
-            $this->methodArgNodesParser->parse($method),
+            $argumentNodes,
             $type,
             $method->getName(),
             $attribute->deprecationReason,