Add GraphQL::Query::Partial

Gemfile

@@ -14,7 +14,7 @@ if RUBY_VERSION >= "3.0"
   gem "evt"
 end
 
-if RUBY_VERSION >= "3.1.1"
+if RUBY_VERSION >= "3.2.0"
   gem "async", "~>2.0"
 end
 

lib/graphql/execution/interpreter.rb

@@ -26,7 +26,7 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
             query = case opts
             when Hash
               schema.query_class.new(schema, nil, **opts)
-            when GraphQL::Query
+            when GraphQL::Query, GraphQL::Query::Partial
               opts
             else
               raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"

lib/graphql/execution/interpreter/runtime.rb

@@ -57,53 +57,142 @@ def initialize(query:, lazies_at_depth:)
         end
 
         def final_result
-          @response && @response.graphql_result_data
+          @response.respond_to?(:graphql_result_data) ? @response.graphql_result_data : @response
         end
 
         def inspect
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
-        # This _begins_ the execution. Some deferred work
-        # might be stored up in lazies.
         # @return [void]
         def run_eager
-          root_operation = query.selected_operation
-          root_op_type = root_operation.operation_type || "query"
-          root_type = schema.root_type_for_operation(root_op_type)
-          runtime_object = root_type.wrap(query.root_value, context)
-          runtime_object = schema.sync_lazy(runtime_object)
-          is_eager = root_op_type == "mutation"
-          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, root_operation.selections, is_eager, root_operation, nil, nil)
-          st = get_current_runtime_state
-          st.current_result = @response
-
-          if runtime_object.nil?
-            # Root .authorized? returned false.
-            @response = nil
+          root_type = query.root_type
+          case query
+          when GraphQL::Query
+            ast_node = query.selected_operation
+            selections = ast_node.selections
+            object = query.root_value
+            is_eager = ast_node.operation_type == "mutation"
+            base_path = nil
+          when GraphQL::Query::Partial
+            ast_node = query.ast_nodes.first
+            selections = query.ast_nodes.map(&:selections).inject(&:+)
+            object = query.object
+            is_eager = false
+            base_path = query.path
           else
-            call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
-              each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
-                @response.ordered_result_keys ||= ordered_result_keys
-                if is_selection_array
-                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager, root_operation, nil, nil)
-                  selection_response.ordered_result_keys = ordered_result_keys
-                  final_response = @response
-                else
-                  selection_response = @response
-                  final_response = nil
-                end
+            raise ArgumentError, "Unexpected Runnable, can't execute: #{query.class} (#{query.inspect})"
+          end
+          object = schema.sync_lazy(object) # TODO test query partial with lazy root object
+          runtime_state = get_current_runtime_state
+          case root_type.kind.name
+          when "OBJECT"
+            object_proxy = root_type.wrap(object, context)
+            object_proxy = schema.sync_lazy(object_proxy)
+            if object_proxy.nil?
+              @response = nil
+            else
+              @response = GraphQLResultHash.new(nil, root_type, object_proxy, nil, false, selections, is_eager, ast_node, nil, nil)
+              @response.base_path = base_path
+              runtime_state.current_result = @response
+              call_method_on_directives(:resolve, object, ast_node.directives) do
+                each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
+                  @response.ordered_result_keys ||= ordered_result_keys
+                  if is_selection_array
+                    selection_response = GraphQLResultHash.new(nil, root_type, object_proxy, nil, false, selections, is_eager, ast_node, nil, nil)
+                    selection_response.ordered_result_keys = ordered_result_keys
+                    final_response = @response
+                  else
+                    selection_response = @response
+                    final_response = nil
+                  end
 
