graphql 1.9.7 → 1.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc1010a9a70360cc6b3d6dcb13db9d35c207179686f503d01d5904c2655f9ae2
-  data.tar.gz: 510f939a5c9dd9b1a66610e7d526aa84e9ae2b494f76a9a07973aef0b24e6cde
+  metadata.gz: 8b6424d74c67296edb56f74eb9214313dd9556f1c1ba5e5797c58099afea8958
+  data.tar.gz: ae10d626a73f8dc873f2b9b2678bfc3ffc1cd80301ddd15a255e4447c728d285
 SHA512:
-  metadata.gz: bebd9ccec78e0ba8e2d2a13d351a33e9a169261faf954bc50710f80c4ad6d555e495761681e0691213a9ed409b3057f77118f91e73e577fdd988759e4c7eb743
-  data.tar.gz: d458a432047fa847b775f8ff5558084eb2cc845a5277d4f47643483de5f9049d2b19c8c7831058c79b28bc962000d8f13c5201a7396169fa81bf080be8f12e18
+  metadata.gz: 51b253d7218b850a4189affeee6e298d1367e8781289ca2f828ab6bbd70d6a1de205f29531ff697d70807d8107f62c3b9cbfc6325f7847116836ab4f500206ce
+  data.tar.gz: f9a81a828f9835ce1222021d0ae3f251c576eba5845df2034e8330456765d2920a28850fa24b7f58cbc7d3e1442bd405995cc3a4bf8d7e17277a73ba8fdb8ab6

data/lib/generators/graphql/install_generator.rb

@@ -13,6 +13,7 @@ module Graphql
     #   - graphql/
     #     - resolvers/
     #     - types/
+    #       - base_argument.rb
     #       - base_field.rb
     #       - base_enum.rb
     #       - base_input_object.rb
@@ -94,7 +95,7 @@ module Graphql
         create_dir("#{options[:directory]}/types")
         template("schema.erb", schema_file_path)
 
-        ["base_object", "base_field", "base_enum", "base_input_object", "base_interface", "base_scalar", "base_union"].each do |base_type|
+        ["base_object", "base_argument", "base_field", "base_enum", "base_input_object", "base_interface", "base_scalar", "base_union"].each do |base_type|
           template("#{base_type}.erb", "#{options[:directory]}/types/#{base_type}.rb")
         end
 

data/lib/generators/graphql/templates/base_argument.erb

@@ -0,0 +1,4 @@
+module Types
+  class BaseArgument < GraphQL::Schema::Argument
+  end
+end

data/lib/generators/graphql/templates/base_field.erb

@@ -1,5 +1,7 @@
 module Types
   class BaseField < GraphQL::Schema::Field
+    argument_class Types::BaseArgument
+
     def resolve_field(obj, args, ctx)
       resolve(obj, args, ctx)
     end

data/lib/generators/graphql/templates/base_input_object.erb

@@ -1,4 +1,5 @@
 module Types
   class BaseInputObject < GraphQL::Schema::InputObject
+    argument_class Types::BaseArgument
   end
 end

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -4,11 +4,11 @@ module GraphQL
     # Calculate the complexity of a query, using {Field#complexity} values.
     module AST
       class QueryComplexity < Analyzer
-        # State for the query complexity calcuation:
+        # State for the query complexity calculation:
         # - `complexities_on_type` holds complexity scores for each type in an IRep node
         def initialize(query)
           super
-          @complexities_on_type = [TypeComplexity.new]
+          @complexities_on_type = [ConcreteTypeComplexity.new]
         end
 
         # Overide this method to use the complexity result
@@ -22,7 +22,11 @@ module GraphQL
           return if visitor.visiting_fragment_definition?
           return if visitor.skipping?
 
-          @complexities_on_type.push(TypeComplexity.new)
+          if visitor.type_definition.kind.abstract?
+            @complexities_on_type.push(AbstractTypeComplexity.new)
+          else
+            @complexities_on_type.push(ConcreteTypeComplexity.new)
+          end
         end
 
         def on_leave_field(node, parent, visitor)
@@ -35,17 +39,14 @@ module GraphQL
           child_complexity = type_complexities.max_possible_complexity
           own_complexity = get_complexity(node, visitor.field_definition, child_complexity, visitor)
 
