graphql 1.9.0 → 2.1.1

data/lib/graphql/execution/lookahead.rb

@@ -9,10 +9,6 @@ module GraphQL
     # A field may get access to its lookahead by adding `extras: [:lookahead]`
     # to its configuration.
     #
-    # __NOTE__: Lookahead for typed fragments (eg `node { ... on Thing { ... } }`)
-    # hasn't been implemented yet. It's possible, I just didn't need it yet.
-    # Feel free to open a PR or an issue if you want to add it.
-    #
     # @example looking ahead in a field
     #   field :articles, [Types::Article], null: false,
     #     extras: [:lookahead]
@@ -35,12 +31,13 @@ module GraphQL
       # @param ast_nodes [Array<GraphQL::Language::Nodes::Field>, Array<GraphQL::Language::Nodes::OperationDefinition>]
       # @param field [GraphQL::Schema::Field] if `ast_nodes` are fields, this is the field definition matching those nodes
       # @param root_type [Class] if `ast_nodes` are operation definition, this is the root type for that operation
-      def initialize(query:, ast_nodes:, field: nil, root_type: nil)
+      def initialize(query:, ast_nodes:, field: nil, root_type: nil, owner_type: nil)
         @ast_nodes = ast_nodes.freeze
         @field = field
         @root_type = root_type
         @query = query
         @selected_type = @field ? @field.type.unwrap : root_type
+        @owner_type = owner_type
       end
 
       # @return [Array<GraphQL::Language::Nodes::Field>]
@@ -49,6 +46,24 @@ module GraphQL
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
+      # @return [GraphQL::Schema::Object, GraphQL::Schema::Union, GraphQL::Schema::Interface]
+      attr_reader :owner_type
+
+      # @return [Hash<Symbol, Object>]
+      def arguments
+        if defined?(@arguments)
+          @arguments
+        else
+          @arguments = if @field
+            @query.after_lazy(@query.arguments_for(@ast_nodes.first, @field)) do |args|
+              args.is_a?(Execution::Interpreter::Arguments) ? args.keyword_arguments : args
+            end
+          else
+            nil
+          end
+        end
+      end
+
       # True if this node has a selection on `field_name`.
       # If `field_name` is a String, it is treated as a GraphQL-style (camelized)
       # field name and used verbatim. If `field_name` is a Symbol, it is
@@ -61,8 +76,8 @@ module GraphQL
       # @param field_name [String, Symbol]
       # @param arguments [Hash] Arguments which must match in the selection
       # @return [Boolean]
-      def selects?(field_name, arguments: nil)
-        selection(field_name, arguments: arguments).selected?
+      def selects?(field_name, selected_type: @selected_type, arguments: nil)
+        selection(field_name, selected_type: selected_type, arguments: arguments).selected?
       end
 
       # @return [Boolean] True if this lookahead represents a field that was requested
@@ -72,21 +87,44 @@ module GraphQL
 
       # Like {#selects?}, but can be used for chaining.
       # It returns a null object (check with {#selected?})
+      # @param field_name [String, Symbol]
       # @return [GraphQL::Execution::Lookahead]
       def selection(field_name, selected_type: @selected_type, arguments: nil)
-        next_field_name = normalize_name(field_name)
+        next_field_defn = case field_name
+        when String
+          @query.get_field(selected_type, field_name)
+        when Symbol
+          # Try to avoid the `.to_s` below, if possible
+          all_fields = if selected_type.kind.fields?
+            @query.warden.fields(selected_type)
+          else
+            # Handle unions by checking possible
+            @query.warden
+              .possible_types(selected_type)
+              .map { |t| @query.warden.fields(t) }
+              .tap(&:flatten!)
+          end
+
+          if (match_by_orig_name = all_fields.find { |f| f.original_name == field_name })
+            match_by_orig_name
+          else
+            # Symbol#name is only present on 3.0+
+            sym_s = field_name.respond_to?(:name) ? field_name.name : field_name.to_s
+            guessed_name = Schema::Member::BuildType.camelize(sym_s)
+            @query.get_field(selected_type, guessed_name)
+          end
+        end
 
-        next_field_defn = FieldHelpers.get_field(@query.schema, selected_type, next_field_name)
         if next_field_defn
           next_nodes = []
           @ast_nodes.each do |ast_node|
             ast_node.selections.each do |selection|
-              find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+              find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
             end
           end
 
           if next_nodes.any?