-                @dataloader.append_job {
-                  evaluate_selections(
-                    selections,
-                    selection_response,
-                    final_response,
-                    nil,
+                  @dataloader.append_job {
+                    evaluate_selections(
+                      selections,
+                      selection_response,
+                      final_response,
+                      nil,
+                    )
+                  }
+                end
+              end
+            end
+          when "LIST"
+            inner_type = root_type.unwrap
+            case inner_type.kind.name
+            when "SCALAR", "ENUM"
+              result_name = ast_node.alias || ast_node.name
+              owner_type = query.field_definition.owner
+              selection_result = GraphQLResultHash.new(nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+              selection_result.base_path = base_path
+              selection_result.ordered_result_keys = [result_name]
+              runtime_state = get_current_runtime_state
+              runtime_state.current_result = selection_result
+              runtime_state.current_result_name = result_name
+              field_defn = query.field_definition
+              continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
+              if HALT != continue_value
+                continue_field(continue_value, owner_type, field_defn, root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
+              end
+              @response = selection_result[result_name]
+            else
+              @response = GraphQLResultArray.new(nil, root_type, nil, nil, false, selections, false, ast_node, nil, nil)
+              @response.base_path = base_path
+              idx = nil
+              object.each do |inner_value|
+                idx ||= 0
+                this_idx = idx
+                idx += 1
+                @dataloader.append_job do
+                  runtime_state.current_result_name = this_idx
+                  runtime_state.current_result = @response
+                  continue_field(
+                    inner_value, root_type, nil, inner_type, nil, @response.graphql_selections, false, object_proxy,
+                    nil, this_idx, @response, false, runtime_state
                   )
-                }
+                end
+              end
+            end
+          when "SCALAR", "ENUM"
+            result_name = ast_node.alias || ast_node.name
+            owner_type = query.field_definition.owner
+            selection_result = GraphQLResultHash.new(nil, query.parent_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+            selection_result.ordered_result_keys = [result_name]
+            selection_result.base_path = base_path
+            runtime_state = get_current_runtime_state
+            runtime_state.current_result = selection_result
+            runtime_state.current_result_name = result_name
+            field_defn = query.field_definition
+            continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
+            if HALT != continue_value
+              continue_field(continue_value, owner_type, field_defn, query.root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
+            end
+            @response = selection_result[result_name]
+          when "UNION", "INTERFACE"
+            resolved_type, _resolved_obj = resolve_type(root_type, object)
+            resolved_type = schema.sync_lazy(resolved_type)
+            object_proxy = resolved_type.wrap(object, context)
+            object_proxy = schema.sync_lazy(object_proxy)
+            @response = GraphQLResultHash.new(nil, resolved_type, object_proxy, nil, false, selections, false, query.ast_nodes.first, nil, nil)
+            @response.base_path = base_path
+            each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
+              @response.ordered_result_keys ||= ordered_result_keys
+              if is_selection_array == true
+                raise "This isn't supported yet"
               end
+
+              @dataloader.append_job {
+                evaluate_selections(
+                  selections,
+                  @response,
+                  nil,
+                  runtime_state,
+                )
+              }
             end
+          else
+            raise "Invariant: unsupported type kind for partial execution: #{root_type.kind.inspect} (#{root_type})"
           end
           nil
         end

lib/graphql/execution/interpreter/runtime/graphql_result.rb

@@ -21,15 +21,25 @@ def initialize(result_name, result_type, application_value, parent_result, is_no
             @graphql_metadata = nil
             @graphql_selections = selections
             @graphql_is_eager = is_eager
+            @base_path = nil
           end
 
+          # TODO test full path in Partial
+          attr_writer :base_path
+
           def path
             @path ||= build_path([])
           end
 
           def build_path(path_array)
             graphql_result_name && path_array.unshift(graphql_result_name)
-            @graphql_parent ? @graphql_parent.build_path(path_array) : path_array
+            if @graphql_parent
+              @graphql_parent.build_path(path_array)
+            elsif @base_path
+              @base_path + path_array
+            else
+              path_array
+            end
           end
 
           attr_accessor :graphql_dead

lib/graphql/query.rb

@@ -10,12 +10,47 @@ class Query
     autoload :Context, "graphql/query/context"
     autoload :Fingerprint, "graphql/query/fingerprint"
     autoload :NullContext, "graphql/query/null_context"
+    autoload :Partial, "graphql/query/partial"
     autoload :Result, "graphql/query/result"
     autoload :Variables, "graphql/query/variables"
     autoload :InputValidationResult, "graphql/query/input_validation_result"
     autoload :VariableValidationError, "graphql/query/variable_validation_error"
     autoload :ValidationPipeline, "graphql/query/validation_pipeline"
 
+    # Code shared with {Partial}
+    module Runnable
+      def after_lazy(value, &block)
+        if !defined?(@runtime_instance)
+          @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
+        end
+
+        if @runtime_instance
+          @runtime_instance.minimal_after_lazy(value, &block)
+        else
+          @schema.after_lazy(value, &block)
+        end
+      end
+
+      # Node-level cache for calculating arguments. Used during execution and query analysis.
+      # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
+      # @param definition [GraphQL::Schema::Field]
+      # @param parent_object [GraphQL::Schema::Object]
+      # @return [Hash{Symbol => Object}]
+      def arguments_for(ast_node, definition, parent_object: nil)
+        arguments_cache.fetch(ast_node, definition, parent_object)
+      end
+
+      def arguments_cache
+        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
+      end
+
+      # @api private
+      def handle_or_reraise(err)
+        @schema.handle_or_reraise(context, err)
+      end
+    end
+
+    include Runnable
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)
         msg = if name.nil?
@@ -198,19 +233,10 @@ def subscription_update?
     # @return [GraphQL::Execution::Lookahead]
     def lookahead
       @lookahead ||= begin
-        ast_node = selected_operation
-        if ast_node.nil?
+        if selected_operation.nil?
           GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
         else
-          root_type = case ast_node.operation_type
-          when nil, "query"
-            types.query_root # rubocop:disable Development/ContextIsPassedCop
-          when "mutation"
-            types.mutation_root # rubocop:disable Development/ContextIsPassedCop
-          when "subscription"
-            types.subscription_root # rubocop:disable Development/ContextIsPassedCop
-          end
-          GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
+          GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [selected_operation])
         end
       end
     end
@@ -236,6 +262,18 @@ def operations
       with_prepared_ast { @operations }
     end
 
+    # Run subtree partials of this query and return their results.
+    # Each partial is identified with a `path:` and `object:`
+    # where the path references a field in the AST and the object will be treated
+    # as the return value from that field. Subfields of the field named by `path`
+    # will be executed with `object` as the starting point
+    # @param partials_hashes [Array<Hash{Symbol => Object}>] Hashes with `path:` and `object:` keys
+    # @return [Array<GraphQL::Query::Result>]
+    def run_partials(partials_hashes)
+      partials = partials_hashes.map { |partial_options| Partial.new(query: self, **partial_options) }
+      Execution::Interpreter.run_all(@schema, partials, context: @context)
+    end
+
     # Get the result for this query, executing it once
     # @return [GraphQL::Query::Result] A Hash-like GraphQL response, with `"data"` and/or `"errors"` keys
     def result
@@ -278,19 +316,6 @@ def variables
       end
     end
 
-    # Node-level cache for calculating arguments. Used during execution and query analysis.
-    # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
-    # @param definition [GraphQL::Schema::Field]
-    # @param parent_object [GraphQL::Schema::Object]
-    # @return [Hash{Symbol => Object}]
-    def arguments_for(ast_node, definition, parent_object: nil)
-      arguments_cache.fetch(ast_node, definition, parent_object)
-    end
-
-    def arguments_cache
-      @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
-    end
-
     # A version of the given query string, with:
     # - Variables inlined to the query
     # - Strings replaced with `<REDACTED>`
@@ -357,17 +382,21 @@ def possible_types(type)
 
     def root_type_for_operation(op_type)
       case op_type
-      when "query"
+      when "query", nil
         types.query_root # rubocop:disable Development/ContextIsPassedCop
       when "mutation"
         types.mutation_root # rubocop:disable Development/ContextIsPassedCop
       when "subscription"
         types.subscription_root # rubocop:disable Development/ContextIsPassedCop
       else
-        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected 'query', 'mutation', or 'subscription'"
+        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected nil, 'query', 'mutation', or 'subscription'"
       end
     end
 
+    def root_type
+      root_type_for_operation(selected_operation.operation_type)
+    end
+
     def types
       @visibility_profile || warden.visibility_profile
     end
@@ -400,23 +429,6 @@ def subscription?
       with_prepared_ast { @subscription }
     end
 
-    # @api private
-    def handle_or_reraise(err)
-      schema.handle_or_reraise(context, err)
-    end
-
-    def after_lazy(value, &block)
-      if !defined?(@runtime_instance)
-        @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
-      end
-
-      if @runtime_instance
-        @runtime_instance.minimal_after_lazy(value, &block)
-      else
-        @schema.after_lazy(value, &block)
-      end
-    end
-
     attr_reader :logger
 
     private