graphql 2.5.9 → 2.5.26

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

@@ -35,11 +35,10 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        def initialize(query:, lazies_at_depth:)
+        def initialize(query:)
           @query = query
           @current_trace = query.current_trace
           @dataloader = query.multiplex.dataloader
-          @lazies_at_depth = lazies_at_depth
           @schema = query.schema
           @context = query.context
           @response = nil
@@ -298,8 +297,6 @@ module GraphQL
           end
 
           call_method_on_directives(:resolve, selections_result.graphql_application_value, directives) do
-            finished_jobs = 0
-            enqueued_jobs = gathered_selections.size
             gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
               # Field resolution may pause the fiber,
               # so it wouldn't get to the `Resolve` call that happens below.
@@ -310,12 +307,6 @@ module GraphQL
                   evaluate_selection(
                     result_name, field_ast_nodes_or_ast_node, selections_result
                   )
-                  finished_jobs += 1
-                  if finished_jobs == enqueued_jobs
-                    if target_result
-                      selections_result.merge_into(target_result)
-                    end
-                  end
                   @dataloader.clear_cache
                 }
               else
@@ -323,15 +314,12 @@ module GraphQL
                   evaluate_selection(
                     result_name, field_ast_nodes_or_ast_node, selections_result
                   )
-                  finished_jobs += 1
-                  if finished_jobs == enqueued_jobs
-                    if target_result
-                      selections_result.merge_into(target_result)
-                    end
-                  end
                 }
               end
             end
+            if target_result
+              selections_result.merge_into(target_result)
+            end
             selections_result
           end
         end
@@ -376,6 +364,10 @@ module GraphQL
           else
             @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
               runtime_state = get_current_runtime_state # This might be in a different fiber
+              runtime_state.current_field = field_defn
+              runtime_state.current_arguments = resolved_arguments
+              runtime_state.current_result_name = result_name
+              runtime_state.current_result = selections_result
               evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state)
             end
           end
@@ -384,6 +376,8 @@ module GraphQL
         def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
+              next if selection_result.collect_result(result_name, resolved_arguments)
+
               return_type_non_null = field_defn.type.non_null?
               continue_value(resolved_arguments, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
@@ -457,7 +451,7 @@ module GraphQL
             }
           end
 
-          field_result = call_method_on_directives(:resolve, object, directives) do
+          call_method_on_directives(:resolve, object, directives) do
             if !directives.empty?
               # This might be executed in a different context; reset this info
               runtime_state = get_current_runtime_state
@@ -483,6 +477,8 @@ module GraphQL
             end
             @current_trace.end_execute_field(field_defn, object, kwarg_arguments, query, app_result)
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
+              next if selection_result.collect_result(result_name, inner_result)
+
               owner_type = selection_result.graphql_result_type
               return_type = field_defn.type
               continue_value = continue_value(inner_result, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
@@ -499,7 +495,7 @@ module GraphQL
           # all of its child fields before moving on to the next root mutation field.
           # (Subselections of this mutation will still be resolved level-by-level.)
           if selection_result.graphql_is_eager
-            Interpreter::Resolve.resolve_all([field_result], @dataloader)
+            @dataloader.run
           end
         end
 
@@ -557,7 +553,7 @@ module GraphQL
           path
         end
 
-        HALT = Object.new
+        HALT = Object.new.freeze
         def continue_value(value, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
           case value
           when nil
@@ -607,7 +603,7 @@ module GraphQL
                 err
               end
               continue_value(next_value, field, is_non_null, ast_node, result_name, selection_result)
-            elsif GraphQL::Execution::SKIP == value
+            elsif value.is_a?(GraphQL::Execution::Skip)
               # It's possible a lazy was already written here
               case selection_result
               when GraphQLResultHash
@@ -678,7 +674,11 @@ module GraphQL
             rescue GraphQL::ExecutionError => ex_err
               return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
             rescue StandardError => err
-              query.handle_or_reraise(err)
+              begin
+                query.handle_or_reraise(err)
+              rescue GraphQL::ExecutionError => ex_err
+                return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
+              end
             end
             set_result(selection_result, result_name, r, false, is_non_null)
             r
@@ -761,7 +761,7 @@ module GraphQL
                   idx += 1
                   if use_dataloader_job
                     @dataloader.append_job do
-                      resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
+                      resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, nil)
                     end
                   else
                     resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
@@ -803,6 +803,7 @@ module GraphQL
         end
 
         def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
+          runtime_state ||= get_current_runtime_state
           runtime_state.current_result_name = this_idx
           runtime_state.current_result = response_list
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
@@ -890,7 +891,6 @@ module GraphQL
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
         def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, runtime_state:, trace: true, &block)
           if lazy?(lazy_obj)