-          parent_type = visitor.parent_type_definition
-          possible_types = if parent_type.kind.abstract?
-            query.possible_types(parent_type)
+          if @complexities_on_type.last.is_a?(AbstractTypeComplexity)
+            key = selection_key(visitor.response_path, visitor.query)
+            parent_type = visitor.parent_type_definition
+            query.possible_types(parent_type).each do |type|
+              @complexities_on_type.last.merge(type, key, own_complexity)
+            end
           else
-            [parent_type]
-          end
-
-          key = selection_key(visitor.response_path, visitor.query)
-
-          possible_types.each do |type|
-            @complexities_on_type.last.merge(type, key, own_complexity)
+            @complexities_on_type.last.merge(own_complexity)
           end
         end
 
@@ -68,7 +69,7 @@ module GraphQL
           # We add the query object id to support multiplex queries
           # even if they have the same response path, they should
           # always be added.
-          response_path.join(".") + "-#{query.object_id}"
+          "#{response_path.join(".")}-#{query.object_id}"
         end
 
         # Get a complexity value for a field,
@@ -91,16 +92,19 @@ module GraphQL
 
         # Selections on an object may apply differently depending on what is _actually_ returned by the resolve function.
         # Find the maximum possible complexity among those combinations.
-        class TypeComplexity
+        class AbstractTypeComplexity
           def initialize
             @types = Hash.new { |h, k| h[k] = {} }
           end
 
           # Return the max possible complexity for types in this selection
           def max_possible_complexity
-            @types.map do |type, fields|
-              fields.values.inject(:+)
-            end.max
+            max = 0
+            @types.each_value do |fields|
+              complexity = fields.each_value.inject(:+)
+              max = complexity if complexity > max
+            end
+            max
           end
 
           # Store the complexity for the branch on `type_defn`.
@@ -109,6 +113,18 @@ module GraphQL
             @types[type_defn][key] = complexity
           end
         end
+
+        class ConcreteTypeComplexity
+          attr_reader :max_possible_complexity
+
+          def initialize
+            @max_possible_complexity = 0
+          end
+
+          def merge(complexity)
+            @max_possible_complexity += complexity
+          end
+        end
       end
     end
   end

data/lib/graphql/argument.rb

@@ -35,13 +35,14 @@ module GraphQL
 
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare
+    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access
     attr_reader :default_value
     attr_accessor :description, :name, :as
     attr_accessor :ast_node
+    attr_accessor :method_access
     alias :graphql_name :name
 
-    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare)
+    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access)
 
     # @api private
     module DefaultPrepare
@@ -60,6 +61,11 @@ module GraphQL
       !!@has_default_value
     end
 
+    def method_access?
+      # Treat unset as true -- only `false` should override
+      @method_access != false
+    end
+
     def default_value=(new_default_value)
       if new_default_value == NO_DEFAULT_VALUE
         @has_default_value = false

data/lib/graphql/compatibility/lazy_execution_specification/lazy_schema.rb

@@ -88,7 +88,7 @@ module GraphQL
             end
 
             connection :pushes, lazy_push_type.connection_type do
-              argument :values, types[types.Int]
+              argument :values, types[types.Int], method_access: false
               resolve ->(o, a, c) {
                 LazyPushCollection.new(c, a[:values])
               }

data/lib/graphql/language/lexer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GraphQL
 module Language
 module Lexer
