graphql 1.9.18 → 1.13.24

data/lib/graphql/function.rb

@@ -1,36 +1,11 @@
 # frozen_string_literal: true
 module GraphQL
-  # A reusable container for field logic, including arguments, resolve, return type, and documentation.
-  #
-  # Class-level values defined with the DSL will be inherited,
-  # so {GraphQL::Function}s can extend one another.
-  #
-  # It's OK to override the instance methods here in order to customize behavior of instances.
-  #
-  # @example A reusable GraphQL::Function attached as a field
-  #   class FindRecord < GraphQL::Function
-  #     attr_reader :type
-  #
-  #     def initialize(model:, type:)
-  #       @model = model
-  #       @type = type
-  #     end
-  #
-  #     argument :id, GraphQL::ID_TYPE
-  #
-  #     def call(obj, args, ctx)
-  #        @model.find(args.id)
-  #     end
-  #   end
-  #
-  #   QueryType = GraphQL::ObjectType.define do
-  #     name "Query"
-  #     field :post, function: FindRecord.new(model: Post, type: PostType)
-  #     field :comment, function: FindRecord.new(model: Comment, type: CommentType)
-  #   end
-  #
-  # @see {GraphQL::Schema::Resolver} for a replacement for `GraphQL::Function`
+  # @api deprecated
   class Function
+    def self.inherited(subclass)
+      GraphQL::Deprecation.warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
+    end
+
     # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
     def arguments
       self.class.arguments

data/lib/graphql/id_type.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::ID_TYPE = GraphQL::Types::ID.graphql_definition
+GraphQL::ID_TYPE = GraphQL::Types::ID.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/input_object_type.rb

@@ -1,30 +1,10 @@
 # frozen_string_literal: true
 module GraphQL
-  # {InputObjectType}s are key-value inputs for fields.
-  #
-  # Input objects have _arguments_ which are identical to {GraphQL::Field} arguments.
-  # They map names to types and support default values.
-  # Their input types can be any input types, including {InputObjectType}s.
-  #
-  # @example An input type with name and number
-  #   PlayerInput = GraphQL::InputObjectType.define do
-  #     name("Player")
-  #     argument :name, !types.String
-  #     argument :number, !types.Int
-  #   end
-  #
-  # In a `resolve` function, you can access the values by making nested lookups on `args`.
-  #
-  # @example Accessing input values in a resolve function
-  #   resolve ->(obj, args, ctx) {
-  #     args[:player][:name]    # => "Tony Gwynn"
-  #     args[:player][:number]  # => 19
-  #     args[:player].to_h      # { "name" => "Tony Gwynn", "number" => 19 }
-  #     # ...
-  #   }
-  #
+  # @api deprecated
   class InputObjectType < GraphQL::BaseType
