graphql 2.5.22 → 2.5.24

data/lib/graphql/query/partial.rb

@@ -32,6 +32,7 @@ module GraphQL
         @multiplex = nil
         @result_values = nil
         @result = nil
+        @finalizers = @top_level_finalizers = nil
 
         if fragment_node
           @ast_nodes = [fragment_node]
@@ -51,6 +52,10 @@ module GraphQL
         @leaf
       end
 
+      def root_value
+        object
+      end
+
       attr_reader :context, :query, :ast_nodes, :root_type, :object, :field_definition, :path, :schema
 
       attr_accessor :multiplex, :result_values
@@ -90,10 +95,22 @@ module GraphQL
         @query.fragments
       end
 
+      def validate
+        @query.validate
+      end
+
       def valid?
         @query.valid?
       end
 
+      def query?
+        true
+      end
+
+      def run_partials(...)
+        @query.run_partials(...)
+      end
+
       def analyzers
         EmptyObjects::EMPTY_ARRAY
       end
@@ -107,7 +124,7 @@ module GraphQL
       end
 
       def selected_operation
-        ast_nodes.first
+        Language::Nodes::OperationDefinition.new(selections: ast_nodes.flat_map(&:selections))
       end
 
       def static_errors
@@ -123,7 +140,6 @@ module GraphQL
       def set_type_info_from_path
         selections = [@query.selected_operation]
         type = @query.root_type
-        parent_type = nil
         field_defn = nil
 
         @path.each do |name_in_doc|
@@ -162,7 +178,6 @@ module GraphQL
           end
           field_name = next_selections.first.name
           field_defn = @schema.get_field(type, field_name, @query.context) || raise("Invariant: no field called #{field_name} on #{type.graphql_name}")
-          parent_type = type
           type = field_defn.type
           if type.non_null?
             type = type.of_type

data/lib/graphql/query.rb

@@ -159,6 +159,7 @@ module GraphQL
       @root_value = root_value
       @fragments = nil
       @operations = nil
+      @finalizers = @top_level_finalizers = nil
       @validate = validate
       self.static_validator = static_validator if static_validator
       context_tracers = (context ? context.fetch(:tracers, []) : [])
@@ -262,6 +263,10 @@ module GraphQL
       with_prepared_ast { @operations }
     end
 
+    def path
+      EmptyObjects::EMPTY_ARRAY
+    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
@@ -271,7 +276,11 @@ module GraphQL
     # @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)
+      if context[:__graphql_execute_next]
+        Execution::Next.run_all(@schema, partials, context: @context)
+      else
+        Execution::Interpreter.run_all(@schema, partials, context: @context)
+      end
     end
 
     # Get the result for this query, executing it once

data/lib/graphql/runtime_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module GraphQL
+  class RuntimeError < Error
+    include GraphQL::Execution::Finalizer
+  end
+end

data/lib/graphql/schema/directive.rb

@@ -31,17 +31,25 @@ module GraphQL
 
         def locations(*new_locations)
           if !new_locations.empty?
+            is_runtime = false
             new_locations.each do |new_loc|
-              if !LOCATIONS.include?(new_loc.to_sym)
+              loc_sym = new_loc.to_sym
+              if !LOCATIONS.include?(loc_sym)
                 raise ArgumentError, "#{self} (#{self.graphql_name}) has an invalid directive location: `locations #{new_loc}` "
               end
+              is_runtime ||= RUNTIME_LOCATIONS.include?(loc_sym)
             end
             @locations = new_locations
+            @is_runtime = is_runtime
           else
             @locations ||= (superclass.respond_to?(:locations) ? superclass.locations : [])
           end
         end
 
+        def runtime?
+          @is_runtime
+        end
+
         def default_directive(new_default_directive = nil)
           if new_default_directive != nil
             @default_directive = new_default_directive
@@ -104,8 +112,12 @@ module GraphQL
 
         def inherited(subclass)
           super
