graphql 2.5.11 → 2.6.10

data/lib/graphql/execution/selections_step.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class SelectionsStep
+      def initialize(parent_type:, field_resolve_step:, selections:, objects:, results:, runner:, query:, path:, clobber: true)
+        @path = path
+        @field_resolve_step = field_resolve_step
+        @parent_type = parent_type
+        @selections = selections
+        @runner = runner
+        @objects = objects
+        @results = results
+        @query = query
+        @graphql_objects = nil
+        @all_selections = nil
+        @killed = false
+        @clobber = clobber
+      end
+
+      attr_reader :path, :query, :objects, :results, :field_resolve_step
+
+      attr_accessor :killed
+
+      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, _errors = @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
+
+          i += 2
+        end
+
+        continue_selections.each do |frs|
+          @runner.add_step(frs)
+        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,20 @@ 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)
+        case result_data
+        when Hash
+          result_data.delete(key)
+        when Array
+          result_data.delete_at(key)
+        else
+          raise "Unexpected result data #{result_data.class}: #{result_data}"
+        end
+      end
+    end
   end
 end

data/lib/graphql/execution_error.rb

@@ -3,10 +3,7 @@ module GraphQL
   # If a field's resolve function returns a {ExecutionError},
   # the error will be inserted into the response's `"errors"` key
   # and the field will resolve to `nil`.
-  class ExecutionError < GraphQL::Error
-    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
-    attr_accessor :ast_node
-
+  class ExecutionError < GraphQL::RuntimeError
     # @return [String] an array describing the JSON-path into the execution
     # response which corresponds to this error.
     attr_accessor :path
@@ -21,25 +18,33 @@ module GraphQL
     # under the `extensions` key.
     attr_accessor :extensions
 
-    def initialize(message, ast_node: nil, options: nil, extensions: nil)
-      @ast_node = ast_node
+    def initialize(message, ast_node: nil, ast_nodes: nil, options: nil, extensions: nil)
+      @ast_nodes = ast_nodes || [ast_node]
       @options = options
       @extensions = extensions
       super(message)
     end
 
+    def finalize_graphql_result(query, result_data, key)
+      add_this_error = !query.context.errors.any? { |e| e.eql?(self) }
+      if add_this_error
+        query.context.add_error(self)
+      end
+      if ast_node.is_a?(GraphQL::Language::Nodes::Directive)
+        # This is for backwards compatibility ... what does the spec say?
+        result_data.delete(key)
+      else
+        result_data[key] = nil
+      end
+    end
+
     # @return [Hash] An entry for the response's "errors" key
     def to_h
       hash = {
         "message" => message,
       }
       if ast_node
-        hash["locations"] = [
-          {
-            "line" => ast_node.line,
-            "column" => ast_node.col,
-          }
-        ]
+        hash["locations"] = @ast_nodes.map { |a| { "line" => a.line, "column" => a.col } }
       end
       if path
         hash["path"] = path

data/lib/graphql/float_decoding_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Float` is given a non-finite input value.
+  class FloatDecodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be decoded
+    attr_reader :float_value
+
+    def initialize(value)
+      @float_value = value
+      super("Float is not finite: #{value.inspect}.")
+    end
+  end
+end

data/lib/graphql/float_encoding_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Float` is asked to return a non-finite value.
+  class FloatEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :float_value
+
+    # @return [GraphQL::Schema::Field] The field that returned a non-finite float
+    attr_reader :field
+
+    # @return [Array<String, Integer>] Where the field appeared in the GraphQL response
+    attr_reader :path
+
+    def initialize(value, context:)
+      @float_value = value
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "Float is not finite: #{value.inspect}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      super("#{message}.")
+    end
+  end
+end

data/lib/graphql/introspection/directive_type.rb

@@ -12,7 +12,7 @@ module GraphQL
       field :name, String, null: false, method: :graphql_name
       field :description, String
       field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false, scope: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false, resolve_each: :resolve_args do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?
