graphql 2.5.19 → 2.5.21

data/lib/graphql/execution_error.rb

@@ -3,9 +3,17 @@ 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
+  class ExecutionError < GraphQL::RuntimeError
     # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
-    attr_accessor :ast_node
+    def ast_node
+      ast_nodes.first
+    end
+
+    def ast_node=(new_node)
+      @ast_nodes = [new_node]
+    end
+
+    attr_accessor :ast_nodes
 
     # @return [String] an array describing the JSON-path into the execution
     # response which corresponds to this error.
@@ -21,8 +29,8 @@ 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)
@@ -34,12 +42,7 @@ module GraphQL
         "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/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: :__schema
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true, resolve_static: :__type 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/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

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

@@ -29,6 +29,7 @@ module GraphQL
       end
 
       extend Forwardable
+      include Schema::Member::HasDataloader
 
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
@@ -118,8 +119,8 @@ module GraphQL
       # @param error [GraphQL::ExecutionError] an execution error
       # @return [void]
       def add_error(error)
-        if !error.is_a?(ExecutionError)
-          raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+        if !error.is_a?(GraphQL::RuntimeError)
+          raise TypeError, "expected error to be a GraphQL::RuntimeError, but was #{error.class}"
         end
         errors << error
         nil

data/lib/graphql/query/null_context.rb

@@ -4,7 +4,13 @@ module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
     class NullContext < Context
-      include Singleton
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def self.instance=(new_inst)
+        @instance = new_inst
+      end
 
       class NullQuery
         def after_lazy(value)
@@ -20,10 +26,10 @@ module GraphQL
       attr_reader :schema, :query, :warden, :dataloader
       def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?, :to_h
 
-      def initialize
+      def initialize(schema: NullSchema)
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
-        @schema = NullSchema
+        @schema = schema
         @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
         @types = @warden.visibility_profile
         freeze

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
@@ -164,6 +165,10 @@ module GraphQL
         true
       end
 
+      def authorizes?(_context)
+        self.method(:authorized?).owner != GraphQL::Schema::Argument
+      end
+
       def authorized?(obj, value, ctx)
         authorized_as_type?(obj, value, ctx, as_type: type)
       end

data/lib/graphql/schema/build_from_definition.rb

@@ -512,6 +512,7 @@ module GraphQL
               camelize: false,
               directives: prepare_directives(field_definition, type_resolver),
               resolver_method: resolve_method_name,
+              resolve_batch: resolve_method_name,
             )
 
             builder.build_arguments(schema_field_defn, field_definition.arguments, type_resolver)
@@ -528,6 +529,12 @@ module GraphQL
             field_instance = context.types.field(owner, field_name)
             context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
           }
+          owner.define_singleton_method(method_name) { |objects, context, **args|
+            field_instance = context.types.field(owner, field_name)
+            objects.map do |object|
+              context.schema.definition_default_resolve.call(self, field_instance, object, args, context)
+            end
+          }
         end
 
         def build_resolve_type(lookup_hash, directives, missing_type_handler)

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

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