+          parent_class = self
           subclass.class_exec do
             @default_graphql_name ||= nil
+            @locations = parent_class.locations
+            @is_runtime = parent_class.runtime?
+            @repeatable = false
           end
         end
       end
@@ -177,13 +189,16 @@ module GraphQL
       end
 
       LOCATIONS = [
-        QUERY =                  :QUERY,
-        MUTATION =               :MUTATION,
-        SUBSCRIPTION =           :SUBSCRIPTION,
-        FIELD =                  :FIELD,
-        FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
-        FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
-        INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+        *(RUNTIME_LOCATIONS = [
+          QUERY =                  :QUERY,
+          MUTATION =               :MUTATION,
+          SUBSCRIPTION =           :SUBSCRIPTION,
+          FIELD =                  :FIELD,
+          FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
+          FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
+          INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+          VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
+        ]),
         SCHEMA =                 :SCHEMA,
         SCALAR =                 :SCALAR,
         OBJECT =                 :OBJECT,
@@ -195,7 +210,6 @@ module GraphQL
         ENUM_VALUE =             :ENUM_VALUE,
         INPUT_OBJECT =           :INPUT_OBJECT,
         INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
-        VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
       ]
 
       DEFAULT_DEPRECATION_REASON = 'No longer supported'

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

@@ -12,22 +12,13 @@ module GraphQL
         end
 
         # Remove pagination args before passing it to a user method
-        def resolve(object:, arguments:, context:)
+        def resolve(object: nil, objects: nil, arguments:, context:)
           next_args = arguments.dup
           next_args.delete(:first)
           next_args.delete(:last)
           next_args.delete(:before)
           next_args.delete(:after)
-          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)
+          yield(object || objects, next_args, arguments)
         end
 
         def after_resolve(value:, object:, arguments:, context:, memo:)
@@ -36,10 +27,6 @@ module GraphQL
             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

@@ -28,10 +28,6 @@ module GraphQL
             value
           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.rb

@@ -270,32 +270,32 @@ module GraphQL
         @resolver_method = (resolver_method || name_s).to_sym
 
         if resolve_static
-          @execution_next_mode = :resolve_static
-          @execution_next_mode_key = resolve_static == true ? @method_sym : resolve_static
+          @execution_mode = :resolve_static
+          @execution_mode_key = resolve_static == true ? @method_sym : resolve_static
         elsif resolve_batch
-          @execution_next_mode = :resolve_batch
-          @execution_next_mode_key = resolve_batch == true ? @method_sym : resolve_batch
+          @execution_mode = :resolve_batch
+          @execution_mode_key = resolve_batch == true ? @method_sym : resolve_batch
         elsif resolve_each
-          @execution_next_mode = :resolve_each
-          @execution_next_mode_key = resolve_each == true ? @method_sym : resolve_each
+          @execution_mode = :resolve_each
+          @execution_mode_key = resolve_each == true ? @method_sym : resolve_each
         elsif hash_key
-          @execution_next_mode = :hash_key
-          @execution_next_mode_key = hash_key
+          @execution_mode = :hash_key
+          @execution_mode_key = hash_key
         elsif dig
-          @execution_next_mode = :dig
-          @execution_next_mode_key = dig
+          @execution_mode = :dig
+          @execution_mode_key = dig
         elsif resolver_class
-          @execution_next_mode = :resolver_class
-          @execution_next_mode_key = resolver_class
+          @execution_mode = :resolver_class
+          @execution_mode_key = resolver_class
         elsif resolve_legacy_instance_method
-          @execution_next_mode = :resolve_legacy_instance_method
-          @execution_next_mode_key = resolve_legacy_instance_method == true ? @method_sym : resolve_legacy_instance_method
+          @execution_mode = :resolve_legacy_instance_method
+          @execution_mode_key = resolve_legacy_instance_method == true ? @method_sym : resolve_legacy_instance_method
         elsif dataload
