fix alias relationships not firing its own query

CHANGELOG.md

@@ -5,6 +5,7 @@ CHANGELOG
 --------------
 
 ### Added
+- Fix aliased relationships not fetching the correct data [\#604 / crissi](https://github.com/rebing/graphql-laravel/pull/604)
 - Support Laravel 7 [\#597 / exodusanto](https://github.com/rebing/graphql-laravel/pull/597)
 - Add support for custom authorization message [\#578 / Sh1d0w](https://github.com/rebing/graphql-laravel/pull/578)
 - Add support for macros on the GraphQL service/facade [\#592 / stevelacey](https://github.com/rebing/graphql-laravel/pull/592)

phpstan.neon.dist

@@ -17,6 +17,7 @@ parameters:
         - '/Parameter #1 \$haystack of function mb_stripos expects string, \(array\)\|string given/'
         - '/Strict comparison using === between null and array will always evaluate to false/'
         - '/Cannot access offset . on array\|Closure/'
+        - '/Function factory invoked with [0-9]+ parameter[s]?, 0 required/'
         # \Rebing\GraphQL\Support\SelectFields::handleFields
         - '/Parameter #1 \$function of function call_user_func expects callable\(\): mixed, array\(mixed, mixed\) given/'
         - '/Binary operation "." between string and array\|string\|null results in an error/'

src/Support/AliasedRelationships/AddModelRelationshipScope.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rebing\GraphQL\Support\AliasedRelationships;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Scope;
+
+class AddModelRelationshipScope implements Scope
+{
+    /**
+     * @var array<string,string>
+     */
+    private $relationships;
+
+    /**
+     * @param array<string,string> $relationships
+     */
+    public function __construct(array $relationships = [])
+    {
+        $this->relationships = $relationships;
+    }
+
+    public function extend(Builder $builder): void
+    {
+        foreach ($this->relationships as [$graphqlAlias, $relationship]) {
+            $builder->macro($graphqlAlias, function (Builder $builder) use ($relationship) {
+                return $builder->getModel()->{$relationship}();
+            });
+        }
+    }
+
+    public function apply(Builder $builder, Model $model)
+    {
+    }
+}

src/Support/AliasedRelationships/GenerateRelationshipKey.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rebing\GraphQL\Support\AliasedRelationships;
+
+class GenerateRelationshipKey
+{
+    const RELATIONSHIP_PRE_TEXT = '_generated_';
+
+    public static function generate(string $key): string
+    {
+        return self::RELATIONSHIP_PRE_TEXT.$key;
+    }
+}

src/Support/AliasedRelationships/ModelRelationshipAdder.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rebing\GraphQL\Support\AliasedRelationships;
+
+use Illuminate\Database\Eloquent\Model;
+
+class ModelRelationshipAdder
+{
+    /**
+     * @param class-string<Model> $model
+     * @param array<string,string> $relationships
+     * @return void
+     */
+    public static function add(string $model, array $relationships): void
+    {
+        $model::addGlobalScope(new AddModelRelationshipScope($relationships));
+    }
+}

src/Support/AliasedRelationships/Resolver.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rebing\GraphQL\Support\AliasedRelationships;
+
+use GraphQL\Type\Definition\ResolveInfo;
+
+class Resolver
+{
+    /**
+     * @param mixed $type
+     * @param array<string,mixed> $args
+     * @param mixed $context
+     * @param ResolveInfo $resolveInfo
+     * @return mixed
+     */
+    public function __invoke($type, $args, $context, ResolveInfo $resolveInfo)
+    {
+        $name = $resolveInfo->fieldName;
+        $alias = null;
+        if (isset($resolveInfo->fieldNodes[0]->alias)) {
+            $alias = GenerateRelationshipKey::generate($resolveInfo->fieldNodes[0]->alias->value);
+        }
+
+        return $type->{$alias ?: $name};
+    }
+}

src/Support/ResolveInfoFieldsAndArguments.php

@@ -115,16 +115,20 @@ private function foldSelectionSet(SelectionSetNode $selectionSet, int $descend):
         foreach ($selectionSet->selections as $selectionNode) {
             if ($selectionNode instanceof FieldNode) {
                 $name = $selectionNode->name->value;
+                $alias = $selectionNode->alias->value ?? null;
+                $key = $alias ?: $name;
 
-                $fields[$name] = [
+                $fields[$key] = [
+                    'name' => $name,
+                    'alias' => $alias,
                     'args' => [],
                     'fields' => $descend > 0 && ! empty($selectionNode->selectionSet)
                         ? $this->foldSelectionSet($selectionNode->selectionSet, $descend - 1)
                         : true,
                 ];
 
                 foreach ($selectionNode->arguments ?? [] as $argumentNode) {
-                    $fields[$name]['args'][$argumentNode->name->value] = $this->getValue($argumentNode->value);
+                    $fields[$key]['args'][$argumentNode->name->value] = $this->getValue($argumentNode->value);
                 }
             } elseif ($selectionNode instanceof FragmentSpreadNode) {
                 $spreadName = $selectionNode->name->value;

src/Support/SelectFields.php

@@ -11,6 +11,7 @@
 use GraphQL\Type\Definition\Type as GraphqlType;
 use GraphQL\Type\Definition\UnionType;
 use GraphQL\Type\Definition\WrappingType;
+use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\HasOne;
@@ -20,6 +21,9 @@
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Database\Query\Expression;
 use Illuminate\Support\Arr;
+use Rebing\GraphQL\Support\AliasedRelationships\GenerateRelationshipKey;
+use Rebing\GraphQL\Support\AliasedRelationships\ModelRelationshipAdder;
+use Rebing\GraphQL\Support\AliasedRelationships\Resolver as AliasedRelationshipsResolver;
 use RuntimeException;
 
 class SelectFields
@@ -28,7 +32,10 @@ class SelectFields
     private $select = [];
     /** @var array */
     private $relations = [];
-
+    /**
+     * @var array<class-string<Model>,array<string,string>>
+     */
+    private static $modelRelationshipsForAlias = [];
     const ALWAYS_RELATION_KEY = 'ALWAYS_RELATION_KEY';
 
     /**
@@ -49,6 +56,8 @@ public function __construct(ResolveInfo $info, GraphqlType $parentType, array $q
         $fields = self::getSelectableFieldsAndRelations($queryArgs, $requestedFields, $parentType, null, true, $ctx);
         $this->select = $fields[0];
         $this->relations = $fields[1];
+
+        $this->createModelRelationshipsForAlias();
     }
 
     private function getFieldSelection(ResolveInfo $resolveInfo, array $args, int $depth): array
@@ -148,6 +157,7 @@ protected static function handleFields(
         $parentTable = self::isMongodbInstance($parentType) ? null : self::getTableNameFromParentType($parentType);
 
         foreach ($requestedFields['fields'] as $key => $field) {
+
             // Ignore __typename, as it's a special case
             if ($key === '__typename') {
                 continue;
@@ -163,7 +173,7 @@ protected static function handleFields(
             // If field doesn't exist on definition we don't select it
             try {
                 if (method_exists($parentType, 'getField')) {
-                    $fieldObject = $parentType->getField($key);
+                    $fieldObject = $parentType->getField($field['name'] ?? $key);
                 } else {
                     continue;
                 }
@@ -204,16 +214,29 @@ protected static function handleFields(
                     if (isset($parentType->config['model'])) {
                         // Get the next parent type, so that 'with' queries could be made
                         // Both keys for the relation are required (e.g 'id' <-> 'user_id')
-                        $relationsKey = $fieldObject->config['alias'] ?? $key;
+                        $relationsKey = $fieldObject->config['alias'] ?? $field['name'];
                         $relation = call_user_func([app($parentType->config['model']), $relationsKey]);
 
                         self::handleRelation($select, $relation, $parentTable, $field);
 
                         // New parent type, which is the relation
-                        $newParentType = $parentType->getField($key)->config['type'];
+                        $newParentType = $parentType->getField($field['name'])->config['type'];
 
                         self::addAlwaysFields($fieldObject, $field, $parentTable, true);
 
+                        // Check if an graphql alias is being used
+                        // and add the relationship to the model
+                        // so it can be eager loaded.
+                        $isGraphqlAlias = (bool) $field['alias'];
+
+                        if ($isGraphqlAlias) {
+                            $generatedRelationshipName = GenerateRelationshipKey::generate($field['alias']);
+                            $fieldObject->resolveFn = new AliasedRelationshipsResolver;
+
+                            self::collectModelRelationshipsForAlias($parentType->config['model'], GenerateRelationshipKey::generate($field['alias']), $relationsKey);
+                            $relationsKey = $generatedRelationshipName;
+                        }
+
                         $with[$relationsKey] = self::getSelectableFieldsAndRelations(
                             $queryArgs,
                             $field,
@@ -268,6 +291,25 @@ protected static function handleFields(
         }
     }
 
+    /**
+     * @param class-string<Model> $modelName
+     * @param string $graphqlAlias
+     * @param string $relationsKey
+     * @return void
+     */
+    public static function collectModelRelationshipsForAlias(string $modelName, string $graphqlAlias, string $relationsKey): void
+    {
+        self::$modelRelationshipsForAlias[$modelName][] = [$graphqlAlias, $relationsKey];
+    }
+
+    public function createModelRelationshipsForAlias(): void
+    {
+        foreach (self::$modelRelationshipsForAlias as $model => $list) {
+            ModelRelationshipAdder::add($model, $list);
+        }
+        self::$modelRelationshipsForAlias = [];
+    }
+
     private static function isMongodbInstance(GraphqlType $parentType): bool
     {
         $mongoType = 'Jenssegers\Mongodb\Eloquent\Model';

tests/Database/SelectFields/QueryArgsTest/CommentType.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rebing\GraphQL\Tests\Database\SelectFields\QueryArgsTest;
+
+use GraphQL\Type\Definition\Type;
+use Rebing\GraphQL\Support\Type as GraphQLType;
+use Rebing\GraphQL\Tests\Support\Models\Comment;
+
+class CommentType extends GraphQLType
+{
+    /**
+     * @var array<string, mixed>
+     */
+    protected $attributes = [
+        'name' => 'Comment',
+        'model' => Comment::class,
+    ];
+
+    public function fields(): array
+    {
+        return [
+            'id' => [
+                'type' => Type::nonNull(Type::ID()),
+            ],
+            'body' => [
+                'type' => Type::string(),
+            ],
+            'title' => [
+                'type' => Type::nonNull(Type::string()),
+            ],
+        ];
+    }
+}

tests/Database/SelectFields/QueryArgsTest/PostType.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rebing\GraphQL\Tests\Database\SelectFields\QueryArgsTest;
+
+use GraphQL\Type\Definition\Type;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Rebing\GraphQL\Support\Facades\GraphQL;
+use Rebing\GraphQL\Support\Type as GraphQLType;
+use Rebing\GraphQL\Tests\Support\Models\Post;
+
+class PostType extends GraphQLType
+{
+    /**
+     * @var array<string, mixed>
+     */
+    protected $attributes = [
+        'name' => 'Post',
+        'model' => Post::class,
+    ];
+
+    public function fields(): array
+    {
+        return [
+            'body' => [
+                'type' => Type::string(),
+            ],
+            'comments' => [
+                'type' => Type::nonNull(Type::listOf(Type::nonNull(GraphQL::type('Comment')))),
+                'args' => [
+                    'flag' => [
+                        Type::boolean(),
+                    ],
+                ],
+                'query' => function (array $args, HasMany $query, $ctx): HasMany {
+                    if (isset($args['flag'])) {
+                        $query->where('comments.flag', '=', $args['flag']);
+                    }
+
+                    return $query;
+                },
+            ],
+            'id' => [
+                'type' => Type::nonNull(Type::ID()),
+            ],
+            'title' => [
+                'type' => Type::nonNull(Type::string()),
+            ],
+        ];
+    }
+}