graphql 2.5.23 → 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
@@ -929,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

@@ -22,6 +22,10 @@ module GraphQL
         @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`
       def graphql_name
         nil

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/resolver.rb

@@ -80,8 +80,8 @@ 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:`
-            @original_arguments = @field_resolve_step.coerce_arguments(@field, @field_resolve_step.ast_node.arguments, false)
+            # 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?

data/lib/graphql/schema.rb

@@ -1362,14 +1362,6 @@ module GraphQL
         lazy_methods.set(lazy_class, value_method)
       end
 
-      def uses_raw_value?
-        !!@uses_raw_value
-      end
-
-      def uses_raw_value(new_val)
-        @uses_raw_value = new_val
-      end
-
       def resolves_lazies?
         lazy_method_count = 0
         lazy_methods.each do |k, v|
@@ -1450,7 +1442,16 @@ module GraphQL
       end
 
       def tracers
-        find_inherited_value(:tracers, EMPTY_ARRAY) + own_tracers
+        inherited = find_inherited_value(:tracers, EMPTY_ARRAY)
+        if inherited.length > 0
+          if own_tracers.length > 0
+            inherited + own_tracers
+          else
+            inherited
+          end
+        else
+          own_tracers
+        end
       end
 
       # Mix `trace_mod` into this schema's `Trace` class so that its methods will be called at runtime.
@@ -1560,7 +1561,8 @@ module GraphQL
       end
 
       def query_analyzers
-        find_inherited_value(:query_analyzers, EMPTY_ARRAY) + own_query_analyzers
+        inherited_qa = find_inherited_value(:query_analyzers, EMPTY_ARRAY)
+        inherited_qa.empty? ? own_query_analyzers : (inherited_qa + own_query_analyzers)
       end
 
       # @param new_analyzer [Class<GraphQL::Analysis::Analyzer>] An analyzer to run on multiplexes to this schema

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -2,41 +2,41 @@
 module GraphQL
   class Subscriptions
     class DefaultSubscriptionResolveExtension < GraphQL::Schema::FieldExtension
-      def resolve(context:, object:, arguments:)
-        has_override_implementation = @field.resolver ||
-          object.respond_to?(@field.resolver_method)
+      def resolve(context:, object: nil, objects: nil,  arguments:)
+        if objects
+          has_override_implementation = @field.execution_mode != :direct_send
 
-        if !has_override_implementation
-          if context.query.subscription_update?
-            object.object
+          if !has_override_implementation
+            if context.query.subscription_update?
+              objects
+            else
+              objects.map { |o| context.skip }
+            end
           else
-            context.skip
+            yield(objects, arguments)
           end
         else
-          yield(object, arguments)
-        end
-      end
+          has_override_implementation = @field.resolver ||
+            object.respond_to?(@field.resolver_method)
 
-      def resolve_next(context:, objects:, arguments:)
-        has_override_implementation = @field.execution_next_mode != :direct_send
-
-        if !has_override_implementation
-          if context.query.subscription_update?
-            objects
+          if !has_override_implementation
+            if context.query.subscription_update?
+              object.object
+            else
+              context.skip
+            end
           else
-            objects.map { |o| context.skip }
+            yield(object, arguments)
           end
-        else
-          yield(objects, arguments)
         end
       end
 
-      def after_resolve(value:, context:, object:, arguments:, **rest)
-        self.class.write_subscription(@field, value, arguments, context)
-      end
-
-      def after_resolve_next(values:, context:, objects:, arguments:, **rest)
-        values.map do |value|
+      def after_resolve(values: nil, value: nil, context:, objects: nil, object: nil, arguments:, **rest)
+        if values
+          values.map do |value|
+            self.class.write_subscription(@field, value, arguments, context)
+          end
+        else
           self.class.write_subscription(@field, value, arguments, context)
         end
       end

data/lib/graphql/subscriptions.rb

@@ -259,6 +259,21 @@ module GraphQL
       nil
     end
 
+    def finalizer
+      Finalizer.new(self)
+    end
+
+    class Finalizer
+      include Execution::Finalizer
+      def initialize(subscriptions)
+        @subscriptions = subscriptions
+      end
+
+      def finalize_graphql_result(query, result_data, result_key)
+        @subscriptions.finish_subscriptions(query)
+      end
+    end
+
     private
 
     # Recursively normalize `args` as belonging to `arg_owner`:

data/lib/graphql/tracing/trace.rb

@@ -98,6 +98,12 @@ module GraphQL
         yield
       end
 
+      def objects(type, object, context)
+      end
+
+      def object_loaded(argument_definition, object, context)
+      end
+
       # A call to `.authorized?` is starting
       # @param type [Class<GraphQL::Schema::Object>]
       # @param object [Object]

data/lib/graphql/unauthorized_error.rb

@@ -30,7 +30,7 @@ module GraphQL
 
     attr_accessor :path, :ast_nodes
 
-    def assign_graphql_result(query, result_data, key)
+    def finalize_graphql_result(query, result_data, key)
       result_data[key] = nil
     end
   end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.5.23"
+  VERSION = "2.5.24"
 end

data/lib/graphql.rb

@@ -21,9 +21,6 @@ module GraphQL
   class Error < StandardError
   end
 
-  class RuntimeError < Error
-  end
-
   # This error is raised when GraphQL-Ruby encounters a situation
   # that it *thought* would never happen. Please report this bug!
   class InvariantError < Error
@@ -122,6 +119,7 @@ This is probably a bug in GraphQL-Ruby, please report this error on GitHub: http
   autoload :ParseError, "graphql/parse_error"
   autoload :Backtrace, "graphql/backtrace"
 
+  autoload :RuntimeError, "graphql/runtime_error"
   autoload :UnauthorizedError, "graphql/unauthorized_error"
   autoload :UnauthorizedEnumValueError, "graphql/unauthorized_enum_value_error"
   autoload :UnauthorizedFieldError, "graphql/unauthorized_field_error"