graphql 2.6.9 → 2.6.14

data/lib/graphql/execution/field_resolve_step.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     class FieldResolveStep
+      # Only these built-in fields on Relay connection and edge types return already-scoped items.
+      # Custom fields on those types must still be authorized normally.
+      SCOPED_RELAY_FIELD_NAMES = [:node, :nodes, :edges].freeze
+
       def initialize(parent_type:, runner:, key:, selections_step:)
         @selections_step = selections_step
         @key = key
@@ -21,6 +26,8 @@ module GraphQL
         @finish_extension_idx = nil
         @was_scoped = nil
         @pending_steps = nil
+        @field_authorization_objects = @field_authorization_results = @field_authorization_errors = nil
+        @field_authorization_next_idx = @field_authorization_pending = nil
         @arguments_without_loads = @post_processors = @directive_finalizers = nil
       end
 
@@ -89,6 +96,12 @@ module GraphQL
           finish_extensions
         elsif @field_results
           build_results
+        elsif @field_authorization_results
+          if @field_authorization_next_idx < @field_authorization_objects.size
+            authorize_next_field_object
+          else
+            finish_field_authorizations
+          end
         elsif @arguments
           execute_field
         else
@@ -113,7 +126,7 @@ module GraphQL
         @runner.add_finalizer(@selections_step.query, result, key, err)
         if !err.is_a?(GraphQL::Execution::Skip)
           field_type = return_type
-          should_propagate_null = field_type.non_null?
+          should_propagate_null = field_type.non_null? #: bool
           while (should_propagate_null == false && field_type.kind.wraps?)
             field_type = field_type.of_type
             should_propagate_null = field_type.non_null?
@@ -126,10 +139,10 @@ module GraphQL
       end
 
       def propagate_nulls
-        propagating_null = true
+        propagating_null = true #: bool
         highest_nulled_depth = path.size
-        highest_list_depth = nil
-        current_field_step = self
+        highest_list_depth = nil #: Integer?
+        current_field_step = self #: FieldResolveStep?
         while current_field_step && current_field_step.field_definition
           return_type = current_field_step.field_definition.type
           if propagating_null && return_type.non_null?
@@ -146,7 +159,7 @@ module GraphQL
         end
 
         if highest_list_depth.nil? || highest_nulled_depth <= highest_list_depth
-          kill_field_step = self
+          kill_field_step = self #: FieldResolveStep?
           while kill_field_step && kill_field_step.field_definition && highest_nulled_depth <= kill_field_step.path.size
             kill_field_step.selections_step.killed = true
             kill_field_step = kill_field_step.selections_step.field_resolve_step
@@ -238,153 +251,30 @@ module GraphQL
         end
 
         if @runner.authorizes?(@field_definition, ctx)
-          authorized_objects = []
-          authorized_results = []
-          l = objects.size
-          i = 0
-          while i < l
-            o = objects[i]
-            err = nil
-            begin
-              field_authed = @field_definition.authorized?(o, @arguments, ctx)
-              if @runner.resolves_lazies && @runner.lazy?(field_authed)
-                # TODO batch this properly...
-                field_authed = sync(field_authed)
-              end
-            rescue GraphQL::UnauthorizedFieldError => field_auth_err
-              err = field_auth_err
-              err.field ||= @field_definition
-              field_authed = false
-            end
-
-            if field_authed
-              authorized_results << @results[i]
-              authorized_objects << o
-            else
-              begin
-                err ||= GraphQL::UnauthorizedFieldError.new(object: o, type: @parent_type, context: ctx, field: @field_definition)
-                new_obj = query.schema.unauthorized_field(err)
-                if !new_obj.nil?
-                  authorized_objects << new_obj
-                  authorized_results << @results[i]
-                end
-              rescue GraphQL::ExecutionError => exec_err
-                add_graphql_error(@results[i], key, exec_err)
-              end
-            end
-            i += 1
-          end
-
-          if authorized_objects.size == 0
+          @field_authorization_objects = objects
+          @field_authorization_results = Array.new(objects.size)
+          @field_authorization_next_idx = 0
+          if objects.size > 1 && !@runner.dataloader.is_a?(GraphQL::Dataloader::NullDataloader)
+            # Enqueue this step once per object, so Dataloader sources loaded by `authorized?` batch across objects.
+            # Each call authorizes the next object; see `authorize_next_field_object`.
+            @field_authorization_pending = objects.size
+            objects.size.times { @runner.dataloader.append_job(self) }
             return
           end
