graphql 1.8.0 → 1.12.12

data/lib/graphql/execution/multiplex.rb

@@ -29,23 +29,25 @@ module GraphQL
 
       include Tracing::Traceable
 
-      attr_reader :context, :queries, :schema
-      def initialize(schema:, queries:, context:)
+      attr_reader :context, :queries, :schema, :max_complexity, :dataloader
+      def initialize(schema:, queries:, context:, max_complexity:)
         @schema = schema
         @queries = queries
+        @queries.each { |q| q.multiplex = self }
         @context = context
-        # TODO remove support for global tracers
-        @tracers = schema.tracers + GraphQL::Tracing.tracers + (context[:tracers] || [])
+        @context[:dataloader] = @dataloader = @schema.dataloader_class.new
+        @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
           @tracers << GraphQL::Backtrace::Tracer
         end
+        @max_complexity = max_complexity
       end
 
       class << self
-        def run_all(schema, query_options, *args)
-          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, opts) }
-          run_queries(schema, queries, *args)
+        def run_all(schema, query_options, **kwargs)
+          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, **opts) }
+          run_queries(schema, queries, **kwargs)
         end
 
         # @param schema [GraphQL::Schema]
@@ -54,81 +56,93 @@ module GraphQL
         # @param max_complexity [Integer, nil]
         # @return [Array<Hash>] One result per query
         def run_queries(schema, queries, context: {}, max_complexity: schema.max_complexity)
-          multiplex = self.new(schema: schema, queries: queries, context: context)
+          multiplex = self.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
           multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
-            if has_custom_strategy?(schema)
+            if supports_multiplexing?(schema)
+              instrument_and_analyze(multiplex) do
+                run_as_multiplex(multiplex)
+              end
+            else
               if queries.length != 1
                 raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
               else
-                instrument_and_analyze(multiplex, max_complexity: max_complexity) do
+                instrument_and_analyze(multiplex) do
                   [run_one_legacy(schema, queries.first)]
                 end
               end
-            else
-              instrument_and_analyze(multiplex, max_complexity: max_complexity) do
-                run_as_multiplex(multiplex)
-              end
             end
           end
         end
 
+        # @param query [GraphQL::Query]
+        def begin_query(results, idx, query, multiplex)
+          operation = query.selected_operation
+          result = if operation.nil? || !query.valid? || query.context.errors.any?
+            NO_OPERATION
+          else
+            begin
+              # These were checked to be the same in `#supports_multiplexing?`
+              query.schema.query_execution_strategy.begin_query(query, multiplex)
+            rescue GraphQL::ExecutionError => err
+              query.context.errors << err
+              NO_OPERATION
+            end
+          end
+          results[idx] = result
+          nil
+        end
+
         private
 
         def run_as_multiplex(multiplex)
+
+          multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
           queries = multiplex.queries
           # Do as much eager evaluation of the query as possible
-          results = queries.map do |query|
-            begin_query(query)
+          results = []
+          queries.each_with_index do |query, idx|
+            multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
           end
 
+          multiplex.dataloader.run
+
           # Then, work through lazy results in a breadth-first way
-          GraphQL::Execution::Execute::ExecutionFunctions.lazy_resolve_root_selection(results, { multiplex: multiplex })
+          multiplex.dataloader.append_job {
+            multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+          }
+          multiplex.dataloader.run
 
           # Then, find all errors and assign the result to the query object
-          results.each_with_index.map do |data_result, idx|
+          results.each_with_index do |data_result, idx|
             query = queries[idx]
-            finish_query(data_result, query)
+            finish_query(data_result, query, multiplex)
             # Get the Query::Result, not the Hash
-            query.result
+            results[idx] = query.result
           end
-        rescue StandardError
+
+          results
+        rescue Exception
+          # TODO rescue at a higher level so it will catch errors in analysis, too
           # Assign values here so that the query's `@executed` becomes true
           queries.map { |q| q.result_values ||= {} }
           raise
         end
 
