Support optimized select for top-level query

src/Pagination/PaginateDirective.php

@@ -9,10 +9,12 @@
 use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Database\Query\Builder as QueryBuilder;
+use Illuminate\Support\Arr;
 use Laravel\Scout\Builder as ScoutBuilder;
 use Nuwave\Lighthouse\Schema\AST\DocumentAST;
 use Nuwave\Lighthouse\Schema\Directives\BaseDirective;
 use Nuwave\Lighthouse\Schema\Values\FieldValue;
+use Nuwave\Lighthouse\Select\SelectHelper;
 use Nuwave\Lighthouse\Support\Contracts\FieldManipulator;
 use Nuwave\Lighthouse\Support\Contracts\FieldResolver;
 use Nuwave\Lighthouse\Support\Contracts\GraphQLContext;
@@ -129,6 +131,31 @@ public function resolveField(FieldValue $fieldValue): FieldValue
                     $this->directiveArgValue('scopes', [])
                 );
 
+            if (config('lighthouse.optimized_selects')) {
+                if ($query instanceof EloquentBuilder) {
+                    $fieldSelection = $resolveInfo->getFieldSelection(2);
+
+                    if (($hasData = Arr::has($fieldSelection, 'data')) || Arr::has($fieldSelection, 'edges')) {
+                        $data = $hasData
+                            ? $fieldSelection['data']
+                            : $fieldSelection['edges']['node'];
+
+                        /** @var array<int, string> $fieldSelection */
+                        $fieldSelection = array_keys($data);
+
+                        $selectColumns = SelectHelper::getSelectColumns(
+                            $this->definitionNode,
+                            $fieldSelection,
+                            get_class($query->getModel())
+                        );
+
+                        if (! empty($selectColumns)) {
+                            $query = $query->select($selectColumns);
+                        }
+                    }
+                }
+            }
+
             $paginationArgs = PaginationArgs::extractArgs($args, $this->paginationType(), $this->paginateMaxCount());
 
             $paginationArgs->type = $this->optimalPaginationType($resolveInfo);

src/Schema/Directives/AllDirective.php

@@ -6,9 +6,11 @@
 use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Database\Query\Builder as QueryBuilder;
+use Illuminate\Database\Query\Expression;
 use Illuminate\Support\Collection;
 use Laravel\Scout\Builder as ScoutBuilder;
 use Nuwave\Lighthouse\Schema\Values\FieldValue;
+use Nuwave\Lighthouse\Select\SelectHelper;
 use Nuwave\Lighthouse\Support\Contracts\FieldResolver;
 use Nuwave\Lighthouse\Support\Contracts\GraphQLContext;
 
@@ -56,13 +58,48 @@ public function resolveField(FieldValue $fieldValue): FieldValue
                 $query = $this->getModelClass()::query();
             }
 
-            return $resolveInfo
+            $builder = $resolveInfo
                 ->argumentSet
                 ->enhanceBuilder(
                     $query,
                     $this->directiveArgValue('scopes', [])
-                )
-                ->get();
+                );
+
+            if (config('lighthouse.optimized_selects')) {
+                if ($builder instanceof EloquentBuilder) {
+                    $fieldSelection = array_keys($resolveInfo->getFieldSelection(1));
+
+                    $selectColumns = SelectHelper::getSelectColumns(
+                        $this->definitionNode,
+                        $fieldSelection,
+                        get_class($builder->getModel())
+                    );
+
+                    if (empty($selectColumns)) {
+                        return $builder->get();
+                    }
+
+                    $query = $builder->getQuery();
+
+                    if (null !== $query->columns) {
+                        $bindings = $query->getRawBindings();
+
+                        $expressions = array_filter($query->columns, function ($column) {
+                            return $column instanceof Expression;
+                        });
+
+                        $builder = $builder->select(array_unique(array_merge($selectColumns, $expressions)));
+
+                        foreach ($bindings as $type => $binding) {
+                            $builder = $builder->addBinding($binding, $type);
+                        }
+                    } else {
+                        $builder = $builder->select($selectColumns);
+                    }
+                }
+            }
+
+            return $builder->get();
         });
 
         return $fieldValue;

src/Schema/Directives/FindDirective.php

@@ -6,6 +6,7 @@
 use GraphQL\Type\Definition\ResolveInfo;
 use Illuminate\Database\Eloquent\Model;
 use Nuwave\Lighthouse\Schema\Values\FieldValue;