-          @results = authorized_results
+          objects.size.times { |idx| authorize_field_at(idx, ctx) }
+          authorized_objects = collect_field_authorizations
+          return if authorized_objects.nil?
         else
           authorized_objects = objects
         end
 
-        if @parent_type.default_relay? && authorized_objects.all? { |o| o.respond_to?(:was_authorized_by_scope_items?) && o.was_authorized_by_scope_items? }
-          @was_scoped = true
-        end
-
-        query.current_trace.begin_execute_field(@field_definition, authorized_objects, @arguments, query)
-
-        if @runner.uses_runtime_directives
-          if @ast_nodes.nil? || @ast_nodes.size == 1
-            directives = if !@ast_node.directives.empty?
-              @ast_node.directives
-            else
-              nil
-            end
-          else
-            directives = nil
-            @ast_nodes.each do |n|
-              if (d = n.directives).any? # rubocop:disable Development/NoneWithoutBlockCop
-                directives ||= []
-                directives.concat(d)
-              end
-            end
-          end
-
-          if directives
-            directives.each do |dir_node|
-              if (dir_defn = @runner.runtime_directives[dir_node.name])
-                dir_args, errors = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, self)  # rubocop:disable Development/ContextIsPassedCop
-                if errors
-                  @results.each { |r| r.delete(@key) }
-                  errors.each { |e| e.ast_node = dir_node }
-                  build_errors_result(errors, nil)
-                  return
-                else
-                  begin
-                    dir_defn.validate!(dir_args, query.context)
-                    if !(result = dir_defn.resolve_field(ast_nodes, @parent_type, field_definition, authorized_objects, dir_args, ctx)).nil?
-                      if result.is_a?(Finalizer)
-                        result.path = path
-                        @directive_finalizers ||= []
-                        @directive_finalizers << result
-                      end
-
-                      if result.is_a?(PostProcessor)
-                        @post_processors ||= []
-                        @post_processors << result
-                      end
-
-                      if result.is_a?(HaltExecution)
-                        @directive_finalizers&.each { |f|
-                          @selections_step.results.each { |r|  @runner.add_finalizer(query, r, key, f) }
-                        }
-                        return
-                      end
-                    end
-                  rescue GraphQL::RuntimeError => err
-                    err.ast_node = dir_node
-                    raise
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        has_extensions = @field_definition.extensions.size > 0
-        if has_extensions
-          @extended = GraphQL::Schema::Field::ExtendedState.new(@arguments, authorized_objects)
-          @field_results = @field_definition.run_next_extensions_before_resolve(authorized_objects, @arguments, ctx, @extended) do |objs, args|
-            if (added_extras = @extended.added_extras)
-              args = args.dup
-              added_extras.each { |e| args.delete(e) }
-            end
-            resolve_batch(objs, ctx, args)
-          end
-          @finish_extension_idx = 0
-        else
-          @field_results = resolve_batch(authorized_objects, ctx, @arguments)
-        end
-
-        query.current_trace.end_execute_field(@field_definition, authorized_objects, @arguments, query, @field_results)
-
-        if any_lazy_results?
-          @runner.dataloader.lazy_at_depth(path.size, self)
-        elsif @pending_steps.nil? || @pending_steps.empty?
-          if has_extensions
-            finish_extensions
-          else
-            build_results
-          end
-        end
-      rescue GraphQL::ExecutionError => err
-        build_errors_result(nil, err)
-      rescue StandardError => stderr
-        begin
-          @selections_step.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
-        rescue GraphQL::ExecutionError => err
-          add_graphql_error(@results[0], key, err)
-        end
+        execute_authorized_field(authorized_objects)
+      rescue StandardError => err
+        handle_execute_field_error(err)
       end
 
       def any_lazy_results?