-        # @param query [GraphQL::Query]
-        # @return [Hash] The initial result (may not be finished if there are lazy values)
-        def begin_query(query)
-          operation = query.selected_operation
-          if operation.nil? || !query.valid?
-            NO_OPERATION
-          else
-            begin
-              GraphQL::Execution::Execute::ExecutionFunctions.resolve_root_selection(query)
-            rescue GraphQL::ExecutionError => err
-              query.context.errors << err
-              NO_OPERATION
-            end
-          end
-        end
-
         # @param data_result [Hash] The result for the "data" key, if any
         # @param query [GraphQL::Query] The query which was run
         # @return [Hash] final result of this query, including all values and errors
-        def finish_query(data_result, query)
+        def finish_query(data_result, query, multiplex)
           # Assign the result so that it can be accessed in instrumentation
           query.result_values = if data_result.equal?(NO_OPERATION)
-            if !query.valid?
+            if !query.valid? || query.context.errors.any?
+              # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
               { "errors" => query.static_errors.map(&:to_h) }
             else
               data_result
             end
           else
             # Use `context.value` which was assigned during execution
-            result = {
-              "data" => Execution::Flatten.call(query.context)
-            }
+            result = query.schema.query_execution_strategy.finish_query(query, multiplex)
 
             if query.context.errors.any?
               error_result = query.context.errors.map(&:to_h)
@@ -141,6 +155,8 @@ module GraphQL
 
         # use the old `query_execution_strategy` etc to run this query
         def run_one_legacy(schema, query)
+          GraphQL::Deprecation.warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
+
           query.result_values = if !query.valid?
             all_errors = query.validation_errors + query.analysis_errors + query.context.errors
             if all_errors.any?
@@ -153,24 +169,42 @@ module GraphQL
           end
         end
 
-        def has_custom_strategy?(schema)
-          schema.query_execution_strategy != GraphQL::Execution::Execute ||
-            schema.mutation_execution_strategy != GraphQL::Execution::Execute ||
-            schema.subscription_execution_strategy != GraphQL::Execution::Execute
+        DEFAULT_STRATEGIES = [
+          GraphQL::Execution::Execute,
+          GraphQL::Execution::Interpreter
+        ]
+        # @return [Boolean] True if the schema is only using one strategy, and it's one that supports multiplexing.
+        def supports_multiplexing?(schema)
+          schema_strategies = [schema.query_execution_strategy, schema.mutation_execution_strategy, schema.subscription_execution_strategy]
+          schema_strategies.uniq!
+          schema_strategies.size == 1 && DEFAULT_STRATEGIES.include?(schema_strategies.first)
         end
 
         # Apply multiplex & query instrumentation to `queries`.
         #
         # It yields when the queries should be executed, then runs teardown.
-        def instrument_and_analyze(multiplex, max_complexity:)
+        def instrument_and_analyze(multiplex)
           GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
             schema = multiplex.schema
+            if schema.interpreter? && schema.analysis_engine != GraphQL::Analysis::AST
+              raise <<-ERR
+Can't use `GraphQL::Execution::Interpreter` without `GraphQL::Analysis::AST`, please add this plugin to your schema:
+
+    use GraphQL::Analysis::AST
+
+For information about the new analysis engine: https://graphql-ruby.org/queries/ast_analysis.html
+ERR
+            end
             multiplex_analyzers = schema.multiplex_analyzers
