graphql 2.5.20 → 2.5.21

data/lib/graphql/execution/next/load_argument_step.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    module Next
+      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 = @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
+          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::Error)
+            @loaded_value.path = @field_resolve_step.path
+            @field_resolve_step.arguments = @loaded_value
+          else
+            @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
+end

data/lib/graphql/execution/{batching → next}/prepare_object_step.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Execution
-    module Batching
+    module Next
       class PrepareObjectStep
         def initialize(static_type:, object:, runner:, graphql_result:, key:, is_non_null:, field_resolve_step:, next_objects:, next_results:, is_from_array:)
           @static_type = static_type
@@ -22,9 +22,15 @@ module GraphQL
 
         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
+            ctx.query.current_trace.begin_resolve_type(@static_type, @object, ctx)
             @resolved_type, _ignored_value = @field_resolve_step.sync(@resolved_type)
+            ctx.query.current_trace.end_resolve_type(@static_type, @object, ctx, @resolved_type)
           end
           @runner.add_step(self)
         end
@@ -33,11 +39,14 @@ module GraphQL
           case @next_step
           when :resolve_type
             if @static_type.kind.abstract?
-              @resolved_type, _ignored_value = @runner.schema.resolve_type(@static_type, @object, @field_resolve_step.selections_step.query.context)
+              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.schema.lazy?(@resolved_type)
+            if @runner.resolves_lazies && @runner.lazy?(@resolved_type)
               @next_step = :authorize
               @runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
             else
@@ -53,14 +62,22 @@ module GraphQL
         end
 
         def authorize
-          ctx = @field_resolve_step.selections_step.query.context
+          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
-            @authorized_value = @resolved_type.authorized?(@object, ctx)
+            query.current_trace.begin_authorized(@resolved_type, @object, query.context)
+            @authorized_value = @resolved_type.authorized?(@object, query.context)
+            query.current_trace.end_authorized(@resolve_type, @object, query.context, @authorized_value)
           rescue GraphQL::UnauthorizedError => auth_err
             @authorization_error = auth_err
           end
 
-          if @runner.resolves_lazies && @runner.schema.lazy?(@authorized_value)
+          if @runner.resolves_lazies && @runner.lazy?(@authorized_value)
             @runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
             @next_step = :create_result
           else
@@ -100,11 +117,11 @@ module GraphQL
             @next_results << next_result_h
             @next_objects << @object
             @graphql_result[@key] = next_result_h
-            @runner.runtime_types_at_result[next_result_h] = @resolved_type
-            @runner.static_types_at_result[next_result_h] = @static_type
+            @runner.runtime_type_at[next_result_h] = @resolved_type
+            @runner.static_type_at[next_result_h] = @static_type
           end
 
-          @field_resolve_step.authorized_finished
+          @field_resolve_step.authorized_finished(self)
         end
       end
     end

data/lib/graphql/execution/{batching → next}/runner.rb

@@ -1,26 +1,49 @@
 # frozen_string_literal: true
 module GraphQL
   module Execution
-    module Batching
+    module Next
       class Runner
-        def initialize(multiplex)
+        def initialize(multiplex, authorization:)
           @multiplex = multiplex
           @schema = multiplex.schema
           @steps_queue = []
-          @runtime_types_at_result = {}.compare_by_identity
-          @static_types_at_result = {}.compare_by_identity
+          @runtime_type_at = {}.compare_by_identity
+          @static_type_at = {}.compare_by_identity
           @selected_operation = nil
           @dataloader = multiplex.context[:dataloader] ||= @schema.dataloader_class.new
           @resolves_lazies = @schema.resolves_lazies?
+          @lazy_cache = resolves_lazies ? {}.compare_by_identity : nil
           @field_resolve_step_class = @schema.uses_raw_value? ? RawValueFieldResolveStep : FieldResolveStep