-          @execution_next_mode = :dataload
-          @execution_next_mode_key = dataload
+          @execution_mode = :dataload
+          @execution_mode_key = dataload
         else
-          @execution_next_mode = :direct_send
-          @execution_next_mode_key = @method_sym
+          @execution_mode = :direct_send
+          @execution_mode_key = @method_sym
         end
 
         @complexity = complexity
@@ -369,7 +369,7 @@ module GraphQL
       end
 
       # @api private
-      attr_reader :execution_next_mode_key, :execution_next_mode
+      attr_reader :execution_mode_key, :execution_mode
 
       # Calls the definition block, if one was given.
       # This is deferred so that references to the return type
@@ -665,10 +665,9 @@ module GraphQL
       end
 
       def authorizes?(context)
-        method(:authorized?).owner != GraphQL::Schema::Field || (
-          (args = context.types.arguments(self)) &&
-            (args.any? { |a| a.authorizes?(context) })
-        )
+        method(:authorized?).owner != GraphQL::Schema::Field ||
+          ((args = context.types.arguments(self)) && (args.any? { |a| a.authorizes?(context) })) ||
+          (@resolver_class&.authorizes?(context)) || false
       end
 
       def authorized?(object, args, context)
@@ -930,7 +929,7 @@ ERR
       def run_next_extensions_before_resolve(objs, args, ctx, extended, idx: 0, &block)
         extension = @extensions[idx]
         if extension
-          extension.resolve_next(objects: objs, arguments: args, context: ctx) do |extended_objs, extended_args, memo|
+          extension.resolve(objects: objs, arguments: args, context: ctx) do |extended_objs, extended_args, memo|
             if memo
               memos = extended.memos ||= {}
               memos[idx] = memo

data/lib/graphql/schema/field_extension.rb

@@ -123,33 +123,16 @@ module GraphQL
       #
       # Whatever this method returns will be used for execution.
       #
-      # @param object [Object] The object the field is being resolved on
+      # @param object [Object] The object the field is being resolved on (not passed by new execution)
+      # @param objects [Array<Object>] The objects the field is being resolved on (passed by new execution)
       # @param arguments [Hash] Ruby keyword arguments for resolving this field
       # @param context [Query::Context] the context for this query
-      # @yieldparam object [Object] The object to continue resolving the field on
+      # @yieldparam object_or_objects [Object, Array<Object>] The object or objects (new execution) to continue resolving the field on
       # @yieldparam arguments [Hash] The keyword arguments to continue resolving with
       # @yieldparam memo [Object] Any extension-specific value which will be passed to {#after_resolve} later
       # @return [Object] The return value for this field.
-      def resolve(object:, arguments:, context:)
-        yield(object, arguments, nil)
-      end
-
-      # Called before batch-resolving {#field}. It should either:
-      #
-      # - `yield` values to continue execution; OR
-      # - return something else to shortcut field execution.
-      #
-      # Whatever this method returns will be used for execution.
-      #
-      # @param objects [Array<Object>] The objects the field is being resolved on
-      # @param arguments [Hash] Ruby keyword arguments for resolving this field
-      # @param context [Query::Context] the context for this query
-      # @yieldparam objects [Array<Object>] The objects to continue resolving the field on. Length must be the same as passed-in `objects:`
-      # @yieldparam arguments [Hash] The keyword arguments to continue resolving with
-      # @yieldparam memo [Object] Any extension-specific value which will be passed to {#after_resolve} later
-      # @return [Array<Object>] The return value for this field, length matching passed-in `objects:`.
-      def resolve_next(objects:, arguments:, context:)
-        yield(objects, arguments, nil)
+      def resolve(object: nil, objects: nil, arguments:, context:)
+        yield(object || objects, arguments, nil)
       end
 
       # Called after {#field} was resolved, and after any lazy values (like `Promise`s) were synced,