-            if max_complexity
-              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
+            if multiplex.max_complexity
+              multiplex_analyzers += if schema.using_ast_analysis?
+                [GraphQL::Analysis::AST::MaxQueryComplexity]
+              else
+                [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
+              end
             end
 
-            GraphQL::Analysis.analyze_multiplex(multiplex, multiplex_analyzers)
+            schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
             yield
           end
         end

data/lib/graphql/execution.rb

@@ -3,6 +3,9 @@ require "graphql/execution/directive_checks"
 require "graphql/execution/execute"
 require "graphql/execution/flatten"
 require "graphql/execution/instrumentation"
+require "graphql/execution/interpreter"
 require "graphql/execution/lazy"
+require "graphql/execution/lookahead"
 require "graphql/execution/multiplex"
 require "graphql/execution/typecast"
+require "graphql/execution/errors"

data/lib/graphql/execution_error.rb

@@ -4,7 +4,7 @@ module GraphQL
   # 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 occured
+    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
     attr_accessor :ast_node
 
     # @return [String] an array describing the JSON-path into the execution
@@ -12,11 +12,19 @@ module GraphQL
     attr_accessor :path
 
     # @return [Hash] Optional data for error objects
+    # @deprecated Use `extensions` instead of `options`. The GraphQL spec
+    # recommends that any custom entries in an error be under the
+    # `extensions` key.
     attr_accessor :options
 
-    def initialize(message, ast_node: nil, options: nil)
+    # @return [Hash] Optional custom data for error objects which will be added
+    # under the `extensions` key.
+    attr_accessor :extensions
+
+    def initialize(message, ast_node: nil, options: nil, extensions: nil)
       @ast_node = ast_node
       @options = options
+      @extensions = extensions
       super(message)
     end
 
@@ -39,6 +47,11 @@ module GraphQL
       if options
         hash.merge!(options)
       end
+      if extensions
+        hash["extensions"] = extensions.each_with_object({}) { |(key, value), ext|
+          ext[key.to_s] = value
+        }
+      end
       hash
     end
   end

data/lib/graphql/field.rb

@@ -2,123 +2,7 @@
 require "graphql/field/resolve"
 
 module GraphQL
-  # {Field}s belong to {ObjectType}s and {InterfaceType}s.
-  #
-  # They're usually created with the `field` helper. If you create it by hand, make sure {#name} is a String.
-  #
-  # A field must have a return type, but if you want to defer the return type calculation until later,
-  # you can pass a proc for the return type. That proc will be called when the schema is defined.
-  #
-  # @example Lazy type resolution
-  #   # If the field's type isn't defined yet, you can pass a proc
-  #   field :city, -> { TypeForModelName.find("City") }
-  #
-  # For complex field definition, you can pass a block to the `field` helper, eg `field :name do ... end`.
-  # This block is equivalent to calling `GraphQL::Field.define { ... }`.
-  #
-  # @example Defining a field with a block
-  #   field :city, CityType do
-  #     # field definition continues inside the block
-  #   end
-  #
-  # ## Resolve
-  #
-  # Fields have `resolve` functions to determine their values at query-time.
-  # The default implementation is to call a method on the object based on the field name.
-  #
-  # @example Create a field which calls a method with the same name.
-  #   GraphQL::ObjectType.define do
-  #     field :name, types.String, "The name of this thing "
-  #   end
-  #
-  # You can specify a custom proc with the `resolve` helper.
-  #
-  # There are some shortcuts for common `resolve` implementations:
-  #   - Provide `property:` to call a method with a different name than the field name
-  #   - Provide `hash_key:` to resolve the field by doing a key lookup, eg `obj[:my_hash_key]`
-  #
-  # @example Create a field that calls a different method on the object
-  #   GraphQL::ObjectType.define do
-  #     # use the `property` keyword:
-  #     field :firstName, types.String, property: :first_name
-  #   end
-  #
-  # @example Create a field looks up with `[hash_key]`
-  #   GraphQL::ObjectType.define do
-  #     # use the `hash_key` keyword:
-  #     field :firstName, types.String, hash_key: :first_name
-  #   end
-  #
-  # ## Arguments
-  #
-  # Fields can take inputs; they're called arguments. You can define them with the `argument` helper.
-  #
-  # @example Create a field with an argument
-  #   field :students, types[StudentType] do
-  #     argument :grade, types.Int
-  #     resolve ->(obj, args, ctx) {
-  #       Student.where(grade: args[:grade])
-  #     }
-  #   end
-  #
-  # They can have default values which will be provided to `resolve` if the query doesn't include a value.
-  #
-  # @example Argument with a default value
-  #   field :events, types[EventType] do
-  #     # by default, don't include past events
-  #     argument :includePast, types.Boolean, default_value: false
-  #     resolve ->(obj, args, ctx) {
-  #       args[:includePast] # => false if no value was provided in the query
-  #       # ...
-  #     }
-  #   end
-  #
-  # Only certain types maybe used for inputs:
-  #
-  # - Scalars
-  # - Enums
-  # - Input Objects
-  # - Lists of those types
-  #
-  # Input types may also be non-null -- in that case, the query will fail
-  # if the input is not present.
-  #
-  # ## Complexity
-  #
-  # Fields can have _complexity_ values which describe the computation cost of resolving the field.
-  # You can provide the complexity as a constant with `complexity:` or as a proc, with the `complexity` helper.
-  #
-  # @example Custom complexity values
-  #   # Complexity can be a number or a proc.
-  #
-  #   # Complexity can be defined with a keyword:
-  #   field :expensive_calculation, !types.Int, complexity: 10
-  #
-  #   # Or inside the block:
-  #   field :expensive_calculation_2, !types.Int do
-  #     complexity ->(ctx, args, child_complexity) { ctx[:current_user].staff? ? 0 : 10 }
-  #   end
-  #
-  # @example Calculating the complexity of a list field
-  #   field :items, types[ItemType] do
-  #     argument :limit, !types.Int
-  #     # Multiply the child complexity by the possible items on the list
-  #     complexity ->(ctx, args, child_complexity) { child_complexity * args[:limit] }
-  #   end
-  #
-  # @example Creating a field, then assigning it to a type
-  #   name_field = GraphQL::Field.define do
-  #     name("Name")
-  #     type(!types.String)
-  #     description("The name of this thing")
-  #     resolve ->(object, arguments, context) { object.name }
-  #   end
-  #
-  #   NamedType = GraphQL::ObjectType.define do
-  #     # The second argument may be a GraphQL::Field
-  #     field :name, name_field
-  #   end
-  #
+  # @api deprecated
   class Field
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :name, :description, :deprecation_reason,
@@ -156,7 +40,8 @@ module GraphQL
     attr_reader :lazy_resolve_proc
 
     # @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
-    attr_accessor :name
+    attr_reader :name
+    alias :graphql_name :name
 
     # @return [String, nil] The client-facing description of this field
     attr_accessor :description
@@ -174,10 +59,10 @@ module GraphQL
     attr_accessor :complexity
 
     # @return [Symbol, nil] The method to call on `obj` to return this field (overrides {#name} if present)
-    attr_accessor :property
+    attr_reader :property
 
     # @return [Object, nil] The key to access with `obj.[]` to resolve this field (overrides {#name} if present)
-    attr_accessor :hash_key
+    attr_reader :hash_key
 
     # @return [Object, GraphQL::Function] The function used to derive this field
     attr_accessor :function
@@ -195,6 +80,10 @@ module GraphQL
 
     attr_accessor :ast_node
 
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
+
     # @return [Boolean]
     def connection?
       @connection
@@ -265,7 +154,7 @@ module GraphQL
     end
 
     def name=(new_name)
-      old_name = @name
+      old_name = defined?(@name) ? @name : nil
       @name = new_name
 
       if old_name != new_name && @resolve_proc.is_a?(Field::Resolve::NameResolve)
@@ -314,6 +203,14 @@ module GraphQL
       }
     end
 