-            orig_result = result
             was_authorized_by_scope_items = runtime_state.was_authorized_by_scope_items
             lazy = GraphQL::Execution::Lazy.new(field: field) do
               # This block might be called in a new fiber;
@@ -900,13 +900,13 @@ module GraphQL
               runtime_state.current_field = field
               runtime_state.current_arguments = arguments
               runtime_state.current_result_name = result_name
-              runtime_state.current_result = orig_result
+              runtime_state.current_result = result
               runtime_state.was_authorized_by_scope_items = was_authorized_by_scope_items
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
-              result = nil
+              sync_result = nil
               inner_obj = begin
-                result = if trace
+                sync_result = if trace
                   @current_trace.begin_execute_field(field, owner_object, arguments, query)
                   @current_trace.execute_field_lazy(field: field, query: query, object: owner_object, arguments: arguments, ast_node: ast_node) do
                     schema.sync_lazy(lazy_obj)
@@ -924,7 +924,7 @@ module GraphQL
                 end
               ensure
                 if trace
-                  @current_trace.end_execute_field(field, owner_object, arguments, query, result)
+                  @current_trace.end_execute_field(field, owner_object, arguments, query, sync_result)
                 end
               end
               yield(inner_obj, runtime_state)
@@ -934,12 +934,7 @@ module GraphQL
               lazy.value
             else
               set_result(result, result_name, lazy, false, false) # is_non_null is irrelevant here
-              current_depth = 0
-              while result
-                current_depth += 1
-                result = result.graphql_parent
-              end
-              @lazies_at_depth[current_depth] << lazy
+              @dataloader.lazy_at_depth(result.depth, lazy)
               lazy
             end
           else

data/lib/graphql/execution/interpreter.rb

@@ -42,7 +42,6 @@ module GraphQL
           trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
-            lazies_at_depth = Hash.new { |h, k| h[k] = [] }
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
               multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
@@ -59,11 +58,6 @@ module GraphQL
               # Do as much eager evaluation of the query as possible
               results = []
               queries.each_with_index do |query, idx|
-                if query.subscription? && !query.subscription_update?
-                  subs_namespace = query.context.namespace(:subscriptions)
-                  subs_namespace[:events] = []
-                  subs_namespace[:subscriptions] = {}
-                end
                 multiplex.dataloader.append_job {
                   operation = query.selected_operation
                   result = if operation.nil? || !query.valid? || !query.context.errors.empty?
@@ -73,38 +67,27 @@ module GraphQL
                       # Although queries in a multiplex _share_ an Interpreter instance,
                       # they also have another item of state, which is private to that query
                       # in particular, assign it here:
-                      runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
+                      runtime = Runtime.new(query: query)
                       query.context.namespace(:interpreter_runtime)[:runtime] = runtime
-
+                      if query.subscription? && !query.subscription_update?
+                        schema.subscriptions.initialize_subscriptions(query)
+                      end
                       query.current_trace.execute_query(query: query) do
                         runtime.run_eager
                       end
                     rescue GraphQL::ExecutionError => err
                       query.context.errors << err
-                      NO_OPERATION
                     end
                   end
                   results[idx] = result
                 }
               end
 
-              multiplex.dataloader.run
-
-              # Then, work through lazy results in a breadth-first way
-              multiplex.dataloader.append_job {
-                query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
-                multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
-                  Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
-                end
-              }
-              multiplex.dataloader.run
+              multiplex.dataloader.run(trace_query_lazy: multiplex)
 
               # Then, find all errors and assign the result to the query object
               results.each_with_index do |data_result, idx|
                 query = queries[idx]
-                if (events = query.context.namespace(:subscriptions)[:events]) && !events.empty?
-                  schema.subscriptions.write_subscription(query, events)
-                end
                 # Assign the result so that it can be accessed in instrumentation
                 query.result_values = if data_result.equal?(NO_OPERATION)
                   if !query.valid? || !query.context.errors.empty?
@@ -114,6 +97,9 @@ module GraphQL
                     data_result
                   end
                 else
+                  if query.subscription?
+                    schema.subscriptions.finish_subscriptions(query)
+                  end
                   result = {}
 
                   if !query.context.errors.empty?

data/lib/graphql/execution/lazy.rb

@@ -38,7 +38,7 @@ module GraphQL
         # (fewer clauses in a hot `case` block), but now it requires special handling here.
         # I think it's still worth it for the performance win, but if the number of special
         # cases grows, then maybe it's worth rethinking somehow.
-        if @value.is_a?(StandardError) && @value != GraphQL::Execution::SKIP
+        if @value.is_a?(StandardError) && !@value.is_a?(GraphQL::Execution::Skip)
           raise @value
         else
           @value