+use Nuwave\Lighthouse\Select\SelectHelper;
 use Nuwave\Lighthouse\Support\Contracts\FieldResolver;
 use Nuwave\Lighthouse\Support\Contracts\GraphQLContext;
 
@@ -35,13 +36,28 @@ public static function definition(): string
     public function resolveField(FieldValue $fieldValue): FieldValue
     {
         $fieldValue->setResolver(function ($root, array $args, GraphQLContext $context, ResolveInfo $resolveInfo): ?Model {
-            $results = $resolveInfo
+            $builder = $resolveInfo
                 ->argumentSet
                 ->enhanceBuilder(
                     $this->getModelClass()::query(),
                     $this->directiveArgValue('scopes', [])
-                )
-                ->get();
+                );
+
+            if (config('lighthouse.optimized_selects')) {
+                $fieldSelection = array_keys($resolveInfo->getFieldSelection(1));
+
+                $selectColumns = SelectHelper::getSelectColumns(
+                    $this->definitionNode,
+                    $fieldSelection,
+                    $this->getModelClass()
+                );
+
+                if (! empty($selectColumns)) {
+                    $builder = $builder->select($selectColumns);
+                }
+            }
+
+            $results = $builder->get();
 
             if ($results->count() > 1) {
                 throw new Error('The query returned more than one result.');

src/Schema/Directives/SelectDirective.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Nuwave\Lighthouse\Schema\Directives;
+
+class SelectDirective extends BaseDirective
+{
+    public static function definition(): string
+    {
+        return /** @lang GraphQL */ <<<'GRAPHQL'
+"""
+Specify the SQL column dependencies of this field.
+"""
+directive @select(
+  """
+  SQL column names to include in the `SELECT` part of the query.
+  """
+  columns: [String!]!
+) on FIELD_DEFINITION
+GRAPHQL;
+    }
+}

src/Select/SelectHelper.php

@@ -0,0 +1,141 @@
+<?php
+
+namespace Nuwave\Lighthouse\Select;
+
+use GraphQL\Language\AST\DirectiveNode;
+use GraphQL\Language\AST\Node;
+use GraphQL\Language\AST\NodeList;
+use Illuminate\Container\Container;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Str;
+use Nuwave\Lighthouse\Schema\AST\ASTBuilder;
+use Nuwave\Lighthouse\Schema\AST\ASTHelper;
+use Nuwave\Lighthouse\Schema\AST\DocumentAST;
+use Nuwave\Lighthouse\Support\AppVersion;
+use Nuwave\Lighthouse\Support\Utils;
+
+class SelectHelper
+{
+    public const DIRECTIVES_REQUIRING_LOCAL_KEY = ['hasOne', 'hasMany', 'count', 'morphOne', 'morphMany'];
+
+    public const DIRECTIVES_REQUIRING_FOREIGN_KEY = ['belongsTo'];
+
+    public const DIRECTIVES_RETURN = ['morphTo', 'morphToMany'];
+
+    public const DIRECTIVES = [
+        'aggregate',
+        'belongsTo',
+        'belongsToMany',
+        'count',
+        'hasOne',
+        'hasMany',
+        'morphOne',
+        'morphMany',
+        'morphTo',
+        'morphToMany',
+        'withCount',
+    ];
+
+    /**
+     * Given a field definition node, resolve info, and a model name, return the SQL columns that should be selected.
+     * Accounts for relationships and to rename and select directives.
+     *
+     * @param array<int, string> $fieldSelection
+     *
+     * @return array<int, string>
+     *
+     * @reference https://github.com/nuwave/lighthouse/pull/1626
+     */
+    public static function getSelectColumns(Node $definitionNode, array $fieldSelection, string $modelName): array
+    {
+        $returnTypeName = ASTHelper::getUnderlyingTypeName($definitionNode);
+
+        $astBuilder = Container::getInstance()->make(ASTBuilder::class);
+
+        assert($astBuilder instanceof ASTBuilder);
+
+        $documentAST = $astBuilder->documentAST();
+
+        assert($documentAST instanceof DocumentAST);
+
+        if (Str::contains($returnTypeName, ['SimplePaginator', 'Paginator'])) {
+            $returnTypeName = str_replace(['SimplePaginator', 'Paginator'], '', $returnTypeName);
+        }
+
+        $type = $documentAST->types[$returnTypeName];
+
+        $fieldDefinitions = $type->fields;
+
+        assert($fieldDefinitions instanceof NodeList);
+
+        $model = new $modelName();
+
+        assert($model instanceof Model);
+
+        $selectColumns = [];
+
+        foreach ($fieldSelection as $field) {
+            $fieldDefinition = ASTHelper::firstByName($fieldDefinitions, $field);
+
+            if ($fieldDefinition) {
+                foreach (self::DIRECTIVES as $directiveType) {
+                    if ($directive = ASTHelper::directiveDefinition($fieldDefinition, $directiveType)) {
+                        assert($directive instanceof DirectiveNode);
+
+                        if (in_array($directiveType, self::DIRECTIVES_RETURN)) {
+                            return [];
+                        }
+
+                        if (in_array($directiveType, self::DIRECTIVES_REQUIRING_LOCAL_KEY)) {
+                            $relationName = ASTHelper::directiveArgValue($directive, 'relation', $field);
+
+                            if (method_exists($model, $relationName)) {
+                                $relation = $model->{$relationName}();
+
+                                $localKey = AppVersion::below(5.7)
+                                    ? Utils::accessProtected($relation, 'localKey')
+                                    : $relation->getLocalKeyName();
+
+                                $selectColumns[] = $localKey;
+                            }
+                        }
+
+                        if (in_array($directiveType, self::DIRECTIVES_REQUIRING_FOREIGN_KEY)) {
+                            $relationName = ASTHelper::directiveArgValue($directive, 'relation', $field);
+
+                            if (method_exists($model, $relationName)) {
+                                $foreignKey = AppVersion::below(5.8)
+                                    ? $model->{$relationName}()->getForeignKey()
+                                    : $model->{$relationName}()->getForeignKeyName();
+
+                                $selectColumns[] = $foreignKey;
+                            }
+                        }
+
+                        continue 2;
+                    }
+                }
+
+                if ($directive = ASTHelper::directiveDefinition($fieldDefinition, 'select')) {
+                    // append selected columns in select directive to selection
+                    $selectFields = ASTHelper::directiveArgValue($directive, 'columns', []);
+                    $selectColumns = array_merge($selectColumns, $selectFields);
+                } elseif ($directive = ASTHelper::directiveDefinition($fieldDefinition, 'rename')) {
+                    // append renamed attribute to selection
+                    $renamedAttribute = ASTHelper::directiveArgValue($directive, 'attribute');
+                    $selectColumns[] = $renamedAttribute;
+                } else {
+                    // fallback to selecting the field name
+                    $selectColumns[] = $field;
+                }
+            }
+        }
+
+        /** @var array<int, string> $selectColumns */
+        $selectColumns = array_filter($selectColumns, function ($column) use ($model): bool {
+            return ! $model->hasGetMutator($column) && ! method_exists($model, $column);
+        });
+
+        return array_unique($selectColumns);
+    }
+}

src/lighthouse.php

@@ -355,6 +355,18 @@
 
     'batchload_relations' => true,
 
+    /*
+    |--------------------------------------------------------------------------
+    | Optimized Selects
+    |--------------------------------------------------------------------------
+    |
+    | If set to true, Eloquent will only select the columns necessary to resolve a query.
+    | Use the @select directive to specify column dependencies of compound fields.
+    |
+    */
+
+    'optimized_selects' => true,
+
     /*
     |--------------------------------------------------------------------------
     | Shortcut Foreign Key Selection

tests/Integration/Pagination/PaginateDirectiveDBTest.php

@@ -265,6 +265,45 @@ public function testPaginateWithScopes(): void
         ]);
     }
 
+    public function testPaginateOptimizedSelect(): void
+    {
+        factory(User::class, 2)->create();
+
+        $this->schema = /** @lang GraphQL */ '
+        type User {
+            id: ID!
+        }
+
+        type Query {
+            users: [User!]! @paginate
+        }
+        ';
+
+        self::trackQueries();
+
+        $this->graphQL(/** @lang GraphQL */ '
+        {
+            users(first: 1) {
+                paginatorInfo {
+                    count
+                    total
+                    currentPage
+                }
+                data {
+                    id
+                }
+            }
+        }
+        ')->assertJsonCount(1, 'data.users.data');
+
+        $queries = self::getQueriesExecuted();
+
+        $this->assertStringContainsString(
+            'select `id` from `users`',
+            $queries[1]['query']
+        );
+    }
+
     public function builder(): EloquentBuilder
     {
         return User::orderBy('id', 'DESC');