-        lazies = false
+        lazies = false #: bool
         if @runner.resolves_lazies # TODO extract this
           @field_results.each do |field_result|
             if @runner.lazy?(field_result)
@@ -414,11 +304,15 @@ module GraphQL
           case ext
           when Schema::Field::ConnectionExtension
             conns = ctx.schema.connections
+            lookahead = @arguments[:lookahead]
+            # The memo omits the extension's extras (`:lookahead`)
+            conn_arguments = memos[@finish_extension_idx] || @arguments
             @field_results.map!.each_with_index do |value, idx|
               object = @extended.object[idx]
-              conn = conns.populate_connection(@field_definition, object, value, @arguments, ctx)
+              conn = conns.populate_connection(@field_definition, object, value, conn_arguments, ctx)
               if conn
                 conn.was_authorized_by_scope_items = @was_scoped
+                conn.lookahead ||= lookahead
               end
               conn
             rescue GraphQL::RuntimeError => err
@@ -510,7 +404,7 @@ module GraphQL
       def build_leaf_result(result_h, result_key, field_result, return_type, ctx, is_from_array)
         if field_result.nil?
           if return_type.non_null?
-            add_non_null_error(is_from_array)
+            add_non_null_error(is_from_array, return_type: return_type)
           else
             nil
           end
@@ -527,7 +421,7 @@ module GraphQL
           end
 
           inner_type = return_type.of_type
-          result_a = Array.new(field_result.size)
+          result_a = field_result.is_a?(Array) ? Array.new(field_result.size) : []
           field_result.each_with_index do |item, idx|
             result_a[idx] = build_leaf_result(result_a, idx, item, inner_type, ctx, true)
           end
@@ -605,8 +499,14 @@ module GraphQL
         end
       end
 
-      def add_non_null_error(is_from_array)
-        err = @parent_type::InvalidNullError.new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path)
+      def add_non_null_error(is_from_array, return_type: nil)
+        if is_from_array && return_type
+          list_type = @field_definition.type
+          list_type = list_type.of_type if list_type.non_null?
+          # Preserve existing messages for single-level lists.
+          element_type = return_type.of_type if list_type.of_type.list?
+        end
+        err = @parent_type.const_get(:InvalidNullError).new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path, element_type: element_type)
         nn_result = @runner.schema.type_error(err, @selections_step.query.context)
         if nn_result.nil?
           propagate_nulls
@@ -620,6 +520,207 @@ module GraphQL
 
       private
 