-          @authorizes = {}.compare_by_identity
+          @authorization = authorization
+          if @authorization
+            @authorizes_cache = Hash.new do |h, query_context|
+              h[query_context] = {}.compare_by_identity
+            end.compare_by_identity
+          end
+        end
+
+        def resolve_type(type, object, query)
+          query.current_trace.begin_resolve_type(@static_type, object, query.context)
+          resolved_type, _ignored_new_value = query.resolve_type(type, object)
+          query.current_trace.end_resolve_type(@static_type, object, query.context, resolved_type)
+          resolved_type
+        end
+
+        def authorizes?(graphql_definition, query_context)
+          auth_cache = @authorizes_cache[query_context]
+          case (auth_res = auth_cache[graphql_definition])
+          when nil
+            auth_cache[graphql_definition] = graphql_definition.authorizes?(query_context)
+          else
+            auth_res
+          end
         end
 
         def add_step(step)
           @dataloader.append_job(step)
         end
 
-        attr_reader :steps_queue, :schema, :variables, :static_types_at_result, :runtime_types_at_result, :dataloader, :resolves_lazies, :authorizes
+        attr_reader :authorization, :steps_queue, :schema, :variables, :dataloader, :resolves_lazies, :authorizes, :static_type_at, :runtime_type_at
 
         def execute
           Fiber[:__graphql_current_multiplex] = @multiplex
@@ -60,27 +83,33 @@ module GraphQL
                 raise ArgumentError, "Unknown operation type: #{selected_operation.operation_type.inspect}"
               end
 
-              auth_check = schema.sync_lazy(root_type.authorized?(query.root_value, query.context))
-              root_value = if auth_check
-                query.root_value
-              else
-                begin
-                  auth_err = GraphQL::UnauthorizedError.new(object: query.root_value, type: root_type, context: query.context)
-                  new_val = schema.unauthorized_object(auth_err)
-                  if new_val
-                    auth_check = true
+              if self.authorization && authorizes?(root_type, query.context)
+                query.current_trace.begin_authorized(root_type, query.root_value, query.context)
+                auth_check = schema.sync_lazy(root_type.authorized?(query.root_value, query.context))
+                query.current_trace.end_authorized(root_type, query.root_value, query.context, auth_check)
+                root_value = if auth_check
+                  query.root_value
+                else
+                  begin
+                    auth_err = GraphQL::UnauthorizedError.new(object: query.root_value, type: root_type, context: query.context)
+                    new_val = schema.unauthorized_object(auth_err)
+                    if new_val
+                      auth_check = true
+                    end
+                    new_val
+                  rescue GraphQL::ExecutionError => ex_err
+                    # The old runtime didn't add path and ast_nodes to this
+                    query.context.add_error(ex_err)
+                    nil
                   end
-                  new_val
-                rescue GraphQL::ExecutionError => ex_err
-                  # The old runtime didn't add path and ast_nodes to this
-                  query.context.add_error(ex_err)
-                  nil
                 end
-              end
 
-              if !auth_check
-                results << {}
-                next
+                if !auth_check
+                  results << {}
+                  next
+                end
+              else
+                root_value = query.root_value
               end
 
               results << { "data" => data }
@@ -116,8 +145,7 @@ module GraphQL
                 raise ArgumentError, "Unhandled operation type: #{operation.operation_type.inspect}"
               end
 
-              @static_types_at_result[data] = root_type
-              @runtime_types_at_result[data] = root_type
+              @static_type_at[data] = root_type
 
               # TODO This is stupid but makes multiplex_spec.rb pass
               trace.execute_query(query: query) do
@@ -197,6 +225,15 @@ module GraphQL
           end
         end
 
+        def lazy?(object)
+          obj_class = object.class
+          is_lazy = @lazy_cache[obj_class]
+          if is_lazy.nil?
+            is_lazy = @lazy_cache[obj_class] = @schema.lazy?(object)
+          end
+          is_lazy
+        end
+
         private
 
         def propagate_errors(data, query)
@@ -256,13 +293,13 @@ module GraphQL
                 current_result_path.pop
               end
             when Language::Nodes::InlineFragment