-    accepts_definitions(
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    deprecated_accepts_definitions(
       :arguments, :mutation,
       input_field: GraphQL::Define::AssignArgument,
       argument: GraphQL::Define::AssignArgument
@@ -80,6 +60,10 @@ module GraphQL
       result
     end
 
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
+
     private
 
     def coerce_non_null_input(value, ctx)
@@ -136,7 +120,7 @@ module GraphQL
       # Items in the input that are unexpected
       input.each do |name, value|
         if visible_arguments_map[name].nil?
-          result.add_problem("Field is not defined on #{self.name}", [name])
+          result.add_problem("Field is not defined on #{self.graphql_name}", [name])
         end
       end
 

data/lib/graphql/int_type.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::INT_TYPE = GraphQL::Types::Int.graphql_definition
+GraphQL::INT_TYPE = GraphQL::Types::Int.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/integer_decoding_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Int` is given an input value outside of 32-bit integer range.
+  #
+  # For really big integer values, consider `GraphQL::Types::BigInt`
+  #
+  # @see GraphQL::Types::Int which raises this error
+  class IntegerDecodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be decoded
+    attr_reader :integer_value
+
+    def initialize(value)
+      @integer_value = value
+      super("Integer out of bounds: #{value}. \nConsider using GraphQL::Types::BigInt instead.")
+    end
+  end
+end

data/lib/graphql/integer_encoding_error.rb

@@ -12,9 +12,25 @@ module GraphQL
     # The value which couldn't be encoded
     attr_reader :integer_value
 
-    def initialize(value)
+    # @return [GraphQL::Schema::Field] The field that returned a too-big integer
+    attr_reader :field
+
+    # @return [Array<String, Integer>] Where the field appeared in the GraphQL response
+    attr_reader :path
+
+    def initialize(value, context:)
       @integer_value = value
-      super("Integer out of bounds: #{value}. \nConsider using ID or GraphQL::Types::BigInt instead.")
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "Integer out of bounds: #{value}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      message << ". Consider using ID or GraphQL::Types::BigInt instead."
+      super(message)
     end
   end
 end

data/lib/graphql/interface_type.rb

@@ -1,31 +1,13 @@
 # frozen_string_literal: true
 module GraphQL
-  # An Interface contains a collection of types which implement some of the same fields.
-  #
-  # Interfaces can have fields, defined with `field`, just like an object type.
-  #
-  # Objects which implement this field _inherit_ field definitions from the interface.
-  # An object type can override the inherited definition by redefining that field.
-  #
-  # @example An interface with three fields
-  #   DeviceInterface = GraphQL::InterfaceType.define do
-  #     name("Device")
-  #     description("Hardware devices for computing")
-  #
-  #     field :ram, types.String
-  #     field :processor, ProcessorType
-  #     field :release_year, types.Int
-  #   end
-  #
-  # @example Implementing an interface with an object type
-  #   Laptoptype = GraphQL::ObjectType.define do
-  #     interfaces [DeviceInterface]
-  #   end
-  #
+  # @api deprecated
   class InterfaceType < GraphQL::BaseType
-    accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    deprecated_accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
 
     attr_accessor :fields, :orphan_types, :resolve_type_proc
+    attr_writer :type_membership_class
     ensure_defined :fields, :orphan_types, :resolve_type_proc, :resolve_type
 
     def initialize
@@ -71,7 +53,7 @@ module GraphQL
     # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and implements this {InterfaceType}, (else `nil`)
     def get_possible_type(type_name, ctx)
       type = ctx.query.get_type(type_name)
-      type if type && ctx.query.schema.possible_types(self).include?(type)
+      type if type && ctx.query.warden.possible_types(self).include?(type)
     end
 
     # Check if a type is a possible type of this {InterfaceType}
@@ -82,5 +64,9 @@ module GraphQL
       type_name = type.is_a?(String) ? type : type.graphql_name
       !get_possible_type(type_name, ctx).nil?
     end
+
+    def type_membership_class
+      @type_membership_class || GraphQL::Schema::TypeMembership
+    end
   end
 end

data/lib/graphql/internal_representation/document.rb

@@ -14,12 +14,12 @@ module GraphQL
       end
 
       def [](key)
-        warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
+        GraphQL::Deprecation.warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
         operation_definitions[key]
       end
 
       def each(&block)
-        warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
+        GraphQL::Deprecation.warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
         operation_definitions.each(&block)
       end
     end

data/lib/graphql/internal_representation/rewrite.rb

@@ -60,7 +60,7 @@ module GraphQL
 
       # @return [Hash<String, Node>] Roots of this query
       def operations
-        warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
+        GraphQL::Deprecation.warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
         @document.operation_definitions
       end
 

data/lib/graphql/internal_representation/scope.rb

@@ -66,11 +66,11 @@ module GraphQL
       # Call the block for each type in `self`.
       # This uses the simplest possible expression of `self`,
       # so if this scope is defined by an abstract type, it gets yielded.
-      def each
+      def each(&block)
         if @abstract_type
           yield(@type)
         else
-          @types.each { |t| yield(t) }
+          @types.each(&block)
         end
       end
 

data/lib/graphql/internal_representation/visit.rb

@@ -23,11 +23,11 @@ module GraphQL
 
       # Traverse a node in a rewritten query tree,
       # visiting the node itself and each of its typed children.
-      def each_node(node)
+      def each_node(node, &block)
         yield(node)
         node.typed_children.each do |obj_type, children|
           children.each do |name, node|
-            each_node(node) { |n| yield(n) }
+            each_node(node, &block)
           end
         end
       end

data/lib/graphql/introspection/base_object.rb

@@ -2,15 +2,12 @@
 module GraphQL
   module Introspection
     class BaseObject < GraphQL::Schema::Object
+      introspection(true)
+
       def self.field(*args, **kwargs, &block)
         kwargs[:introspection] = true
         super(*args, **kwargs, &block)
       end
-
-      def self.inherited(child_class)
-        child_class.introspection(true)
-        super
-      end
     end
   end
 end

data/lib/graphql/introspection/directive_location_enum.rb

@@ -6,8 +6,8 @@ module GraphQL
       description "A Directive can be adjacent to many parts of the GraphQL language, "\
                   "a __DirectiveLocation describes one such possible adjacencies."
 
-      GraphQL::Directive::LOCATIONS.each do |location|
-        value(location.to_s, GraphQL::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+      GraphQL::Schema::Directive::LOCATIONS.each do |location|
+        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location)
       end
       introspection true
     end

data/lib/graphql/introspection/directive_type.rb

@@ -9,16 +9,22 @@ module GraphQL
                   "in ways field arguments will not suffice, such as conditionally including or "\
                   "skipping a field. Directives provide this by describing additional information "\
                     "to the executor."
-      field :name, String, null: false
-      field :description, String, null: true
-      field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      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
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?
       field :on_fragment, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_fragment?
       field :on_field, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_field?
 
-      def args
-        @context.warden.arguments(@object)
+      field :is_repeatable, Boolean, method: :repeatable?
+
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
       end
     end
   end

data/lib/graphql/introspection/entry_points.rb

@@ -3,30 +3,30 @@ module GraphQL
   module Introspection
     class EntryPoints < Introspection::BaseObject
       field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false
-      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", null: true do
-        argument :name, String, required: true
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system" do
+        argument :name, String
       end
 
       def __schema
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = @context.query.schema
-        schema_type = schema.introspection_system.schema_type
-        schema_type.metadata[:type_class].authorized_new(schema, @context)
+        schema_type = schema.introspection_system.types["__Schema"]
+        schema_type.type_class.authorized_new(schema, @context)
       end
 
       def __type(name:)
         return unless context.warden.reachable_type?(name)
-
         type = context.warden.get_type(name)
-        if type && context.interpreter?
-          type = type.metadata[:type_class] || raise("Invariant: interpreter requires class-based type for #{name}")
+
+        if type && context.interpreter? && !type.is_a?(Module)
+          type = type.type_class || raise("Invariant: interpreter requires class-based type for #{name}")
         end
 
         # The interpreter provides this wrapping, other execution doesnt, so support both.
         if type && !context.interpreter?
           # Apply wrapping manually since this field isn't wrapped by instrumentation
-          type_type = context.schema.introspection_system.type_type
-          type = type_type.metadata[:type_class].authorized_new(type, context)
+          type_type = context.schema.introspection_system.types["__Type"]
+          type = type_type.type_class.authorized_new(type, context)
         end
         type
       end

data/lib/graphql/introspection/enum_value_type.rb

@@ -7,9 +7,9 @@ module GraphQL
                   "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 :description, String, null: true
+      field :description, String
       field :is_deprecated, Boolean, null: false
-      field :deprecation_reason, String, null: true
+      field :deprecation_reason, String
 
       def name
         object.graphql_name

data/lib/graphql/introspection/field_type.rb

@@ -6,18 +6,22 @@ module GraphQL
       description "Object and Interface types are described by a list of Fields, each of which has "\
                   "a name, potentially a list of arguments, and a return type."
       field :name, String, null: false
-      field :description, String, null: true
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :description, String
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false 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 :deprecation_reason, String, null: true
+      field :deprecation_reason, String
 
       def is_deprecated
         !!@object.deprecation_reason
       end
 
-      def args
-        @context.warden.arguments(@object)
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
       end
     end
   end

data/lib/graphql/introspection/input_value_type.rb

@@ -7,9 +7,15 @@ module GraphQL
                   "InputObject are represented as Input Values which describe their type and "\
                   "optionally a default value."
       field :name, String, null: false
-      field :description, String, null: true
+      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.", null: true
+      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value."
+      field :is_deprecated, Boolean, null: false
+      field :deprecation_reason, String
+
+      def is_deprecated
+        !!@object.deprecation_reason
+      end
 
       def default_value
         if @object.default_value?
@@ -17,21 +23,45 @@ module GraphQL
           if value.nil?
             'null'
           else
-            coerced_default_value = @object.type.coerce_result(value, @context)
-            if @object.type.unwrap.is_a?(GraphQL::EnumType)
-              if @object.type.list? 
-                "[#{coerced_default_value.join(", ")}]"
-              else
-                coerced_default_value
-              end
-            else
-              GraphQL::Language.serialize(coerced_default_value)
+            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)
           end
         else
           nil
         end
       end
+
+
+      private
+
+      # Recursively serialize, taking care not to add quotes to enum values
+      def serialize_default_value(value, type)
+        if value.nil?
+          'null'
+        elsif type.kind.list?
+          inner_type = type.of_type
+          "[" + value.map { |v| serialize_default_value(v, inner_type) }.join(", ") + "]"
+        elsif type.kind.non_null?
+          serialize_default_value(value, type.of_type)
+        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)}"
+            end.join(", ") +
+            "}"
+        else
+          GraphQL::Language.serialize(value)
+        end
+      end
     end
   end
 end

data/lib/graphql/introspection/introspection_query.rb

@@ -1,93 +1,7 @@
 # frozen_string_literal: true
-# The introspection query to end all introspection queries, copied from
-# https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
-GraphQL::Introspection::INTROSPECTION_QUERY = "
-query IntrospectionQuery {
-  __schema {
-    queryType { name }
-    mutationType { name }
-    subscriptionType { name }
-    types {
-      ...FullType
-    }
-    directives {
-      name
-      description
-      locations
-      args {
-        ...InputValue
-      }
-    }
-  }
-}
-fragment FullType on __Type {
-  kind
-  name
-  description
-  fields(includeDeprecated: true) {
-    name
-    description
-    args {
-      ...InputValue
-    }
-    type {
-      ...TypeRef
-    }
-    isDeprecated
-    deprecationReason
-  }
-  inputFields {
-    ...InputValue
-  }
-  interfaces {
-    ...TypeRef
-  }
-  enumValues(includeDeprecated: true) {
-    name
-    description
-    isDeprecated
-    deprecationReason
-  }
-  possibleTypes {
-    ...TypeRef
-  }
-}
-fragment InputValue on __InputValue {
-  name
-  description
-  type { ...TypeRef }
-  defaultValue
-}
-fragment TypeRef on __Type {
-  kind
-  name
-  ofType {
-    kind
-    name
-    ofType {
-      kind
-      name
-      ofType {
-        kind
-        name
-        ofType {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-"
+
+# This query is used by graphql-client so don't add the includeDeprecated
+# argument for inputFields since the server may not support it. Two stage
+# introspection queries will be required to handle this in clients.
+GraphQL::Introspection::INTROSPECTION_QUERY = GraphQL::Introspection.query
+

data/lib/graphql/introspection/schema_type.rb

@@ -8,19 +8,19 @@ module GraphQL
                   "available types and directives on the server, as well as the entry points for "\
                   "query, mutation, and subscription operations."
 
-      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
-      field :queryType, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
-      field :mutationType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
-      field :subscriptionType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
-      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
+      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false, scope: false
+      field :query_type, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
+      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
+
+      def schema_description
+        context.schema.description
+      end
 
       def types
-        types = @context.warden.reachable_types.sort_by(&:graphql_name)
-        if context.interpreter?
-          types.map { |t| t.metadata[:type_class] || raise("Invariant: can't introspect non-class-based type: #{t}") }
-        else
-          types
-        end
+        @context.warden.reachable_types.sort_by(&:graphql_name)
       end
 
       def query_type
@@ -36,7 +36,7 @@ module GraphQL
       end
 
       def directives
-        context.schema.directives.values
+        @context.warden.directives
       end
 
       private