graphql 2.5.20 → 2.6.0

data/lib/graphql/execution/selections_step.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class SelectionsStep
+      def initialize(parent_type:, selections:, objects:, results:, runner:, query:, path:, clobber: true)
+        @path = path
+        @parent_type = parent_type
+        @selections = selections
+        @runner = runner
+        @objects = objects
+        @results = results
+        @query = query
+        @graphql_objects = nil
+        @all_selections = nil
+        @clobber = clobber
+      end
+
+      attr_reader :path, :query, :objects, :results
+
+      def graphql_objects
+        @graphql_objects ||= @objects.map do |obj|
+          @parent_type.scoped_new(obj, @query.context)
+        end
+      end
+
+      def call
+        @all_selections = [{}, (prototype_result = {})]
+        @runner.gather_selections(@parent_type, @selections, self, self.query, @all_selections, @all_selections[1], into: @all_selections[0])
+        continue_selections = []
+        i = 0
+        l = @all_selections.length
+        while i < l
+          grouped_selections = @all_selections[i]
+          selections_prototype_result = @all_selections[i + 1]
+          if (directives_owner = grouped_selections.delete(:__node))
+            directives = directives_owner.directives
+            continue_execution = true
+            directives.each do |dir_node|
+              dir_defn = @runner.runtime_directives[dir_node.name]
+              if dir_defn # not present for `skip` or `include`
+                dir_args = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                result = case directives_owner
+                when Language::Nodes::FragmentSpread
+                  dir_defn.resolve_fragment_spread(directives_owner, @parent_type, @objects, dir_args, self.query.context)
+                when Language::Nodes::InlineFragment
+                  dir_defn.resolve_inline_fragment(directives_owner, @parent_type, @objects, dir_args, self.query.context)
+                else
+                  raise ArgumentError, "Unhandled directive owner (#{directives_owner.class}): #{directives_owner.inspect}"
+                end
+                if result.is_a?(Finalizer)
+                  result.path = path
+                  @results.each do |r|
+                    @runner.add_finalizer(@query, r, nil, result)
+                  end
+                  if result.is_a?(HaltExecution)
+                    continue_execution = false
+                    break
+                  end
+                end
+
+                if continue_execution
+                  prototype_result.merge!(selections_prototype_result)
+                  grouped_selections.each_value { |v| continue_selections << v }
+                end
+              else
+                grouped_selections.each_value { |v| continue_selections << v }
+              end
+            end
+          else
+            grouped_selections.each_value { |v| continue_selections << v }
+          end
+
+          if @clobber
+            i2 = 0
+            l2 = @results.length
+            while i2 < l2
+              @results[i2].replace(prototype_result)
+              i2 += 1
+            end
+          end
+
+          continue_selections.each do |frs|
+            @runner.add_step(frs)
+          end
+
+          i += 2
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "graphql/execution/directive_checks"
+require "graphql/execution/next"
 require "graphql/execution/interpreter"
 require "graphql/execution/lazy"
 require "graphql/execution/lookahead"
@@ -9,10 +10,13 @@ require "graphql/execution/errors"
 module GraphQL
   module Execution
     # @api private
-    class Skip < GraphQL::Error; end
+    class Skip < GraphQL::RuntimeError
+      attr_accessor :path
+      def ast_nodes=(_ignored); end
 
-    # Just a singleton for implementing {Query::Context#skip}
-    # @api private
-    SKIP = Skip.new
+      def finalize_graphql_result(query, result_data, key)
+        result_data.delete(key)
+      end
+    end
   end
 end

data/lib/graphql/execution_error.rb

@@ -6,7 +6,7 @@ module GraphQL
   class ExecutionError < GraphQL::RuntimeError
     # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
     def ast_node
-      ast_nodes.first
+      ast_nodes&.first
     end
 
     def ast_node=(new_node)
@@ -36,6 +36,10 @@ module GraphQL
       super(message)
     end
 
+    def finalize_graphql_result(query, result_data, key)
+      result_data[key] = nil
+    end
+
     # @return [Hash] An entry for the response's "errors" key
     def to_h
       hash = {

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/query/context.rb

@@ -112,7 +112,7 @@ module GraphQL
       # Return this value to tell the runtime
       # to exclude this field from the response altogether
       def skip
-        GraphQL::Execution::SKIP
+        GraphQL::Execution::Skip.new
       end
 
       # Add error at query-level.
@@ -126,6 +126,12 @@ module GraphQL
         nil
       end
 
+      # @param value [Object] Any object to be inserted directly into the final response
+      # @return [GraphQL::Execution::Interpreter::RawValue] Return this from the field
+      def raw_value(value)
+        GraphQL::Execution::Interpreter::RawValue.new(value)
+      end
+
       # @example Print the GraphQL backtrace during field resolution
       #   puts ctx.backtrace
       #

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/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

@@ -99,6 +99,16 @@ module GraphQL
               # It's possible that this was already loaded by the directives
               prev_type = types[definition.name]
               if prev_type.nil? || prev_type.is_a?(Schema::LateBoundType)
+                if definition.is_a?(GraphQL::Language::Nodes::ObjectTypeDefinition) || definition.is_a?(Language::Nodes::InterfaceTypeDefinition)
+                  interface_names = definition.interfaces.map(&:name)
+                  transitive_names = interface_names.map { |n| document.definitions.find { |d| d.respond_to?(:name) && d.name == n }&.interfaces&.map(&:name) }
+                  transitive_names.flatten!
+                  transitive_names.compact!
+                  if !(missing_transitive_interfaces = transitive_names - interface_names).empty?
+                    raise GraphQL::Schema::InvalidDocumentError, "type #{definition.name} is missing one or more transitive interface names: #{missing_transitive_interfaces.join(", ")}. Add them to the type's `implements` list and try again."
+                  end
+                end
+
                 types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve, base_types)
               end
             end
@@ -519,35 +529,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/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,52 +12,19 @@ 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)
+          yield(object || 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
       end

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

@@ -5,22 +5,27 @@ 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
       end