@@ -1369,7 +1371,7 @@ end
 def self.record_comment(ts, te, meta)
 token = GraphQL::Language::Token.new(
 name: :COMMENT,
-value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
+value: meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
 line: meta[:line],
 col: meta[:col],
 prev_token: meta[:previous_token],
@@ -1383,7 +1385,7 @@ end
 def self.emit(token_name, ts, te, meta)
 meta[:tokens] << token = GraphQL::Language::Token.new(
 name: token_name,
-value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
+value: meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
 line: meta[:line],
 col: meta[:col],
 prev_token: meta[:previous_token],
@@ -1415,16 +1417,15 @@ UTF_8_ENCODING = "UTF-8"
 
 def self.emit_string(ts, te, meta, block:)
 quotes_length = block ? 3 : 1
-ts += quotes_length
-value = meta[:data][ts...te - quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+value = meta[:data][ts + quotes_length, te - ts - 2 * quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING) || ''
 line_incr = 0
-if block
+if block && !value.length.zero?
 line_incr = value.count("\n")
 value = GraphQL::Language::BlockString.trim_whitespace(value)
 end
 # TODO: replace with `String#match?` when we support only Ruby 2.4+
 # (It's faster: https://bugs.ruby-lang.org/issues/8110)
-if value !~ VALID_STRING
+if !value.valid_encoding? || value !~ VALID_STRING
 meta[:tokens] << token = GraphQL::Language::Token.new(
 name: :BAD_UNICODE_ESCAPE,
 value: value,
@@ -1435,13 +1436,23 @@ prev_token: meta[:previous_token],
 else
 replace_escaped_characters_in_place(value)
 
-meta[:tokens] << token = GraphQL::Language::Token.new(
-name: :STRING,
-value: value,
-line: meta[:line],
-col: meta[:col],
-prev_token: meta[:previous_token],
-)
+if !value.valid_encoding?
+	meta[:tokens] << token = GraphQL::Language::Token.new(
+	name: :BAD_UNICODE_ESCAPE,
+	value: value,
+	line: meta[:line],
+	col: meta[:col],
+	prev_token: meta[:previous_token],
+	)
+	else
+	meta[:tokens] << token = GraphQL::Language::Token.new(
+	name: :STRING,
+	value: value,
+	line: meta[:line],
+	col: meta[:col],
+	prev_token: meta[:previous_token],
+	)
+	end
 end
 
 meta[:previous_token] = token

data/lib/graphql/language/lexer.rl

@@ -105,6 +105,7 @@
   *|;
 }%%
 
+# frozen_string_literal: true
 
 module GraphQL
   module Language
@@ -152,7 +153,7 @@ module GraphQL
       def self.record_comment(ts, te, meta)
         token = GraphQL::Language::Token.new(
           name: :COMMENT,
-          value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
+          value: meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
           line: meta[:line],
           col: meta[:col],
           prev_token: meta[:previous_token],
@@ -166,7 +167,7 @@ module GraphQL
       def self.emit(token_name, ts, te, meta)
         meta[:tokens] << token = GraphQL::Language::Token.new(
           name: token_name,
-          value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
+          value: meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
           line: meta[:line],
           col: meta[:col],
           prev_token: meta[:previous_token],
@@ -198,16 +199,15 @@ module GraphQL
 
       def self.emit_string(ts, te, meta, block:)
         quotes_length = block ? 3 : 1
-        ts += quotes_length
-        value = meta[:data][ts...te - quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+        value = meta[:data][ts + quotes_length, te - ts - 2 * quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING) || ''
         line_incr = 0
-        if block
+        if block && !value.length.zero?
           line_incr = value.count("\n")
           value = GraphQL::Language::BlockString.trim_whitespace(value)
         end
         # TODO: replace with `String#match?` when we support only Ruby 2.4+
         # (It's faster: https://bugs.ruby-lang.org/issues/8110)
-        if value !~ VALID_STRING
+        if !value.valid_encoding? || value !~ VALID_STRING
           meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,
             value: value,
@@ -218,13 +218,23 @@ module GraphQL
         else
           replace_escaped_characters_in_place(value)
 
-          meta[:tokens] << token = GraphQL::Language::Token.new(
-            name: :STRING,
-            value: value,
-            line: meta[:line],
-            col: meta[:col],
-            prev_token: meta[:previous_token],
-          )
+          if !value.valid_encoding?
+            meta[:tokens] << token = GraphQL::Language::Token.new(
+              name: :BAD_UNICODE_ESCAPE,
+              value: value,
+              line: meta[:line],
+              col: meta[:col],
+              prev_token: meta[:previous_token],
+            )
+          else
+            meta[:tokens] << token = GraphQL::Language::Token.new(
+              name: :STRING,
+              value: value,
+              line: meta[:line],
+              col: meta[:col],
+              prev_token: meta[:previous_token],
+            )
+          end
         end
 
         meta[:previous_token] = token

data/lib/graphql/query/arguments.rb

@@ -14,21 +14,22 @@ module GraphQL
           self.argument_definitions = argument_definitions
 
           argument_definitions.each do |_arg_name, arg_definition|
-            expose_as = arg_definition.expose_as.to_s.freeze
-            expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as).freeze
-            method_names = [expose_as, expose_as_underscored].uniq
-            method_names.each do |method_name|
-              # Don't define a helper method if it would override something.
-              if method_defined?(method_name)
-                warn(
-                  "Unable to define a helper for argument with name '#{method_name}' "\
-                  "as this is a reserved name. If you're using an argument such as "\
-                  "`argument #{method_name}`, consider renaming this argument.`"
-                )
-              else
-                define_method(method_name) do
-                  # Always use `expose_as` here, since #[] doesn't accept underscored names
-                  self[expose_as]
+            if arg_definition.method_access?
+              expose_as = arg_definition.expose_as.to_s.freeze
+              expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as).freeze
+              method_names = [expose_as, expose_as_underscored].uniq
+              method_names.each do |method_name|
+                # Don't define a helper method if it would override something.
+                if method_defined?(method_name)
+                  warn(
+                    "Unable to define a helper for argument with name '#{method_name}' "\
+                    "as this is a reserved name. Add `method_access: false` to stop this warning."
+                  )
+                else
+                  define_method(method_name) do
+                    # Always use `expose_as` here, since #[] doesn't accept underscored names
+                    self[expose_as]
+                  end
                 end
               end
             end

data/lib/graphql/schema.rb

@@ -3,6 +3,7 @@ require "graphql/schema/base_64_encoder"
 require "graphql/schema/catchall_middleware"
 require "graphql/schema/default_parse_error"
 require "graphql/schema/default_type_error"
+require "graphql/schema/find_inherited_value"
 require "graphql/schema/finder"
 require "graphql/schema/invalid_type_error"
 require "graphql/schema/introspection_system"
@@ -81,6 +82,8 @@ module GraphQL
     extend Forwardable
     extend GraphQL::Schema::Member::AcceptsDefinition
     include GraphQL::Define::InstanceDefinable
+    extend GraphQL::Schema::FindInheritedValue
+
     accepts_definitions \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
@@ -159,7 +162,9 @@ module GraphQL
     # @see {Query#tracers} for query-specific tracers
     attr_reader :tracers
 
-    DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
+    DYNAMIC_FIELDS = ["__type", "__typename", "__schema"].freeze
+    EMPTY_ARRAY = [].freeze
+    EMPTY_HASH = {}.freeze
 
     attr_reader :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
 
@@ -728,11 +733,11 @@ module GraphQL
       end
 
       def use(plugin, options = {})
-        plugins << [plugin, options]
+        own_plugins << [plugin, options]
       end
 
       def plugins
-        @plugins ||= []
+        find_inherited_value(:plugins, EMPTY_ARRAY) + own_plugins
       end
 
       def to_graphql
@@ -746,7 +751,7 @@ module GraphQL
         schema_defn.max_depth = max_depth
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types
-        schema_defn.disable_introspection_entry_points = @disable_introspection_entry_points
+        schema_defn.disable_introspection_entry_points = disable_introspection_entry_points?
 
         prepped_dirs = {}
         directives.each { |k, v| prepped_dirs[k] = v.graphql_definition}
@@ -758,15 +763,15 @@ module GraphQL
         schema_defn.type_error = method(:type_error)
         schema_defn.context_class = context_class
         schema_defn.cursor_encoder = cursor_encoder
-        schema_defn.tracers.concat(defined_tracers)
-        schema_defn.query_analyzers.concat(defined_query_analyzers)
+        schema_defn.tracers.concat(tracers)
+        schema_defn.query_analyzers.concat(query_analyzers)
 
-        schema_defn.middleware.concat(defined_middleware)
-        schema_defn.multiplex_analyzers.concat(defined_multiplex_analyzers)
+        schema_defn.middleware.concat(all_middleware)
+        schema_defn.multiplex_analyzers.concat(multiplex_analyzers)
         schema_defn.query_execution_strategy = query_execution_strategy
         schema_defn.mutation_execution_strategy = mutation_execution_strategy
         schema_defn.subscription_execution_strategy = subscription_execution_strategy
-        defined_instrumenters.each do |step, insts|
+        all_instrumenters.each do |step, insts|
           insts.each do |inst|
             schema_defn.instrumenters[step] << inst
           end
@@ -774,10 +779,8 @@ module GraphQL
         lazy_classes.each do |lazy_class, value_method|
           schema_defn.lazy_methods.set(lazy_class, value_method)
         end
-        if @rescues
-          @rescues.each do |err_class, handler|
-            schema_defn.rescue_from(err_class, &handler)
-          end
+        rescues.each do |err_class, handler|
+          schema_defn.rescue_from(err_class, &handler)
         end
 
         if plugins.any?
@@ -806,7 +809,8 @@ module GraphQL
         if new_query_object
           @query_object = new_query_object
         else
-          @query_object.respond_to?(:graphql_definition) ? @query_object.graphql_definition : @query_object
+          query_object = @query_object || find_inherited_value(:query)
+          query_object.respond_to?(:graphql_definition) ? query_object.graphql_definition : query_object
         end
       end
 
@@ -814,7 +818,8 @@ module GraphQL
         if new_mutation_object
           @mutation_object = new_mutation_object
         else
-          @mutation_object.respond_to?(:graphql_definition) ? @mutation_object.graphql_definition : @mutation_object
+          mutation_object = @mutation_object || find_inherited_value(:mutation)
+          mutation_object.respond_to?(:graphql_definition) ? mutation_object.graphql_definition : mutation_object
         end
       end
 
@@ -822,7 +827,8 @@ module GraphQL
         if new_subscription_object
           @subscription_object = new_subscription_object
         else
-          @subscription_object.respond_to?(:graphql_definition) ? @subscription_object.graphql_definition : @subscription_object
+          subscription_object = @subscription_object || find_inherited_value(:subscription)
+          subscription_object.respond_to?(:graphql_definition) ? subscription_object.graphql_definition : subscription_object
         end
       end
 
@@ -830,7 +836,7 @@ module GraphQL
         if new_introspection_namespace
           @introspection = new_introspection_namespace
         else
-          @introspection
+          @introspection || find_inherited_value(:introspection)
         end
       end
 
@@ -838,14 +844,14 @@ module GraphQL
         if new_encoder
           @cursor_encoder = new_encoder
         end
-        @cursor_encoder || Base64Encoder
+        @cursor_encoder || find_inherited_value(:cursor_encoder, Base64Encoder)
       end
 
       def default_max_page_size(new_default_max_page_size = nil)
         if new_default_max_page_size
           @default_max_page_size = new_default_max_page_size
         else
-          @default_max_page_size
+          @default_max_page_size || find_inherited_value(:default_max_page_size)
         end
       end
 
@@ -853,7 +859,7 @@ module GraphQL
         if new_query_execution_strategy
           @query_execution_strategy = new_query_execution_strategy
         else
-          @query_execution_strategy || self.default_execution_strategy
+          @query_execution_strategy || find_inherited_value(:query_execution_strategy, self.default_execution_strategy)
         end
       end
 
@@ -861,7 +867,7 @@ module GraphQL
         if new_mutation_execution_strategy
           @mutation_execution_strategy = new_mutation_execution_strategy
         else
-          @mutation_execution_strategy || self.default_execution_strategy
+          @mutation_execution_strategy || find_inherited_value(:mutation_execution_strategy, self.default_execution_strategy)
         end
       end
 
@@ -869,7 +875,7 @@ module GraphQL
         if new_subscription_execution_strategy
           @subscription_execution_strategy = new_subscription_execution_strategy
         else
-          @subscription_execution_strategy || self.default_execution_strategy
+          @subscription_execution_strategy || find_inherited_value(:subscription_execution_strategy, self.default_execution_strategy)
         end
       end
 
@@ -877,7 +883,7 @@ module GraphQL
         if max_complexity
           @max_complexity = max_complexity
         else
-          @max_complexity
+          @max_complexity || find_inherited_value(:max_complexity)
         end
       end
 
@@ -885,7 +891,7 @@ module GraphQL
         if !new_error_bubbling.nil?
           @error_bubbling = new_error_bubbling
         else
-          @error_bubbling
+          @error_bubbling.nil? ? find_inherited_value(:error_bubbling) : @error_bubbling
         end
       end
 
@@ -893,7 +899,7 @@ module GraphQL
         if new_max_depth
           @max_depth = new_max_depth
         else
-          @max_depth
+          @max_depth || find_inherited_value(:max_depth)
         end
       end
 
@@ -901,12 +907,20 @@ module GraphQL
         @disable_introspection_entry_points = true
       end
 
+      def disable_introspection_entry_points?
+        if instance_variable_defined?(:@disable_introspection_entry_points)
+          @disable_introspection_entry_points
+        else
+          find_inherited_value(:disable_introspection_entry_points?, false)
+        end
+      end
+
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
-          @orphan_types = new_orphan_types.flatten
-        else
-          @orphan_types || []
+          own_orphan_types.concat(new_orphan_types.flatten)
         end
+
+        find_inherited_value(:orphan_types, EMPTY_ARRAY) + own_orphan_types
       end
 
       def default_execution_strategy
@@ -921,17 +935,20 @@ module GraphQL
         if new_context_class
           @context_class = new_context_class
         else
-          @context_class || GraphQL::Query::Context
+          @context_class || find_inherited_value(:context_class, GraphQL::Query::Context)
         end
       end
 
       def rescue_from(*err_classes, &handler_block)
-        @rescues ||= {}
         err_classes.each do |err_class|
-          @rescues[err_class] = handler_block
+          own_rescues[err_class] = handler_block
         end
       end
 
+      def rescues
+        find_inherited_value(:rescues, EMPTY_HASH).merge(own_rescues)
+      end
+
       def resolve_type(type, obj, ctx)
         if type.kind.object?
           type
@@ -1017,19 +1034,20 @@ module GraphQL
         else
           instrument_step
         end
-        defined_instrumenters[step] << instrumenter
+
+        own_instrumenters[step] << instrumenter
       end
 
       def directives(new_directives = nil)
         if new_directives
-          @directives = new_directives.reduce({}) { |m, d| m[d.name] = d; m }
+          new_directives.each {|d| directive(d) }
         end
 
-        @directives ||= default_directives
+        find_inherited_value(:directives, default_directives).merge(own_directives)
       end
 
       def directive(new_directive)
-        directives[new_directive.graphql_name] = new_directive
+        own_directives[new_directive.graphql_name] = new_directive
       end
 
       def default_directives
@@ -1041,26 +1059,38 @@ module GraphQL
       end
 
       def tracer(new_tracer)
-        defined_tracers << new_tracer
+        own_tracers << new_tracer
+      end
+
+      def tracers
+        find_inherited_value(:tracers, EMPTY_ARRAY) + own_tracers
       end
 
       def query_analyzer(new_analyzer)
         if new_analyzer == GraphQL::Authorization::Analyzer
           warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
         end
-        defined_query_analyzers << new_analyzer
+        own_query_analyzers << new_analyzer
+      end
+
+      def query_analyzers
+        find_inherited_value(:query_analyzers, EMPTY_ARRAY) + own_query_analyzers
       end
 
       def middleware(new_middleware = nil)
         if new_middleware
-          defined_middleware << new_middleware
+          own_middleware << new_middleware
         else
           graphql_definition.middleware
         end
       end
 
       def multiplex_analyzer(new_analyzer)
-        defined_multiplex_analyzers << new_analyzer
+        own_multiplex_analyzers << new_analyzer
+      end
+
+      def multiplex_analyzers
+        find_inherited_value(:multiplex_analyzers, EMPTY_ARRAY) + own_multiplex_analyzers
       end
 
       private
@@ -1069,24 +1099,51 @@ module GraphQL
         @lazy_classes ||= {}
       end
 
-      def defined_instrumenters
-        @defined_instrumenters ||= Hash.new { |h,k| h[k] = [] }
+      def own_plugins
+        @own_plugins ||= []
+      end
+
+      def own_rescues
+        @own_rescues ||= {}
       end
 
-      def defined_tracers
-        @defined_tracers ||= []
+      def own_orphan_types
+        @own_orphan_types ||= []
       end
 
-      def defined_query_analyzers
+      def own_directives
+        @own_directives ||= {}
+      end
+
+      def all_instrumenters
+        inherited_instrumenters = find_inherited_value(:all_instrumenters) || Hash.new { |h,k| h[k] = [] }
+        inherited_instrumenters.merge(own_instrumenters) do |_step, inherited, own|
+          inherited + own
+        end
+      end
+
+      def own_instrumenters
+        @own_instrumenters ||= Hash.new { |h,k| h[k] = [] }
+      end
+
+      def own_tracers
+        @own_tracers ||= []
+      end
+
+      def own_query_analyzers
         @defined_query_analyzers ||= []
       end
 
-      def defined_middleware
-        @defined_middleware ||= []
+      def all_middleware
+        find_inherited_value(:all_middleware, EMPTY_ARRAY) + own_middleware
+      end
+
+      def own_middleware
+        @own_middleware ||= []
       end
 
-      def defined_multiplex_analyzers
-        @defined_multiplex_analyzers ||= []
+      def own_multiplex_analyzers
+        @own_multiplex_analyzers ||= []
       end
 
       # Given this schema member, find the class-based definition object