-            Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn)
+            Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
           else
             NULL_LOOKAHEAD
           end
@@ -111,13 +149,24 @@ module GraphQL
       # @param arguments [Hash] Arguments which must match in the selection
       # @return [Array<GraphQL::Execution::Lookahead>]
       def selections(arguments: nil)
-        subselections_by_name = {}
+        subselections_by_type = {}
+        subselections_on_type = subselections_by_type[@selected_type] = {}
+
         @ast_nodes.each do |node|
-          find_selections(subselections_by_name, @selected_type, node.selections, arguments)
+          find_selections(subselections_by_type, subselections_on_type, @selected_type, node.selections, arguments)
+        end
+
+        subselections = []
+
+        subselections_by_type.each do |type, ast_nodes_by_response_key|
+          ast_nodes_by_response_key.each do |response_key, ast_nodes|
+            field_defn = @query.get_field(type, ast_nodes.first.name)
+            lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
+            subselections.push(lookahead)
+          end
         end
 
-        # Items may be filtered out if `arguments` doesn't match
-        subselections_by_name.values.select(&:selected?)
+        subselections
       end
 
       # The method name of the field.
@@ -170,39 +219,50 @@ module GraphQL
 
       private
 
-      # If it's a symbol, stringify and camelize it
-      def normalize_name(name)
-        if name.is_a?(Symbol)
-          Schema::Member::BuildType.camelize(name.to_s)
-        else
-          name
-        end
-      end
-
-      def normalize_keyword(keyword)
-        if keyword.is_a?(String)
-          Schema::Member::BuildType.underscore(keyword).to_sym
-        else
-          keyword
+      def skipped_by_directive?(ast_selection)
+        ast_selection.directives.each do |directive|
+          dir_defn = @query.schema.directives.fetch(directive.name)
+          directive_class = dir_defn
+          if directive_class
+            dir_args = @query.arguments_for(directive, dir_defn)
+            return true unless directive_class.static_include?(dir_args, @query.context)
+          end
         end
+        false
       end
 
-      def find_selections(subselections_by_name, selected_type, ast_selections, arguments)
+      def find_selections(subselections_by_type, selections_on_type, selected_type, ast_selections, arguments)
         ast_selections.each do |ast_selection|
+          next if skipped_by_directive?(ast_selection)
+
           case ast_selection
           when GraphQL::Language::Nodes::Field
-            subselections_by_name[ast_selection.name] ||= selection(ast_selection.name, selected_type: selected_type, arguments: arguments)
+            response_key = ast_selection.alias || ast_selection.name
+            if selections_on_type.key?(response_key)
+              selections_on_type[response_key] << ast_selection
+            elsif arguments.nil? || arguments.empty?
+              selections_on_type[response_key] = [ast_selection]
+            else
+              field_defn = @query.get_field(selected_type, ast_selection.name)
+              if arguments_match?(arguments, field_defn, ast_selection)
+                selections_on_type[response_key] = [ast_selection]
+              end
+            end
           when GraphQL::Language::Nodes::InlineFragment
+            on_type = selected_type
+            subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              selected_type = @query.schema.types[t.name].metadata[:type_class]
+              on_type = @query.get_type(t.name)
+              subselections_on_type = subselections_by_type[on_type] ||= {}
             end
-            find_selections(subselections_by_name, selected_type, ast_selection.selections, arguments)
+            find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
             # Again, assuming a valid AST
-            selected_type = @query.schema.types[frag_defn.type.name].metadata[:type_class]
-            find_selections(subselections_by_name, selected_type, frag_defn.selections, arguments)
+            on_type = @query.get_type(frag_defn.type.name)
+            subselections_on_type = subselections_by_type[on_type] ||= {}
+            find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else
             raise "Invariant: Unexpected selection type: #{ast_selection.class}"
           end
@@ -211,139 +271,39 @@ module GraphQL
 
       # If a selection on `node` matches `field_name` (which is backed by `field_defn`)
       # and matches the `arguments:` constraints, then add that node to `matches`
-      def find_selected_nodes(node, field_name, field_defn, arguments:, matches:)
+      def find_selected_nodes(node, field_defn, arguments:, matches:)
+        return if skipped_by_directive?(node)
         case node
         when GraphQL::Language::Nodes::Field
-          if node.name == field_name
+          if node.name == field_defn.graphql_name
             if arguments.nil? || arguments.empty?
               # No constraint applied
               matches << node