@@ -157,29 +140,16 @@ module GraphQL
       #
       # Whatever this hook returns will be used as the return value.
       #
-      # @param object [Object] The object the field is being resolved on
+      # @param object [Object] The object the field is being resolved on (not passed by new execution)
+      # @param objects [Array<Object>] The object the field is being resolved on (passed by new execution)
       # @param arguments [Hash] Ruby keyword arguments for resolving this field
       # @param context [Query::Context] the context for this query
-      # @param value [Object] Whatever the field previously returned
+      # @param value [Object] Whatever the field previously returned (not passed by new execution)
+      # @param values [Array<Object>] Whatever the field previously returned (passed by new execution)
       # @param memo [Object] The third value yielded by {#resolve}, or `nil` if there wasn't one
       # @return [Object] The return value for this field.
-      def after_resolve(object:, arguments:, context:, value:, memo:)
-        value
-      end
-
-      # Called after {#field} was batch-resolved, and after any lazy values (like `Promise`s) were synced,
-      # but before the value was added to the GraphQL response.
-      #
-      # Whatever this hook returns will be used as the return value.
-      #
-      # @param objects [Array<Object>] The objects the field is being resolved on
-      # @param arguments [Hash] Ruby keyword arguments for resolving this field
-      # @param context [Query::Context] the context for this query
-      # @param values [Array<Object>] Whatever the field returned, one for each of `objects`
-      # @param memo [Object] The third value yielded by {#resolve}, or `nil` if there wasn't one
-      # @return [Array<Object>] The return values for this field, length matching `objects:`.
-      def after_resolve_next(objects:, arguments:, context:, values:, memo:)
-        values
+      def after_resolve(object: nil, objects: nil, arguments:, context:, values: nil, value: nil, memo:)
+        value || values
       end
     end
   end

data/lib/graphql/schema/interface.rb

@@ -33,6 +33,26 @@ module GraphQL
           self::DefinitionMethods.module_exec(&block)
         end
 
+        # Instance methods defined in this block will become class methods on objects that implement this interface.
+        # Use it to implement `resolve_each:`, `resolve_batch:`, and `resolve_static:` fields.
+        # @example
+        #   field :thing, String, resolve_static: true
+        #
+        #   resolver_methods do
+        #     def thing
+        #       Somehow.get.thing
+        #     end
+        #   end
+        def resolver_methods(&block)
+          if !defined?(@_resolver_methods)
+            resolver_methods_module = Module.new
+            @_resolver_methods = resolver_methods_module
+            const_set(:ResolverMethods, resolver_methods_module)
+            extend(self::ResolverMethods)
+          end
+          self::ResolverMethods.module_exec(&block)
+        end
+
         # @see {Schema::Warden} hides interfaces without visible implementations
         def visible?(context)
           true
@@ -79,6 +99,12 @@ module GraphQL
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end
+
+            child_class.ancestors.reverse_each do |ancestor|
+              if ancestor.const_defined?(:ResolverMethods)
+                child_class.extend(ancestor::ResolverMethods)
+              end
+            end
           end
 
           super

data/lib/graphql/schema/list.rb

@@ -19,7 +19,11 @@ module GraphQL
       end
 
       def to_type_signature
-        "[#{@of_type.to_type_signature}]"
+        @type_signature ||= -"[#{@of_type.to_type_signature}]"
+      end
+
+      def authorizes?(ctx)
+        of_type.authorizes?(ctx)
       end
 
       # This is for introspection, where it's expected the name will be `null`

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -26,16 +26,6 @@ module GraphQL
           end
         end
 
-        # Just a convenience method to point out that people should use graphql_name instead
-        def name(new_name = nil)
-          return super() if new_name.nil?
-
-          fail(
-            "The new name override method is `graphql_name`, not `name`. Usage: "\
-            "graphql_name \"#{new_name}\""
-          )
-        end
-
         # Call this method to provide a new description; OR
         # call it without an argument to get the description
         # @param new_description [String]