@@ -21,11 +21,15 @@ module GraphQL
 
       field :is_repeatable, Boolean, method: :repeatable?
 
-      def args(include_deprecated:)
-        args = @context.types.arguments(@object)
+      def self.resolve_args(object, context, include_deprecated:)
+        args = context.types.arguments(object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end
+
+      def args(include_deprecated:)
+        self.class.resolve_args(object, context, include_deprecated: include_deprecated)
+      end
     end
   end
 end

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

@@ -2,19 +2,27 @@
 module GraphQL
   module Introspection
     class EntryPoints < Introspection::BaseObject
-      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false, dynamic_introspection: true
-      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true do
+      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false, dynamic_introspection: true, resolve_static: true
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true, resolve_static: true do
         argument :name, String
       end
 
-      def __schema
+      def self.__schema(context)
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = context.schema
         schema_type = schema.introspection_system.types["__Schema"]
         schema_type.wrap(schema, context)
       end
 
+      def __schema
+        self.class.__schema(context)
+      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/introspection/enum_value_type.rb

@@ -6,17 +6,17 @@ module GraphQL
       description "One possible value for a given Enum. Enum values are unique values, not a "\
                   "placeholder for a string or numeric value. However an Enum value is returned in "\
                   "a JSON response as a string."
-      field :name, String, null: false
+      field :name, String, null: false, method: :graphql_name
       field :description, String
-      field :is_deprecated, Boolean, null: false
+      field :is_deprecated, Boolean, null: false, resolve_each: :resolve_is_deprecated
       field :deprecation_reason, String
 
-      def name
-        object.graphql_name
+      def self.resolve_is_deprecated(object, context)
+        !!object.deprecation_reason
       end
 
       def is_deprecated
-        !!@object.deprecation_reason
+        self.class.resolve_is_deprecated(object, context)
       end
     end
   end

data/lib/graphql/introspection/field_type.rb

@@ -7,22 +7,30 @@ module GraphQL
                   "a name, potentially a list of arguments, and a return type."
       field :name, String, null: false
       field :description, String
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false, resolve_each: :resolve_args do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
-      field :is_deprecated, Boolean, null: false
+      field :is_deprecated, Boolean, null: false, resolve_each: :resolve_is_deprecated
       field :deprecation_reason, String
 
+      def self.resolve_is_deprecated(object, _context)
+        !!object.deprecation_reason
+      end
+
       def is_deprecated
-        !!@object.deprecation_reason
+        self.class.resolve_is_deprecated(object, context)
       end
 
-      def args(include_deprecated:)
-        args = @context.types.arguments(@object)
+      def self.resolve_args(object, context, include_deprecated:)
+        args = context.types.arguments(object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end
+
+      def args(include_deprecated:)
+        self.class.resolve_args(object, context, include_deprecated: include_deprecated)
+      end
     end
   end
 end

data/lib/graphql/introspection/input_value_type.rb

@@ -9,53 +9,61 @@ module GraphQL
       field :name, String, null: false
       field :description, String
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
-      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value."
-      field :is_deprecated, Boolean, null: false
+      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value.", resolve_each: :resolve_default_value
+      field :is_deprecated, Boolean, null: false, resolve_each: :resolve_is_deprecated
       field :deprecation_reason, String
 
+      def self.resolve_is_deprecated(object, context)
+        !!object.deprecation_reason
+      end
+
       def is_deprecated
-        !!@object.deprecation_reason
+        self.class.resolve_is_deprecated(object, context)
       end
 
-      def default_value
-        if @object.default_value?
-          value = @object.default_value
+      def self.resolve_default_value(object, context)
+        if object.default_value?
+          value = object.default_value
           if value.nil?
             'null'
           else
-            if (@object.type.kind.list? || (@object.type.kind.non_null? && @object.type.of_type.kind.list?)) && !value.respond_to?(:map)
+            if (object.type.kind.list? || (object.type.kind.non_null? && object.type.of_type.kind.list?)) && !value.respond_to?(:map)
               # This is a bit odd -- we expect the default value to be an application-style value, so we use coerce result below.
               # But coerce_result doesn't wrap single-item lists, which are valid inputs to list types.
               # So, apply that wrapper here if needed.
               value = [value]
             end
-            coerced_default_value = @object.type.coerce_result(value, @context)
-            serialize_default_value(coerced_default_value, @object.type)
+            coerced_default_value = object.type.coerce_result(value, context)
+            serialize_default_value(coerced_default_value, object.type, context)
           end
         else
           nil
         end
       end
 
+      def default_value
+        self.class.resolve_default_value(object, context)
+      end
+
 
       private
 
       # Recursively serialize, taking care not to add quotes to enum values
-      def serialize_default_value(value, type)
+      def self.serialize_default_value(value, type, context)
         if value.nil?
           'null'
         elsif type.kind.list?
           inner_type = type.of_type
-          "[" + value.map { |v| serialize_default_value(v, inner_type) }.join(", ") + "]"
+          "[" + value.map { |v| serialize_default_value(v, inner_type, context) }.join(", ") + "]"
         elsif type.kind.non_null?
-          serialize_default_value(value, type.of_type)
+          serialize_default_value(value, type.of_type, context)
         elsif type.kind.enum?
           value
         elsif type.kind.input_object?
           "{" +
             value.map do |k, v|
               arg_defn = type.get_argument(k, context)
-              "#{k}: #{serialize_default_value(v, arg_defn.type)}"
+              "#{k}: #{serialize_default_value(v, arg_defn.type, context)}"
             end.join(", ") +
             "}"
         else

data/lib/graphql/introspection/schema_type.rb

@@ -13,12 +13,16 @@ module GraphQL
       field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at."
       field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at."
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false, scope: false
-      field :description, String, resolver_method: :schema_description
+      field :description, String, resolver_method: :schema_description, resolve_static: :schema_description
 
-      def schema_description
+      def self.schema_description(context)
         context.schema.description
       end
 
+      def schema_description
+        self.class.schema_description(context)
+      end
+
       def types
         query_types = context.types.all_types
         types = query_types + context.schema.extra_types

data/lib/graphql/introspection/type_type.rb

@@ -11,32 +11,36 @@ module GraphQL
                   "they describe. Abstract types, Union and Interface, provide the Object types "\
                   "possible at runtime. List and NonNull types compose other types."
 
-      field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
+      field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false, resolve_each: :resolve_kind
       field :name, String, method: :graphql_name
       field :description, String
-      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false do
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false, resolve_each: :resolve_fields do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
-      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
-      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false do
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false, resolve_each: :resolve_interfaces
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false, resolve_each: :resolve_possible_types
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false, resolve_each: :resolve_enum_values do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false  do
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false, resolve_each: :resolve_input_fields  do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
+      field :of_type, GraphQL::Schema::LateBoundType.new("__Type"), resolve_each: :resolve_of_type
 
-      field :specifiedByURL, String, resolver_method: :specified_by_url
+      field :specifiedByURL, String, resolve_each: :resolve_specified_by_url, resolver_method: :specified_by_url
 
-      field :is_one_of, Boolean, null: false
+      field :is_one_of, Boolean, null: false, resolve_each: :resolve_is_one_of
 
-      def is_one_of
+      def self.resolve_is_one_of(object, _ctx)
         object.kind.input_object? &&
           object.directives.any? { |d| d.graphql_name == "oneOf" }
       end
 
-      def specified_by_url
+      def is_one_of
+        self.class.resolve_is_one_of(object, context)
+      end
+
+      def self.resolve_specified_by_url(object, _ctx)
         if object.kind.scalar?
           object.specified_by_url
         else
@@ -44,15 +48,23 @@ module GraphQL
         end
       end
 
+      def specified_by_url
+        self.class.resolve_specified_by_url(object, context)
+      end
+
+      def self.resolve_kind(object, context)
+        object.kind.name
+      end
+
       def kind
-        @object.kind.name
+        self.class.resolve_kind(object, context)
       end
 
-      def enum_values(include_deprecated:)
-        if !@object.kind.enum?
+      def self.resolve_enum_values(object, context, include_deprecated:)
+        if !object.kind.enum?
           nil
         else
-          enum_values = @context.types.enum_values(@object)
+          enum_values = context.types.enum_values(object)
 
           if !include_deprecated
             enum_values = enum_values.select {|f| !f.deprecation_reason }
@@ -62,17 +74,25 @@ module GraphQL
         end
       end
 
-      def interfaces
-        if @object.kind.object? || @object.kind.interface?
-          @context.types.interfaces(@object).sort_by(&:graphql_name)
+      def enum_values(include_deprecated:)
+        self.class.resolve_enum_values(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_interfaces(object, context)
+        if object.kind.object? || object.kind.interface?
+          context.types.interfaces(object).sort_by(&:graphql_name)
         else
           nil
         end
       end
 
-      def input_fields(include_deprecated:)
-        if @object.kind.input_object?
-          args = @context.types.arguments(@object)
+      def interfaces
+        self.class.resolve_interfaces(object, context)
+      end
+
+      def self.resolve_input_fields(object, context, include_deprecated:)
+        if object.kind.input_object?
+          args = context.types.arguments(object)
           args = args.reject(&:deprecation_reason) unless include_deprecated
           args
         else
@@ -80,19 +100,27 @@ module GraphQL
         end
       end
 
-      def possible_types
-        if @object.kind.abstract?
-          @context.types.possible_types(@object).sort_by(&:graphql_name)
+      def input_fields(include_deprecated:)
+        self.class.resolve_input_fields(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_possible_types(object, context)
+        if object.kind.abstract?
+          context.types.possible_types(object).sort_by(&:graphql_name)
         else
           nil
         end
       end
 
-      def fields(include_deprecated:)
-        if !@object.kind.fields?
+      def possible_types
+        self.class.resolve_possible_types(object, context)
+      end
+
+      def self.resolve_fields(object, context, include_deprecated:)
+        if !object.kind.fields?
           nil
         else
-          fields = @context.types.fields(@object)
+          fields = context.types.fields(object)
           if !include_deprecated
             fields = fields.select {|f| !f.deprecation_reason }
           end
@@ -100,8 +128,16 @@ module GraphQL
         end
       end
 
+      def fields(include_deprecated:)
+        self.class.resolve_fields(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_of_type(object, _ctx)
+        object.kind.wraps? ? object.of_type : nil
+      end
+
       def of_type
-        @object.kind.wraps? ? @object.of_type : nil
+        self.class.resolve_of_type(object, context)
       end
     end
   end

data/lib/graphql/invalid_null_error.rb

@@ -2,7 +2,7 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::Error
+  class InvalidNullError < GraphQL::RuntimeError
     # @return [GraphQL::BaseType] The owner of {#field}
     attr_reader :parent_type
 
@@ -10,17 +10,23 @@ module GraphQL
     attr_reader :field
 
     # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
-    attr_reader :ast_node
+    def ast_node
+      @ast_nodes.first
+    end
+
+    attr_reader :ast_nodes
 
     # @return [Boolean] indicates an array result caused the error
     attr_reader :is_from_array
 
-    def initialize(parent_type, field, ast_node, is_from_array: false)
+    attr_accessor :path
+
+    def initialize(parent_type, field, ast_node_or_nodes, is_from_array: false, path: nil)
       @parent_type = parent_type
       @field = field
-      @ast_node = ast_node
+      @ast_nodes = Array(ast_node_or_nodes)
       @is_from_array = is_from_array
-
+      @path = path
       # For List elements, identify the non-null error is for an
       # element and the required element type so it's not ambiguous
       # whether it was caused by a null instead of the list or a