+      def execute_authorized_field(authorized_objects)
+        query = @selections_step.query
+        ctx = query.context
+
+        if @parent_type.default_relay? && SCOPED_RELAY_FIELD_NAMES.include?(@field_definition.original_name) && authorized_objects.all? { |o| o.respond_to?(:was_authorized_by_scope_items?) && o.was_authorized_by_scope_items? }
+          @was_scoped = true
+        end
+
+        query.current_trace.begin_execute_field(@field_definition, authorized_objects, @arguments, query)
+
+        if @runner.uses_runtime_directives
+          if @ast_nodes.nil? || @ast_nodes.size == 1
+            directives = if !@ast_node.directives.empty?
+              @ast_node.directives
+            else
+              nil
+            end
+          else
+            directives = nil #: Array[untyped]?
+            @ast_nodes.each do |n|
+              if (d = n.directives).any? # rubocop:disable Development/NoneWithoutBlockCop
+                directives ||= []
+                directives.concat(d)
+              end
+            end
+          end
+
+          if directives
+            directives.each do |dir_node|
+              if (dir_defn = @runner.runtime_directives[dir_node.name])
+                dir_args, errors = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, self)  # rubocop:disable Development/ContextIsPassedCop
+                if errors
+                  @results.each { |r| r.delete(@key) }
+                  errors.each { |e| e.ast_node = dir_node }
+                  build_errors_result(errors, nil)
+                  return
+                else
+                  begin
+                    dir_defn.validate!(dir_args, query.context)
+                    if !(result = dir_defn.resolve_field(ast_nodes, @parent_type, field_definition, authorized_objects, dir_args, ctx)).nil?
+                      if result.is_a?(Finalizer)
+                        result.path = path
+                        @directive_finalizers ||= []
+                        @directive_finalizers << result
+                      end
+
+                      if result.is_a?(PostProcessor)
+                        @post_processors ||= []
+                        @post_processors << result
+                      end
+
+                      if result.is_a?(HaltExecution)
+                        @directive_finalizers&.each { |f|
+                          @selections_step.results.each { |r|  @runner.add_finalizer(query, r, key, f) }
+                        }
+                        return
+                      end
+                    end
+                  rescue GraphQL::RuntimeError => err
+                    err.ast_node = dir_node
+                    raise
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        has_extensions = @field_definition.extensions.size > 0
+        if has_extensions
+          @extended = GraphQL::Schema::Field::ExtendedState.new(@arguments, authorized_objects)
+          @field_results = @field_definition.run_next_extensions_before_resolve(authorized_objects, @arguments, ctx, @extended) do |objs, args|
+            if (added_extras = @extended.added_extras)
+              args = args.dup
+              added_extras.each { |e| args.delete(e) }
+            end
+            resolve_batch(objs, ctx, args)
+          end
+          @finish_extension_idx = 0
+        else
+          @field_results = resolve_batch(authorized_objects, ctx, @arguments)
+        end
+
+        query.current_trace.end_execute_field(@field_definition, authorized_objects, @arguments, query, @field_results)
+
+        if any_lazy_results?
+          @runner.dataloader.lazy_at_depth(path.size, self)
+        elsif @pending_steps.nil? || @pending_steps.empty?
+          if has_extensions
+            finish_extensions
+          else
+            build_results
+          end
+        end
+      rescue StandardError => err
+        handle_execute_field_error(err)
+      end
+
+      def handle_execute_field_error(err)
+        if @field_authorization_objects
+          clear_field_authorizations
+        end
+        if err.is_a?(GraphQL::ExecutionError)
+          build_errors_result(nil, err)
+        else
+          begin
+            @selections_step.query.handle_or_reraise(err, field: @field_definition, arguments: @arguments, object: nil)
+          rescue GraphQL::ExecutionError => exec_err
+            add_graphql_error(@results[0], key, exec_err)
+          end
+        end
+      end
+
+      # Stores the (possibly synced) +authorized?+ result for the object at +idx+.
+      # A GraphQL::UnauthorizedFieldError raised by +authorized?+ is stored in +@field_authorization_errors+.
+      def authorize_field_at(idx, ctx)
+        field_authed = @field_definition.authorized?(@field_authorization_objects[idx], @arguments, ctx)
+        if @runner.resolves_lazies && @runner.lazy?(field_authed)
+          field_authed = sync(field_authed)
+        end
+        @field_authorization_results[idx] = field_authed
+      rescue GraphQL::UnauthorizedFieldError => field_auth_err
+        field_auth_err.field ||= @field_definition
+        (@field_authorization_errors ||= {})[idx] = field_auth_err
+      end
+
+      # Runs once for each time this step was enqueued for field authorization.
+      # The index is taken before +authorized?+ runs, so it's still correct if this Fiber pauses.
+      # When the last object is done, the step is enqueued again to call +finish_field_authorizations+.
+      def authorize_next_field_object
+        idx = @field_authorization_next_idx
+        @field_authorization_next_idx += 1
+        begin
+          authorize_field_at(idx, @selections_step.query.context)
+        rescue StandardError => err
+          (@field_authorization_errors ||= {})[idx] = err
+        end
+        @field_authorization_pending -= 1
+        if @field_authorization_pending == 0
+          @runner.add_step(self)
+        end
+      end
+
+      def finish_field_authorizations
+        if (errors = @field_authorization_errors)
+          @field_authorization_objects.size.times do |idx|
+            err = errors[idx]
+            if err && !err.is_a?(GraphQL::UnauthorizedFieldError)
+              raise err
+            end
+          end
+        end
+        authorized_objects = collect_field_authorizations
+        if authorized_objects
+          execute_authorized_field(authorized_objects)
+        end
+      rescue StandardError => err
+        handle_execute_field_error(err)
+      end
+
+      def clear_field_authorizations
+        @field_authorization_objects = @field_authorization_results = @field_authorization_errors = nil
+        @field_authorization_next_idx = @field_authorization_pending = nil
+      end
+
+      # Applies +unauthorized_field+ for denied objects, in object order.
+      # Returns the objects to resolve, or +nil+ if none are left.
+      def collect_field_authorizations
+        objects = @field_authorization_objects
+        auth_results = @field_authorization_results
+        errors = @field_authorization_errors
+        clear_field_authorizations
+        ctx = @selections_step.query.context
+        authorized_objects = []
+        authorized_results = []
+        objects.each_with_index do |o, i|
+          err = errors && errors[i]
+          if !err && auth_results[i]
+            authorized_results << @results[i]
+            authorized_objects << o
+          else
+            begin
+              err ||= GraphQL::UnauthorizedFieldError.new(object: o, type: @parent_type, context: ctx, field: @field_definition)
+              new_obj = ctx.schema.unauthorized_field(err)
+              if !new_obj.nil?
+                authorized_objects << new_obj
+                authorized_results << @results[i]
+              end
+            rescue GraphQL::ExecutionError => exec_err
+              add_graphql_error(@results[i], key, exec_err)
+            end
+          end
+        end
+
+        if authorized_objects.size == 0
+          return nil
+        end
+        @results = authorized_results
+        authorized_objects
+      end
+
       def build_graphql_result(graphql_result, key, field_result, return_type, is_nn, is_list, is_from_array) # rubocop:disable Metrics/ParameterLists
         if field_result.nil?
           if is_nn