+    def type_class
+      metadata[:type_class]
+    end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
+
     private
 
     def build_default_resolver
@@ -322,8 +219,7 @@ module GraphQL
 
     module DefaultLazyResolve
       def self.call(obj, args, ctx)
-        method_name = ctx.schema.lazy_method_name(obj)
-        obj.public_send(method_name)
+        ctx.schema.sync_lazy(obj)
       end
     end
   end

data/lib/graphql/filter.rb

@@ -33,7 +33,7 @@ module GraphQL
       end
 
       def self.build(onlies)
-        case onlies
+        case onlies.size
         when 0
           nil
         when 1

data/lib/graphql/float_type.rb

@@ -1,9 +1,2 @@
 # frozen_string_literal: true
-GraphQL::FLOAT_TYPE = GraphQL::ScalarType.define do
-  name "Float"
-  description "Represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point)."
-
-  coerce_input ->(value, _ctx) { value.is_a?(Numeric) ? value.to_f : nil }
-  coerce_result ->(value, _ctx) { value.to_f }
-  default_scalar true
-end
+GraphQL::FLOAT_TYPE = GraphQL::Types::Float.graphql_definition

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
@@ -43,7 +18,7 @@ module GraphQL
 
     # @return [Object] This function's resolver
     def call(obj, args, ctx)