-              static_type_at_result = @static_types_at_result[result_h]
+              static_type_at_result = @static_type_at[result_h]
               if static_type_at_result && type_condition_applies?(query.context, static_type_at_result, ast_selection.type.name)
                 result_h = check_object_result(query, result_h, static_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
               end
             when Language::Nodes::FragmentSpread
               fragment_defn = query.document.definitions.find { |defn| defn.is_a?(Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
-              static_type_at_result = @static_types_at_result[result_h]
+              static_type_at_result = @static_type_at[result_h]
               if static_type_at_result && type_condition_applies?(query.context, static_type_at_result, fragment_defn.type.name)
                 result_h = check_object_result(query, result_h, static_type, fragment_defn.selections, current_exec_path, current_result_path, paths_to_check)
               end

data/lib/graphql/execution/{batching → next}/selections_step.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Execution
-    module Batching
+    module Next
       class SelectionsStep
         def initialize(parent_type:, selections:, objects:, results:, runner:, query:, path:)
           @path = path

data/lib/graphql/execution/{batching.rb → next.rb}

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
-require "graphql/execution/batching/prepare_object_step"
-require "graphql/execution/batching/field_compatibility"
-require "graphql/execution/batching/field_resolve_step"
-require "graphql/execution/batching/runner"
-require "graphql/execution/batching/selections_step"
+require "graphql/execution/next/prepare_object_step"
+require "graphql/execution/next/field_resolve_step"
+require "graphql/execution/next/load_argument_step"
+require "graphql/execution/next/runner"
+require "graphql/execution/next/selections_step"
 module GraphQL
   module Execution
-    module Batching
+    module Next
       module SchemaExtension
-        def execute_batching(query_str = nil, context: nil, document: nil, variables: nil, root_value: nil, validate: true, visibility_profile: nil)
+        def execute_next(query_str = nil, context: nil, document: nil, variables: nil, root_value: nil, validate: true, visibility_profile: nil)
           multiplex_context = if context
             {
               backtrace: context[:backtrace],
@@ -29,17 +29,24 @@ module GraphQL
             root_value: root_value,
             visibility_profile: visibility_profile,
           }
-          m_results = multiplex_batching([query_opts], context: multiplex_context, max_complexity: nil)
+          m_results = multiplex_next([query_opts], context: multiplex_context, max_complexity: nil)
           m_results[0]
         end
 
-        def multiplex_batching(query_options, context: {}, max_complexity: self.max_complexity)
-          Batching.run_all(self, query_options, context: context, max_complexity: max_complexity)
+        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)
+      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)
@@ -54,7 +61,7 @@ module GraphQL
           end
         end
         multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
-        runner = Runner.new(multiplex)
+        runner = Runner.new(multiplex, **schema.execution_next_options)
         runner.execute
       end
     end

data/lib/graphql/execution.rb

@@ -4,6 +4,7 @@ require "graphql/execution/interpreter"
 require "graphql/execution/lazy"
 require "graphql/execution/lookahead"
 require "graphql/execution/multiplex"
+require "graphql/execution/next"
 require "graphql/execution/errors"
 
 module GraphQL

data/lib/graphql/introspection/dynamic_fields.rb

@@ -2,9 +2,13 @@
 module GraphQL
   module Introspection
     class DynamicFields < Introspection::BaseObject
-      field :__typename, String, "The name of this type", null: false, dynamic_introspection: true
+      field :__typename, String, "The name of this type", null: false, dynamic_introspection: true, resolve_each: true
 
       def __typename
+        self.class.__typename(object, context)
+      end
+
+      def self.__typename(object, context)
         object.class.graphql_name
       end
     end

data/lib/graphql/introspection/entry_points.rb

@@ -3,7 +3,7 @@ module GraphQL
   module Introspection
     class EntryPoints < Introspection::BaseObject
       field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false, dynamic_introspection: true, resolve_static: :__schema
-      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true do
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true, resolve_static: :__type do
         argument :name, String
       end
 
@@ -19,6 +19,10 @@ module GraphQL
       end
 
       def __type(name:)
+        self.class.__type(context, name: name)
+      end
+
+      def self.__type(context, name:)
         if context.types.reachable_type?(name) && (type = context.types.type(name))
           type
         elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })

