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,26 @@ public function resolveField(FieldValue $fieldValue): FieldValue
                     $this->directiveArgValue('scopes', [])
                 );
 
+            if (config('lighthouse.optimized_selects')) {
+                if (($query instanceof QueryBuilder || $query instanceof EloquentBuilder) && ! $this->directiveHasArgument('builder')) {
+                    $fieldSelection = $resolveInfo->getFieldSelection(4);
+
+                    if (Arr::has($fieldSelection, 'data') || Arr::has($fieldSelection, 'edges')) {
+                        $fieldSelection = array_keys(Arr::has($fieldSelection, 'data') ? $fieldSelection['data'] : $fieldSelection['edges']['node']);
+
+                        $selectColumns = SelectHelper::getSelectColumns(
+                            $this->definitionNode,
+                            $fieldSelection,
+                            $this->getModelClass()
+                        );
+
+                        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 QueryBuilder || $builder instanceof EloquentBuilder) && ! $this->directiveHasArgument('builder')) {
+                    $fieldSelection = array_keys($resolveInfo->getFieldSelection(1));
+
+                    $selectColumns = SelectHelper::getSelectColumns(
+                        $this->definitionNode,
+                        $fieldSelection,
+                        $this->getModelClass()
+                    );
+
+                    if (empty($selectColumns)) {
+                        return $builder->get();
+                    }
+
+                    $query = $builder instanceof EloquentBuilder ? $builder->getQuery() : $builder;
+
+                    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 columns names to pass to the Eloquent query builder
+  """
+  columns: [String!]
+) on FIELD_DEFINITION
+GRAPHQL;
+    }
+}

src/Select/SelectHelper.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace Nuwave\Lighthouse\Select;
+
+use GraphQL\Language\AST\DirectiveNode;
+use GraphQL\Language\AST\FieldDefinitionNode;
+use GraphQL\Language\AST\Node;
+use GraphQL\Language\AST\UnionTypeDefinitionNode;
+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;
+
+class SelectHelper
+{
+    public const DirectivesRequiringLocalKey = ['hasOne', 'hasMany', 'count', 'morphOne', 'morphMany'];
+
+    public const DirectivesRequiringForeignKey = ['belongsTo'];
+
+    public const DirectivesReturn = ['morphTo', 'morphToMany'];
+
+    public const DirectivesIgnore = ['aggregate', 'withCount', 'belongsToMany'];
+
+    /**
+     * 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 mixed[] $fieldSelection
+     *
+     * @return string[]
+     *
+     * @reference https://github.com/nuwave/lighthouse/pull/1626
+     */
+    public static function getSelectColumns(Node $definitionNode, array $fieldSelection, string $modelName): array
+    {
+        $returnTypeName = ASTHelper::getUnderlyingTypeName($definitionNode);
+
+        /** @var DocumentAST $documentAST */
+        $documentAST = app(ASTBuilder::class)->documentAST();
+
+        if (Str::contains($returnTypeName, ['SimplePaginator', 'Paginator'])) {
+            $returnTypeName = str_replace(['SimplePaginator', 'Paginator'], '', $returnTypeName);
+        }
+
+        $type = $documentAST->types[$returnTypeName];
+
+        if ($type instanceof UnionTypeDefinitionNode) {
+            $type = $documentAST->types[ASTHelper::getUnderlyingTypeName($type->types[0])];
+        }
+
+        /** @var iterable<FieldDefinitionNode> $fieldDefinitions */
+        $fieldDefinitions = $type->fields;
+
+        /** @var Model $model */
+        $model = new $modelName();
+
+        $selectColumns = [];
+
+        foreach ($fieldSelection as $field) {
+            $fieldDefinition = ASTHelper::firstByName($fieldDefinitions, $field);
+
+            if ($fieldDefinition) {
+                $directivesRequiringKeys = array_merge(self::DirectivesRequiringLocalKey, self::DirectivesRequiringForeignKey, self::DirectivesReturn, self::DirectivesIgnore);
+
+                foreach ($directivesRequiringKeys as $directiveType) {
+                    if (ASTHelper::hasDirective($fieldDefinition, $directiveType)) {
+                        /** @var DirectiveNode $directive */
+                        $directive = ASTHelper::directiveDefinition($fieldDefinition, $directiveType);
+
+                        if (in_array($directiveType, self::DirectivesReturn)) {
+                            return [];
+                        }
+
+                        if (in_array($directiveType, self::DirectivesRequiringLocalKey)) {
+                            $relationName = ASTHelper::directiveArgValue($directive, 'relation', $field);
+
+                            if (method_exists($model, $relationName)) {
+                                if (AppVersion::below(5.7)) {
+                                    $relation = $model->{$relationName}();
+                                    $rc = new \ReflectionClass($model->{$relationName}());
+                                    $localKey = $rc->getProperty('localKey');
+                                    $localKey->setAccessible(true);
+                                    array_push($selectColumns, $localKey->getValue($relation));
+                                } else {
+                                    array_push($selectColumns, $model->{$relationName}()->getLocalKeyName());
+                                }
+                            }
+                        }
+
+                        if (in_array($directiveType, self::DirectivesRequiringForeignKey)) {
+                            $relationName = ASTHelper::directiveArgValue($directive, 'relation', $field);
+
+                            if (method_exists($model, $relationName)) {
+                                if (AppVersion::below(5.8)) {
+                                    array_push($selectColumns, $model->{$relationName}()->getForeignKey());
+                                } else {
+                                    array_push($selectColumns, $model->{$relationName}()->getForeignKeyName());
+                                }
+                            }
+                        }
+
+                        continue 2;
+                    }
+                }
+
+                if (ASTHelper::hasDirective($fieldDefinition, 'select')) {
+                    // append selected columns in select directive to seletion
+                    $directive = ASTHelper::directiveDefinition($fieldDefinition, 'select');
+
+                    if ($directive) {
+                        $selectFields = ASTHelper::directiveArgValue($directive, 'columns') ?? [];
+                        $selectColumns = array_merge($selectColumns, $selectFields);
+                    }
+                } elseif (ASTHelper::hasDirective($fieldDefinition, 'rename')) {
+                    // append renamed attribute to selection
+                    $directive = ASTHelper::directiveDefinition($fieldDefinition, 'rename');
+
+                    if ($directive) {
+                        $renamedAttribute = ASTHelper::directiveArgValue($directive, 'attribute');
+                        array_push($selectColumns, $renamedAttribute);
+                    }
+                } else {
+                    // fallback to selecting the field name
+                    array_push($selectColumns, $field);
+                }
+            }
+        }
+
+        $selectColumns = array_filter($selectColumns, function ($column) use ($model) {
+            return ! $model->hasGetMutator($column) && ! method_exists($model, $column);
+        });
+
+        return array_unique($selectColumns);
+    }
+}

src/lighthouse.php

@@ -355,6 +355,19 @@
 
     'batchload_relations' => true,
 
+    /*
+    |--------------------------------------------------------------------------
+    | Optimized Selects
+    |--------------------------------------------------------------------------
+    |
+    | If set to true, Eloquent will only select the columns necessary to resolve
+    | a query. You must use the select directive to resolve advanced field dependencies
+    | on other columns.
+    |
+    */
+
+    'optimized_selects' => true,
+
     /*
     |--------------------------------------------------------------------------
     | Shortcut Foreign Key Selection

tests/AssertsQueryCounts.php

@@ -15,7 +15,7 @@ trait AssertsQueryCounts
 {
     protected function countQueries(?int &$count): void
     {
-        DB::listen(function () use (&$count): void {
+        DB::listen(function ($query) use (&$count): void {
             ++$count;
         });
     }

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');