@@ -645,11 +746,18 @@ module GraphQL
           list_result = graphql_result[key] = []
           @directive_finalizers&.each { |f| @runner.add_finalizer(@selections_step.query, list_result, nil, f) }
           i = 0
-          s = field_result.size
-          while i < s
-            inner_f_r = field_result[i]
-            build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
-            i += 1
+          if field_result.is_a?(Array)
+            s = field_result.size
+            while i < s
+              inner_f_r = field_result[i]
+              build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
+              i += 1
+            end
+          else
+            field_result.each do |inner_f_r|
+              build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
+              i += 1
+            end
           end
         elsif @runner.resolves_lazies || (
                 @static_type.kind.object? ?
@@ -690,25 +798,25 @@ module GraphQL
         when :resolve_batch
           begin
             method_receiver.public_send(@field_definition.execution_mode_key, objects, context, **args_hash)
-          rescue GraphQL::ExecutionError => exec_err
-            error_instance_array(objects.size, exec_err)
-          rescue StandardError => stderr
+          rescue GraphQL::ExecutionError => batch_err
+            error_instance_array(objects.size, batch_err)
+          rescue StandardError => batch_stderr
             begin
-              context.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
-            rescue GraphQL::ExecutionError => exec_err
-              error_instance_array(objects.size, exec_err)
+              context.query.handle_or_reraise(batch_stderr, field: @field_definition, arguments: @arguments, object: nil)
+            rescue GraphQL::ExecutionError => batch_err
+              error_instance_array(objects.size, batch_err)
             end
           end
         when :resolve_static
           result = begin
             method_receiver.public_send(@field_definition.execution_mode_key, context, **args_hash)
-          rescue GraphQL::ExecutionError => err
-            err
-          rescue StandardError => stderr
+          rescue GraphQL::ExecutionError => static_err
+            static_err
+          rescue StandardError => static_stderr
             begin
-              context.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
-            rescue GraphQL::ExecutionError => err
-              err
+              context.query.handle_or_reraise(static_stderr, field: @field_definition, arguments: @arguments, object: nil)
+            rescue GraphQL::ExecutionError => static_err
+              static_err
             end
           end
           Array.new(objects.size, result)
@@ -744,7 +852,8 @@ module GraphQL
         when :dig
           objects.map { |o| o.dig(*@field_definition.execution_mode_key) }
         when :dataload
-          if (k = @field_definition.execution_mode_key).is_a?(Class)
+          k = @field_definition.execution_mode_key
+          results = if k.is_a?(Class)
             context.dataload_all(k, objects)
           elsif (source_class = k[:with])
             if (batch_args = k[:by])
@@ -764,6 +873,12 @@ module GraphQL
           else
             raise ArgumentError, "Unexpected `dataload: ...` configuration: #{k.inspect}"
           end
+          method = k.is_a?(Hash) ? k[:method] : nil
+          if method
+            results.map { |r| r&.public_send(method) }
+          else
+            results
+          end
         when :resolver_class
           results = Array.new(objects.size, nil)
           ps = @pending_steps ||= []
@@ -779,8 +894,13 @@ module GraphQL
           end
           results
         when :resolve_legacy_instance_method
-          @selections_step.graphql_objects.map do |obj_inst|
-            obj_inst.public_send(@field_definition.execution_mode_key, **args_hash)
+          graphql_objects = if objects.equal?(@selections_step.objects)
+            @selections_step.graphql_objects
+          else
+            objects.map { |object| @parent_type.scoped_new(object, context) }
+          end
+          graphql_objects.map do |graphql_object|
+            graphql_object.public_send(@field_definition.execution_mode_key, **args_hash)
           rescue GraphQL::ExecutionError => exec_err
             exec_err
           end

data/lib/graphql/execution/finalize.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     class Finalize
@@ -39,11 +40,16 @@ module GraphQL
                 tf[key] = err
                 @finalizers_count += 1
               elsif value_at_key.is_a?(Array)
-                value_at_key.each_with_index do |el, idx|
-                  if el.equal?(err)
-                    tf = @finalizers[value_at_key] ||= {}.compare_by_identity
-                    tf[idx] = err
-                    @finalizers_count += 1
+                pending_arrays = [value_at_key]
+                while (array = pending_arrays.pop)
+                  array.each_with_index do |el, idx|
+                    if el.equal?(err)
+                      array_tf = @finalizers[array] ||= {}.compare_by_identity
+                      array_tf[idx] = err
+                      @finalizers_count += 1
+                    elsif el.is_a?(Array)
+                      pending_arrays << el
+                    end
                   end
                 end
               end
@@ -175,7 +181,7 @@ module GraphQL
           inner_type = inner_type.of_type
         end
 
-        new_invalid_null = false
+        new_invalid_null = false #: bool
 
         if (f = finalizers(result_arr, nil))
           run_finalizers(@current_result_path.dup, f, result_arr, nil)

data/lib/graphql/execution/input_values.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     class InputValues
@@ -38,7 +39,7 @@ module GraphQL
       def argument_values(owner_defn, argument_nodes, field_resolve_step)
         arg_defns = @query.types.arguments(owner_defn)
         argument_values = {}
-        errors = nil
+        errors = nil #: untyped
 
         arg_defns.each do |argument_definition|
           arg_ruby_key = argument_definition.keyword
@@ -182,7 +183,9 @@ module GraphQL
           arg_value = begin
             argument_definition.prepare_value(nil, arg_value, context: @query.context)
           rescue StandardError => err
-            @runner.schema.handle_or_reraise(@query.context, err, object: nil, arguments: argument_values, field: field_resolve_step&.field_definition)
+            handled_err = @runner.schema.handle_or_reraise(@query.context, err, object: nil, arguments: argument_values, field: field_resolve_step&.field_definition)
+            raise handled_err if handled_err.is_a?(GraphQL::RuntimeError)
+            handled_err
           end
         end