data/lib/graphql/pagination/connection.rb

@@ -94,6 +94,8 @@ module GraphQL
         @was_authorized_by_scope_items = detect_was_authorized_by_scope_items
       end
 
+      attr_writer :was_authorized_by_scope_items
+
       def was_authorized_by_scope_items?
         @was_authorized_by_scope_items
       end

data/lib/graphql/pagination/connections.rb

@@ -83,6 +83,38 @@ module GraphQL
         end
       end
 
+      def populate_connection(field, object, value, original_arguments, context)
+        if value.is_a? GraphQL::ExecutionError
+          # This isn't even going to work because context doesn't have ast_node anymore
+          context.add_error(value)
+          nil
+        elsif value.nil?
+          nil
+        elsif value.is_a?(GraphQL::Pagination::Connection)
+          # update the connection with some things that may not have been provided
+          value.context ||= context
+          value.parent ||= object
+          value.first_value ||= original_arguments[:first]
+          value.after_value ||= original_arguments[:after]
+          value.last_value ||= original_arguments[:last]
+          value.before_value ||= original_arguments[:before]
+          value.arguments ||= original_arguments # rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
+          value.field ||= field
+          if field.has_max_page_size? && !value.has_max_page_size_override?
+            value.max_page_size = field.max_page_size
+          end
+          if field.has_default_page_size? && !value.has_default_page_size_override?
+            value.default_page_size = field.default_page_size
+          end
+          if (custom_t = context.schema.connections.edge_class_for_field(field))
+            value.edge_class = custom_t
+          end
+          value
+        else
+          context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
+          context.schema.connections.wrap(field, object, value, original_arguments, context)
+        end
+      end
       # use an override if there is one
       # @api private
       def edge_class_for_field(field)

data/lib/graphql/schema/argument.rb

@@ -4,6 +4,7 @@ module GraphQL
     class Argument
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
+      include GraphQL::Schema::Member::HasAuthorization
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
       include GraphQL::Schema::Member::HasValidators

data/lib/graphql/schema/build_from_definition.rb

@@ -519,35 +519,22 @@ module GraphQL
 
             # Don't do this for interfaces
             if default_resolve
-              define_field_resolve_method(owner, resolve_method_name, field_definition.name, field_definition.arguments.empty?)
+              define_field_resolve_method(owner, resolve_method_name, field_definition.name)
             end
           end
         end
 
-        def define_field_resolve_method(owner, method_name, field_name, empty_arguments)
-          if empty_arguments
-            owner.define_method(method_name) {
-              field_instance = context.types.field(owner, field_name)
-              context.schema.definition_default_resolve.call(self.class, field_instance, object, EmptyObjects::EMPTY_HASH, context)
-            }
-            owner.define_singleton_method(method_name) { |objects, context|
-              field_instance = context.types.field(owner, field_name)
-              objects.map do |object|
-                context.schema.definition_default_resolve.call(self, field_instance, object, EmptyObjects::EMPTY_HASH, context)
-              end
-            }
-          else
-            owner.define_method(method_name) { |**args|
-              field_instance = context.types.field(owner, field_name)
-              context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
-            }
-            owner.define_singleton_method(method_name) { |objects, context, **args|
-              field_instance = context.types.field(owner, field_name)
-              objects.map do |object|
-                context.schema.definition_default_resolve.call(self, field_instance, object, args, context)
-              end
-            }
-          end
+        def define_field_resolve_method(owner, method_name, field_name)
+          owner.define_method(method_name) { |**args|
+            field_instance = context.types.field(owner, field_name)
+            context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
+          }
+          owner.define_singleton_method(method_name) { |objects, context, **args|
+            field_instance = context.types.field(owner, field_name)
+            objects.map do |object|
+              context.schema.definition_default_resolve.call(self, field_instance, object, args, context)
+            end
+          }
         end
 
         def build_resolve_type(lookup_hash, directives, missing_type_handler)