data/lib/graphql/execution/load_argument_step.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class LoadArgumentStep
+      def initialize(field_resolve_step:, arguments:, load_receiver:, argument_value:, argument_definition:, argument_key:)
+        @field_resolve_step = field_resolve_step
+        @load_receiver = load_receiver
+        @arguments = arguments
+        @argument_value = argument_value
+        @argument_definition = argument_definition
+        @argument_key = argument_key
+        @loaded_value = nil
+      end
+
+      def value
+        @loaded_value = @field_resolve_step.sync(@loaded_value)
+        assign_value
+      end
+
+      def call
+        context = @field_resolve_step.selections_step.query.context
+        @loaded_value = begin
+          @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
+        rescue GraphQL::UnauthorizedError => auth_err
+          context.schema.unauthorized_object(auth_err)
+        end
+        if (runner = @field_resolve_step.runner).resolves_lazies && runner.lazy?(@loaded_value)
+          runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
+        else
+          assign_value
+        end
+      rescue GraphQL::RuntimeError => err
+        @loaded_value = err
+        assign_value
+      rescue StandardError => stderr
+        @loaded_value = begin
+          context.query.handle_or_reraise(stderr)
+        rescue GraphQL::ExecutionError => ex_err
+          ex_err
+        end
+        assign_value
+      end
+
+      private
+
+      def assign_value
+        if @loaded_value.is_a?(GraphQL::RuntimeError)
+          @loaded_value.path = @field_resolve_step.path
+          @field_resolve_step.arguments = @loaded_value
+        else
+          query = @field_resolve_step.selections_step.query
+          query.current_trace.object_loaded(@argument_definition, @loaded_value, query.context)
+          @arguments[@argument_key] = @loaded_value
+        end
+
+        field_pending_steps = @field_resolve_step.pending_steps
+        field_pending_steps.delete(self)
+        if @field_resolve_step.arguments && field_pending_steps.size == 0 # rubocop:disable Development/ContextIsPassedCop
+          @field_resolve_step.runner.add_step(@field_resolve_step)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/multiplex.rb

@@ -33,7 +33,7 @@ module GraphQL
         @queries.each { |q| q.multiplex = self }
         @context = context
         @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
-        @tracers = schema.tracers + (context[:tracers] || [])
+        @tracers = schema.tracers + (context[:tracers] || EmptyObjects::EMPTY_ARRAY)
         @max_complexity = max_complexity
         @current_trace = context[:trace] ||= schema.new_trace(multiplex: self)
         @logger = nil

data/lib/graphql/execution/next.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require "graphql/execution/prepare_object_step"
+require "graphql/execution/input_values"
+require "graphql/execution/field_resolve_step"
+require "graphql/execution/finalize"
+require "graphql/execution/load_argument_step"
+require "graphql/execution/runner"
+require "graphql/execution/selections_step"
+module GraphQL
+  module Execution
+    module Finalizer
+      attr_accessor :path
+      def finalize_graphql_result(query, result_data, result_key)
+        raise RequiredImplementationMissingError
+      end
+    end
+
+    module HaltExecution
+    end
+
+    module PostProcessor
+      def after_resolve(field_results)
+        raise RequiredImplementationMissingError, "#{self.class}#after_resolve should handle `field_results` and return a new value to use"
+      end
+    end
+
+    module Next
+      module SchemaExtension
+        def execute_next(query_str = nil, context: nil, document: nil, operation_name: nil, variables: nil, root_value: nil, validate: true, visibility_profile: nil)
+          multiplex_context = if context
+            {
+              backtrace: context[:backtrace],
+              tracers: context[:tracers],
+              trace: context[:trace],
+              dataloader: context[:dataloader],
+              trace_mode: context[:trace_mode],
+            }
+          else
+            {}
+          end
+          query_opts = {
+            query: query_str,
+            document: document,
+            context: context,
+            validate: validate,
+            variables: variables,
+            root_value: root_value,
+            operation_name: operation_name,
+            visibility_profile: visibility_profile,
+          }
+          m_results = multiplex_next([query_opts], context: multiplex_context, max_complexity: nil)
+          m_results[0]
+        end
+
+        def multiplex_next(query_options, context: {}, max_complexity: self.max_complexity)
+          Next.run_all(self, query_options, context: context, max_complexity: max_complexity)
+        end
+
+        def execution_next_options
+          @execution_next_options || find_inherited_value(:execution_next_options, EmptyObjects::EMPTY_HASH)
+        end
+
+        attr_writer :execution_next_options
+      end
+
+      def self.use(schema, authorization: true)
+        schema.extend(SchemaExtension)
+        schema.execution_next_options = { authorization: authorization }
+      end
+
+      def self.run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+        queries = query_options.map do |opts|
+          query = case opts
+          when Hash
+            schema.query_class.new(schema, nil, **opts)
+          when GraphQL::Query, GraphQL::Query::Partial
+            opts
+          else
+            raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
+          end
+          query.context[:__graphql_execute_next] = true
+          query
+        end
+        multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+        runner = Runner.new(multiplex, **schema.execution_next_options)
+        runner.execute
+      end
+    end
+  end
+end