-      raise NotImplementedError
+      raise GraphQL::RequiredImplementationMissingError
     end
 
     # @return [String, nil]

data/lib/graphql/id_type.rb

@@ -1,16 +1,2 @@
 # frozen_string_literal: true
-GraphQL::ID_TYPE = GraphQL::ScalarType.define do
-  name "ID"
-  description "Represents a unique identifier that is Base64 obfuscated. It is often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"VXNlci0xMA==\"`) or integer (such as `4`) input value will be accepted as an ID."
-
-  coerce_result ->(value, _ctx) { value.to_s }
-  coerce_input ->(value, _ctx) {
-    case value
-    when String, Integer
-      value.to_s
-    else
-      nil
-    end
-  }
-  default_scalar true
-end
+GraphQL::ID_TYPE = GraphQL::Types::ID.graphql_definition

data/lib/graphql/input_object_type.rb

@@ -1,29 +1,9 @@
 # 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
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions(
       :arguments, :mutation,
       input_field: 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)
@@ -93,12 +77,14 @@ module GraphQL
           coerced_value = input_field_defn.type.coerce_input(field_value, ctx)
           input_values[input_key] = input_field_defn.prepare(coerced_value, ctx)
         elsif input_field_defn.default_value?
-          input_values[input_key] = input_field_defn.default_value
+          coerced_value = input_field_defn.type.coerce_input(input_field_defn.default_value, ctx)
+          input_values[input_key] = coerced_value
           defaults_used << input_key
         end
       end
 
-      arguments_class.new(input_values, context: ctx, defaults_used: defaults_used)
+      result = arguments_class.new(input_values, context: ctx, defaults_used: defaults_used)
+      result.prepare
     end
 
     # @api private
@@ -134,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,9 +1,2 @@
 # frozen_string_literal: true
-GraphQL::INT_TYPE = GraphQL::ScalarType.define do
-  name "Int"
-  description "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1."
-
-  coerce_input ->(value, _ctx) { value.is_a?(Numeric) ? value.to_i : nil }
-  coerce_result ->(value, _ctx) { value.to_i }
-  default_scalar true
-end
+GraphQL::INT_TYPE = GraphQL::Types::Int.graphql_definition

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Int` is asked to return a value outside of 32-bit integer range.
+  #
+  # For values outside that range, consider:
+  #
+  # - `ID` for database primary keys or other identifiers
+  # - `GraphQL::Types::BigInt` for really big integer values
+  #
+  # @see GraphQL::Types::Int which raises this error
+  class IntegerEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :integer_value
+
+    def initialize(value)
+      @integer_value = value
+      super("Integer out of bounds: #{value}. \nConsider using ID or GraphQL::Types::BigInt instead.")
+    end
+  end
+end