-            else
-              query_kwargs = ArgumentHelpers.arguments(@query, nil, field_defn, node)
-              passes_args = arguments.all? do |arg_name, arg_value|
-                arg_name = normalize_keyword(arg_name)
-                # Make sure the constraint is present with a matching value
-                query_kwargs.key?(arg_name) && query_kwargs[arg_name] == arg_value
-              end
-              if passes_args
-                matches << node
-              end
+            elsif arguments_match?(arguments, field_defn, node)
+              matches << node
             end
           end
         when GraphQL::Language::Nodes::InlineFragment
-          node.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches) }
+          node.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
         when GraphQL::Language::Nodes::FragmentSpread
           frag_defn = @query.fragments[node.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{node.name} (found: #{@query.fragments.keys})")
-          frag_defn.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches) }
+          frag_defn.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
         else
           raise "Unexpected selection comparison on #{node.class.name} (#{node})"
         end
       end
 
-      # TODO Dedup with interpreter
-      module ArgumentHelpers
-        module_function
-
-        def arguments(query, graphql_object, arg_owner, ast_node)
-          kwarg_arguments = {}
-          arg_defns = arg_owner.arguments
-          ast_node.arguments.each do |arg|
-            arg_defn = arg_defns[arg.name] || raise("Invariant: missing argument definition for #{arg.name.inspect} in #{arg_defns.keys} from #{arg_owner}")
-            # Need to distinguish between client-provided `nil`
-            # and nothing-at-all
-            is_present, value = arg_to_value(query, graphql_object, arg_defn.type, arg.value)
-            if is_present
-              # This doesn't apply to directives, which are legacy
-              # Can remove this when Skip and Include use classes or something.
-              if graphql_object
-                value = arg_defn.prepare_value(graphql_object, value)
-              end
-              kwarg_arguments[arg_defn.keyword] = value
-            end
-          end
-          arg_defns.each do |name, arg_defn|
-            if arg_defn.default_value? && !kwarg_arguments.key?(arg_defn.keyword)
-              kwarg_arguments[arg_defn.keyword] = arg_defn.default_value
-            end
-          end
-          kwarg_arguments
-        end
-
-        # Get a Ruby-ready value from a client query.
-        # @param graphql_object [Object] The owner of the field whose argument this is
-        # @param arg_type [Class, GraphQL::Schema::NonNull, GraphQL::Schema::List]
-        # @param ast_value [GraphQL::Language::Nodes::VariableIdentifier, String, Integer, Float, Boolean]
-        # @return [Array(is_present, value)]
-        def arg_to_value(query, graphql_object, arg_type, ast_value)
-          if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-            # If it's not here, it will get added later
-            if query.variables.key?(ast_value.name)
-              return true, query.variables[ast_value.name]
-            else
-              return false, nil
-            end
-          elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
-            return true, nil
-          elsif arg_type.is_a?(GraphQL::Schema::NonNull)
-            arg_to_value(query, graphql_object, arg_type.of_type, ast_value)
-          elsif arg_type.is_a?(GraphQL::Schema::List)
-            # Treat a single value like a list
-            arg_value = Array(ast_value)
-            list = []
-            arg_value.map do |inner_v|
-              _present, value = arg_to_value(query, graphql_object, arg_type.of_type, inner_v)
-              list << value
-            end
-            return true, list
-          elsif arg_type.is_a?(Class) && arg_type < GraphQL::Schema::InputObject
-            # For these, `prepare` is applied during `#initialize`.
-            # Pass `nil` so it will be skipped in `#arguments`.
-            # What a mess.
-            args = arguments(query, nil, arg_type, ast_value)
-            # We're not tracking defaults_used, but for our purposes
-            # we compare the value to the default value.
-            return true, arg_type.new(ruby_kwargs: args, context: query.context, defaults_used: nil)
-          else
-            flat_value = flatten_ast_value(query, ast_value)
-            return true, arg_type.coerce_input(flat_value, query.context)
-          end
-        end
-
-        def flatten_ast_value(query, v)
-          case v
-          when GraphQL::Language::Nodes::Enum
-            v.name
-          when GraphQL::Language::Nodes::InputObject
-            h = {}
-            v.arguments.each do |arg|
-              h[arg.name] = flatten_ast_value(query, arg.value)
-            end
-            h
-          when Array
-            v.map { |v2| flatten_ast_value(query, v2) }
-          when GraphQL::Language::Nodes::VariableIdentifier
-            flatten_ast_value(query.variables[v.name])
+      def arguments_match?(arguments, field_defn, field_node)
+        query_kwargs = @query.arguments_for(field_node, field_defn)
+        arguments.all? do |arg_name, arg_value|
+          arg_name_sym = if arg_name.is_a?(String)
+            Schema::Member::BuildType.underscore(arg_name).to_sym
           else