data/lib/graphql/execution/prepare_object_step.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class PrepareObjectStep
+      def initialize(object:, runner:, graphql_result:, key:, is_non_null:, field_resolve_step:, next_objects:, next_results:, is_from_array:)
+        @object = object
+        @runner = runner
+        @field_resolve_step = field_resolve_step
+        @is_non_null = is_non_null
+        @next_objects = next_objects
+        @next_results = next_results
+        @graphql_result = graphql_result
+        @resolved_type = nil
+        @authorized_value = nil
+        @authorization_error = nil
+        @key = key
+        @next_step = :resolve_type
+        @is_from_array = is_from_array
+      end
+
+      def value
+        if @authorized_value
+          query = @field_resolve_step.selections_step.query
+          query.current_trace.begin_authorized(@resolved_type, @object, query.context)
+          @authorized_value = @field_resolve_step.sync(@authorized_value)
+          query.current_trace.end_authorized(@resolved_type, @object, query.context, @authorized_value)
+        elsif @resolved_type
+          ctx = @field_resolve_step.selections_step.query.context
+          st = @field_resolve_step.static_type
+          ctx.query.current_trace.begin_resolve_type(st, @object, ctx)
+          @resolved_type, _ignored_value = @field_resolve_step.sync(@resolved_type)
+          ctx.query.current_trace.end_resolve_type(st, @object, ctx, @resolved_type)
+        end
+        @runner.add_step(self)
+      end
+
+      def call
+        case @next_step
+        when :resolve_type
+          static_type = @field_resolve_step.static_type
+          if static_type.kind.abstract?
+            ctx = @field_resolve_step.selections_step.query.context
+            ctx.query.current_trace.begin_resolve_type(static_type, @object, ctx)
+            @resolved_type, _ignored_value = @runner.schema.resolve_type(static_type, @object, ctx)
+            ctx.query.current_trace.end_resolve_type(static_type, @object, ctx, @resolved_type)
+          else
+            @resolved_type = static_type
+          end
+          if @runner.resolves_lazies && @runner.lazy?(@resolved_type)
+            @next_step = :authorize
+            @runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
+          else
+            authorize
+          end
+        when :authorize
+          authorize
+        when :create_result
+          create_result
+        else
+          raise ArgumentError, "This is a bug, unknown step: #{@next_step.inspect}"
+        end
+      end
+
+      def authorize
+        if @field_resolve_step.was_scoped && !@resolved_type.reauthorize_scoped_objects
+          @authorized_value = @object
+          create_result
+          return
+        end
+
+        query = @field_resolve_step.selections_step.query
+        begin
+          query.current_trace.begin_authorized(@resolved_type, @object, query.context)
+          @authorized_value = @resolved_type.authorized?(@object, query.context)
+          query.current_trace.end_authorized(@resolved_type, @object, query.context, @authorized_value)
+        rescue GraphQL::UnauthorizedError => auth_err
+          @authorization_error = auth_err
+        end
+
+        if @runner.resolves_lazies && @runner.lazy?(@authorized_value)
+          @runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
+          @next_step = :create_result
+        else
+          create_result
+        end
+      rescue GraphQL::RuntimeError => err
+        @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+      end
+
+      def create_result
+        if !@authorized_value
+          @authorization_error ||= GraphQL::UnauthorizedError.new(object: @object, type: @resolved_type, context: @field_resolve_step.selections_step.query.context)
+        end
+
+        if @authorization_error
+          begin
+            new_obj = @runner.schema.unauthorized_object(@authorization_error)
+            if new_obj
+              @authorized_value = true
+              @object = new_obj
+            elsif @is_non_null
+              @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
+            else
+              @graphql_result[@key] = @field_resolve_step.add_graphql_error(@authorization_error)
+            end
+          rescue GraphQL::RuntimeError => err
+            if @is_non_null
+              @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
+            else
+              @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+            end
+          end
+        end
+
+        if @authorized_value
+          next_result_h = {}
+          @next_results << next_result_h
+          @next_objects << @object
+          @graphql_result[@key] = next_result_h
+          @runner.runtime_type_at[next_result_h] = @resolved_type
+          @runner.static_type_at[next_result_h] = @field_resolve_step.static_type
+        end
+
+        @field_resolve_step.authorized_finished(self)
+      end
+    end
+  end
+end