data/lib/graphql/schema/field/connection_extension.rb

@@ -21,45 +21,25 @@ module GraphQL
           yield(object, next_args, arguments)
         end
 
+        def resolve_next(objects:, arguments:, context:)
+          next_args = arguments.dup
+          next_args.delete(:first)
+          next_args.delete(:last)
+          next_args.delete(:before)
+          next_args.delete(:after)
+          yield(objects, next_args, arguments)
+        end
+
         def after_resolve(value:, object:, arguments:, context:, memo:)
           original_arguments = memo
-          # rename some inputs to avoid conflicts inside the block
-          maybe_lazy = value
-          value = nil
-          context.query.after_lazy(maybe_lazy) do |resolved_value|
-            value = resolved_value
-            if value.is_a? GraphQL::ExecutionError
-              # This isn't even going to work because context doesn't have ast_node anymore
-              context.add_error(value)
-              nil
-            elsif value.nil?
-              nil
-            elsif value.is_a?(GraphQL::Pagination::Connection)
-              # update the connection with some things that may not have been provided
-              value.context ||= context
-              value.parent ||= object.object
-              value.first_value ||= original_arguments[:first]
-              value.after_value ||= original_arguments[:after]
-              value.last_value ||= original_arguments[:last]
-              value.before_value ||= original_arguments[:before]
-              value.arguments ||= original_arguments # rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
-              value.field ||= field
-              if field.has_max_page_size? && !value.has_max_page_size_override?
-                value.max_page_size = field.max_page_size
-              end
-              if field.has_default_page_size? && !value.has_default_page_size_override?
-                value.default_page_size = field.default_page_size
-              end
-              if (custom_t = context.schema.connections.edge_class_for_field(@field))
-                value.edge_class = custom_t
-              end
-              value
-            else
-              context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
-              context.schema.connections.wrap(field, object.object, value, original_arguments, context)
-            end
+          context.query.after_lazy(value) do |resolved_value|
+            context.schema.connections.populate_connection(field, object.object, resolved_value, original_arguments, context)
           end
         end
+
+        def after_resolve_next(**kwargs)
+          raise "This should never be called -- it's hardcoded in execution instead."
+        end
       end
     end
   end

data/lib/graphql/schema/field/scope_extension.rb

@@ -5,24 +5,33 @@ module GraphQL
     class Field
       class ScopeExtension < GraphQL::Schema::FieldExtension
         def after_resolve(object:, arguments:, context:, value:, memo:)
-          if value.nil?
-            value
-          else
-            ret_type = @field.type.unwrap
-            if ret_type.respond_to?(:scope_items)
-              scoped_items = ret_type.scope_items(value, context)
-              if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
-                if (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
-                    (query_runtime_state = current_runtime_state[context.query])
-                  query_runtime_state.was_authorized_by_scope_items = true
+          if object.is_a?(GraphQL::Schema::Object)
+            if value.nil?
+              value
+            else
+              return_type = field.type.unwrap
+              if return_type.respond_to?(:scope_items)
+                scoped_items = return_type.scope_items(value, context)
+                if !scoped_items.equal?(value) && !return_type.reauthorize_scoped_objects
+                  if (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
+                      (query_runtime_state = current_runtime_state[context.query])
+                    query_runtime_state.was_authorized_by_scope_items = true
+                  end
                 end
+                scoped_items
+              else
+                value
               end
-              scoped_items
-            else
-              value
             end
+          else
+            # TODO skip this entirely?
+            value
           end
         end
+
+        def after_resolve_next(**kwargs)
+          raise "This should never be called -- it's hardcoded in execution instead."
+        end
       end
     end
   end