-            v
-          end
-        end
-      end
-
-      # TODO dedup with interpreter
-      module FieldHelpers
-        module_function
-
-        def get_field(schema, owner_type, field_name)
-          field_defn = owner_type.get_field(field_name)
-          field_defn ||= if owner_type == schema.query.metadata[:type_class] && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
-            entry_point_field.metadata[:type_class]
-          elsif (dynamic_field = schema.introspection_system.dynamic_field(name: field_name))
-            dynamic_field.metadata[:type_class]
-          else
-            nil
+            arg_name
           end
 
-          field_defn
+          # Make sure the constraint is present with a matching value
+          query_kwargs.key?(arg_name_sym) && query_kwargs[arg_name_sym] == arg_value
         end
       end
     end

data/lib/graphql/execution/multiplex.rb

@@ -23,166 +23,24 @@ module GraphQL
     # @see {Schema#multiplex} for public API
     # @api private
     class Multiplex
-      # Used internally to signal that the query shouldn't be executed
-      # @api private
-      NO_OPERATION = {}.freeze
-
       include Tracing::Traceable
 
-      attr_reader :context, :queries, :schema, :max_complexity
+      attr_reader :context, :queries, :schema, :max_complexity, :dataloader, :current_trace
+
       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] || [])
+        @current_trace = @context[:trace] || schema.new_trace(multiplex: self)
+        @dataloader = @context[: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)
-        end
-
-        # @param schema [GraphQL::Schema]
-        # @param queries [Array<GraphQL::Query>]
-        # @param context [Hash]
-        # @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, max_complexity: max_complexity)
-          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
-            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) do
-                  [run_one_legacy(schema, queries.first)]
-                end
-              end
-            end
-          end
-        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, multiplex)
-          end
-
-          # Then, work through lazy results in a breadth-first way
-          multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
-
-          # Then, find all errors and assign the result to the query object
-          results.each_with_index.map do |data_result, idx|
-            query = queries[idx]
-            finish_query(data_result, query, multiplex)
-            # Get the Query::Result, not the Hash
-            query.result
-          end
-        rescue Exception
-          # 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, multiplex)
-          operation = query.selected_operation
-          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
-        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, multiplex)
-          # Assign the result so that it can be accessed in instrumentation
-          query.result_values = if data_result.equal?(NO_OPERATION)
-            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 = query.schema.query_execution_strategy.finish_query(query, multiplex)
-
-            if query.context.errors.any?
-              error_result = query.context.errors.map(&:to_h)
-              result["errors"] = error_result
-            end
-
-            result
-          end
-        end
-
-        # use the old `query_execution_strategy` etc to run this query
-        def run_one_legacy(schema, query)
-          query.result_values = if !query.valid?
-            all_errors = query.validation_errors + query.analysis_errors + query.context.errors
-            if all_errors.any?
-              { "errors" => all_errors.map(&:to_h) }
-            else
-              nil
-            end
-          else
-            GraphQL::Query::Executor.new(query).result
-          end
-        end
-
-        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)
-          GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
-            schema = multiplex.schema
-            multiplex_analyzers = schema.multiplex_analyzers
-            if multiplex.max_complexity
-              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
-            end
-
-            schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
-            yield
-          end
-        end
-      end
     end
   end
 end

data/lib/graphql/execution.rb

@@ -1,10 +1,18 @@
 # frozen_string_literal: true
 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"
+
+module GraphQL
+  module Execution
+    # @api private
+    class Skip < GraphQL::Error; end
+
+    # Just a singleton for implementing {Query::Context#skip}
+    # @api private
+    SKIP = Skip.new
+  end
+end

data/lib/graphql/execution_error.rb

@@ -48,8 +48,9 @@ module GraphQL
         hash.merge!(options)
       end
       if extensions
-        hash["extensions"] ||= {}
-        hash["extensions"].merge!(extensions)
+        hash["extensions"] = extensions.each_with_object({}) { |(key, value), ext|
+          ext[key.to_s] = value
+        }
       end
       hash
     end

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

@@ -1,12 +1,36 @@
 # 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)
+    # @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.')
+      @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/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