data/lib/graphql/schema/member/has_fields.rb

@@ -150,10 +150,14 @@ module GraphQL
 
         def global_id_field(field_name, **kwargs)
           type = self
-          field field_name, "ID", **kwargs, null: false
+          field field_name, "ID", **kwargs, null: false, resolve_each: true
           define_method(field_name) do
             context.schema.id_from_object(object, type, context)
           end
+
+          define_singleton_method(field_name) do |object, context|
+            context.schema.id_from_object(object, type, context)
+          end
         end
 
         # @param new_has_no_fields [Boolean] Call with `true` to make this Object type ignore the requirement to have any defined fields.

data/lib/graphql/schema/non_null.rb

@@ -24,7 +24,7 @@ module GraphQL
       end
 
       def to_type_signature
-        "#{@of_type.to_type_signature}!"
+        @type_signature ||= -"#{@of_type.to_type_signature}!"
       end
 
       def inspect

data/lib/graphql/schema/resolver.rb

@@ -46,7 +46,7 @@ module GraphQL
         @prepared_arguments = nil
       end
 
-      attr_accessor :exec_result, :exec_index, :field_resolve_step
+      attr_accessor :exec_result, :exec_index, :field_resolve_step, :raw_arguments
 
       # @return [Object] The application object this field is being resolved on
       attr_accessor :object
@@ -66,7 +66,12 @@ module GraphQL
         q = context.query
         trace_objs = [object]
         q.current_trace.begin_execute_field(field, @prepared_arguments, trace_objs, q)
-        is_authed, new_return_value = authorized?(**@prepared_arguments)
+        begin
+          is_authed, new_return_value = authorized?(**@prepared_arguments)
+        rescue GraphQL::UnauthorizedError  => err
+          new_return_value = q.schema.unauthorized_object(err)
+          is_authed = true # the error was handled
+        end
 
         if (runner = @field_resolve_step.runner).resolves_lazies && runner.schema.lazy?(is_authed)
           is_authed, new_return_value = runner.schema.sync_lazy(is_authed)
@@ -74,13 +79,19 @@ module GraphQL
 
         result = if is_authed
           Schema::Validator.validate!(self.class.validators, object, context, @prepared_arguments, as: @field)
+          if q.subscription? && @field.owner == context.schema.subscription
+            # This needs to use arguments without `loads:`. TODO extract this into subscription-related code somehow?
+            @original_arguments = @field_resolve_step.runner.input_values[q].argument_values(@field, @field_resolve_step.ast_node.arguments, nil)
+          end
           call_resolve(@prepared_arguments)
+        elsif new_return_value.nil?
+          err = UnauthorizedFieldError.new(object: object, type: @field_resolve_step.parent_type, context: context, field: @field)
+          context.schema.unauthorized_field(err)
         else
           new_return_value
         end
         q = context.query
         q.current_trace.end_execute_field(field, @prepared_arguments, trace_objs, q, [result])
-
         exec_result[exec_index] = result
       rescue RuntimeError => err
         exec_result[exec_index] = err
@@ -198,6 +209,10 @@ module GraphQL
         authorize_arguments(args, inputs)
       end
 
+      def self.authorizes?(context)
+        self.instance_method(:authorized?).owner != GraphQL::Schema::Resolver
+      end
+
       # Called when an object loaded by `loads:` fails the `.authorized?` check for its resolved GraphQL object type.
       #
       # By default, the error is re-raised and passed along to {{Schema.unauthorized_object}}.

data/lib/graphql/schema/subscription.rb

@@ -15,8 +15,6 @@ module GraphQL
       extend GraphQL::Schema::Resolver::HasPayloadType
       extend GraphQL::Schema::Member::HasFields
       NO_UPDATE = :no_update
-      # The generated payload type is required; If there's no payload,
-      # propagate null.
       null false
 
       # @api private