graphql 1.12.20 → 1.13.1

data/lib/graphql/language/parser.y

@@ -325,8 +325,9 @@ rule
     | EXTEND TYPE name implements { result = make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: [], fields: [], position_source: val[0]) }
 
   interface_type_extension:
-      EXTEND INTERFACE name directives_list_opt LCURLY field_definition_list RCURLY { result = make_node(:InterfaceTypeExtension, name: val[2], directives: val[3], fields: val[5], position_source: val[0]) }
-    | EXTEND INTERFACE name directives_list { result = make_node(:InterfaceTypeExtension, name: val[2], directives: val[3], fields: [], position_source: val[0]) }
+      EXTEND INTERFACE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY { result = make_node(:InterfaceTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: val[6], position_source: val[0]) }
+    | EXTEND INTERFACE name implements_opt directives_list { result = make_node(:InterfaceTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: [], position_source: val[0]) }
+    | EXTEND INTERFACE name implements { result = make_node(:InterfaceTypeExtension, name: val[2], interfaces: val[3], directives: [], fields: [], position_source: val[0]) }
 
   union_type_extension:
       EXTEND UNION name directives_list_opt EQUALS union_members { result = make_node(:UnionTypeExtension, name: val[2], directives: val[3], types: val[5], position_source: val[0]) }
@@ -397,8 +398,8 @@ rule
     | field_definition_list field_definition { val[0] << val[1] }
 
   interface_type_definition:
-      description_opt INTERFACE name directives_list_opt LCURLY field_definition_list RCURLY {
-        result = make_node(:InterfaceTypeDefinition, name: val[2], directives: val[3], fields: val[5], description: val[0] || get_description(val[1]), definition_line: val[1].line, position_source: val[0] || val[1])
+      description_opt INTERFACE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY {
+        result = make_node(:InterfaceTypeDefinition, name: val[2], interfaces: val[3], directives: val[4], fields: val[6], description: val[0] || get_description(val[1]), definition_line: val[1].line, position_source: val[0] || val[1])
       }
 
   union_members:

data/lib/graphql/language/printer.rb

@@ -164,11 +164,15 @@ module GraphQL
       def print_object_type_definition(object_type)
         out = print_description(object_type)
         out << "type #{object_type.name}"
-        out << " implements " << object_type.interfaces.map(&:name).join(" & ") unless object_type.interfaces.empty?
+        out << print_implements(object_type) unless object_type.interfaces.empty?
         out << print_directives(object_type.directives)
         out << print_field_definitions(object_type.fields)
       end
 
+      def print_implements(type)
+        " implements #{type.interfaces.map(&:name).join(" & ")}"
+      end
+
       def print_input_value_definition(input_value)
         out = "#{input_value.name}: #{print_node(input_value.type)}".dup
         out << " = #{print_node(input_value.default_value)}" unless input_value.default_value.nil?
@@ -200,6 +204,7 @@ module GraphQL
       def print_interface_type_definition(interface_type)
         out = print_description(interface_type)
         out << "interface #{interface_type.name}"
+        out << print_implements(interface_type) if interface_type.interfaces.any?
         out << print_directives(interface_type.directives)
         out << print_field_definitions(interface_type.fields)
       end

data/lib/graphql/language/sanitized_printer.rb

@@ -79,7 +79,7 @@ module GraphQL
 
         arg_owner = @current_input_type || @current_directive || @current_field
         old_current_argument = @current_argument
-        @current_argument = arg_owner.arguments[argument.name]
+        @current_argument = arg_owner.get_argument(argument.name, @query.context)
 
         old_input_type = @current_input_type
         @current_input_type = @current_argument.type.non_null? ? @current_argument.type.of_type : @current_argument.type
@@ -113,7 +113,7 @@ module GraphQL
       end
 
       def print_field(field, indent: "")
-        @current_field = query.schema.get_field(@current_type, field.name)
+        @current_field = query.get_field(@current_type, field.name)
         old_type = @current_type
         @current_type = @current_field.type.unwrap
         res = super
@@ -125,7 +125,7 @@ module GraphQL
         old_type = @current_type
 
         if inline_fragment.type
-          @current_type = query.schema.types[inline_fragment.type.name]
+          @current_type = query.get_type(inline_fragment.type.name)
         end
 
         res = super
@@ -137,7 +137,7 @@ module GraphQL
 
       def print_fragment_definition(fragment_def, indent: "")
         old_type = @current_type
-        @current_type = query.schema.types[fragment_def.type.name]
+        @current_type = query.get_type(fragment_def.type.name)
 
         res = super
 
@@ -193,7 +193,7 @@ module GraphQL
           end
 
           arguments = value.map do |key, val|
-            sub_type = type.arguments[key.to_s].type
+            sub_type = type.get_argument(key.to_s, @query.context).type
 
             GraphQL::Language::Nodes::Argument.new(
               name: key.to_s,

data/lib/graphql/language/token.rb

@@ -4,10 +4,6 @@ module GraphQL
     # Emitted by the lexer and passed to the parser.
     # Contains type, value and position data.
     class Token
-      if !String.method_defined?(:-@)
-        using GraphQL::StringDedupBackport
-      end
-
       # @return [Symbol] The kind of token this is
       attr_reader :name
       # @return [String] The text of this token

data/lib/graphql/name_validator.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
   class NameValidator
-    if !String.method_defined?(:match?)
-      using GraphQL::StringMatchBackport
-    end
-
     VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
 
     def self.validate!(name)

data/lib/graphql/query/arguments.rb

@@ -9,7 +9,7 @@ module GraphQL
       include GraphQL::Dig
 
       def self.construct_arguments_class(argument_owner)
-        argument_definitions = argument_owner.arguments
+        argument_definitions = argument_owner.arguments # rubocop:disable Development/ContextIsPassedCop -- legacy-related
         argument_owner.arguments_class = Class.new(self) do
           self.argument_owner = argument_owner
           self.argument_definitions = argument_definitions

data/lib/graphql/query/arguments_cache.rb

@@ -7,7 +7,7 @@ module GraphQL
         Hash.new do |h1, irep_or_ast_node|
           h1[irep_or_ast_node] = Hash.new do |h2, definition|
             ast_node = irep_or_ast_node.is_a?(GraphQL::InternalRepresentation::Node) ? irep_or_ast_node.ast_node : irep_or_ast_node
-            h2[definition] = if definition.arguments.empty?
+            h2[definition] = if definition.arguments(query.context).empty?
               GraphQL::Query::Arguments::NO_ARGS
             else
               GraphQL::Query::LiteralInput.from_arguments(

data/lib/graphql/query/context.rb

@@ -156,8 +156,13 @@ module GraphQL
         @scoped_context = {}
       end
 
+      # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
+      def response_extensions
+        namespace(:__query_result_extensions__)
+      end
+
       def dataloader
-        @dataloader ||= query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new
+        @dataloader ||= self[:dataloader] || (query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new)
       end
 
       # @api private
@@ -223,9 +228,12 @@ module GraphQL
 
       # @return [GraphQL::Schema::Warden]
       def warden
-        @warden ||= @query.warden
+        @warden ||= (@query && @query.warden)
       end
 
+      # @api private
+      attr_writer :warden
+
       # Get an isolated hash for `ns`. Doesn't affect user-provided storage.
       # @param ns [Object] a usage-specific namespace identifier
       # @return [Hash] namespaced storage
@@ -233,6 +241,11 @@ module GraphQL
         @storage[ns]
       end
 
+      # @return [Boolean] true if this namespace was accessed before
+      def namespace?(ns)
+        @storage.key?(ns)
+      end
+
       def inspect
         "#<Query::Context ...>"
       end

data/lib/graphql/query/literal_input.rb

@@ -62,7 +62,7 @@ module GraphQL
           raise ArgumentError, "Unexpected ast_arguments: #{ast_arguments}"
         end
 
-        argument_defns = argument_owner.arguments
+        argument_defns = argument_owner.arguments(context || GraphQL::Query::NullContext)
         argument_defns.each do |arg_name, arg_defn|
           ast_arg = indexed_arguments[arg_name]
           # First, check the argument in the AST.

data/lib/graphql/query/null_context.rb

@@ -4,9 +4,11 @@ module GraphQL
     # This object can be `ctx` in places where there is no query
     class NullContext
       class NullWarden < GraphQL::Schema::Warden
-        def visible?(t); true; end
-        def visible_field?(t); true; end
-        def visible_type?(t); true; end
+        def visible_field?(field, ctx); true; end
+        def visible_argument?(arg, ctx); true; end
+        def visible_type?(type, ctx); true; end
+        def visible_enum_value?(ev, ctx); true; end
+        def visible_type_membership?(tm, ctx); true; end
       end
 
       class NullQuery
@@ -15,12 +17,15 @@ module GraphQL
         end
       end
 
+      class NullSchema < GraphQL::Schema
+      end
+
       attr_reader :schema, :query, :warden, :dataloader
 
       def initialize
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
-        @schema = GraphQL::Schema.new
+        @schema = NullSchema
         @warden = NullWarden.new(
           GraphQL::Filter.new,
           context: self,
@@ -31,7 +36,7 @@ module GraphQL
       def [](key); end
 
       def interpreter?
-        false
+        true
       end
 
       class << self
@@ -40,10 +45,10 @@ module GraphQL
         def [](key); end
 
         def instance
-          @instance = self.new
+          @instance ||= self.new
         end
 
-        def_delegators :instance, :query, :schema, :warden, :interpreter?, :dataloader
+        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader
       end
     end
   end

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -81,7 +81,7 @@ module GraphQL
         # is added to the "errors" key.
         def get_raw_value
           begin
-            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx])
+            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx]) # rubocop:disable Development/ContextIsPassedCop -- unrelated
           rescue GraphQL::ExecutionError => err
             err
           end

data/lib/graphql/query/variables.rb

@@ -45,7 +45,11 @@ module GraphQL
                   end
                 elsif default_value != nil
                   memo[variable_name] = if ctx.interpreter?
-                    default_value
+                    if default_value.is_a?(Language::Nodes::NullValue)
+                      nil
+                    else
+                      default_value
+                    end
                   else
                     # Add the variable if it wasn't provided but it has a default value (including `null`)
                     GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)

data/lib/graphql/relay/edges_instrumentation.rb

@@ -16,7 +16,6 @@ module GraphQL
         end
       end
 
-
       class EdgesResolve
         def initialize(edge_class:, resolve:)
           @edge_class = edge_class

data/lib/graphql/relay/global_id_resolve.rb

@@ -10,7 +10,7 @@ module GraphQL
         if obj.is_a?(GraphQL::Schema::Object)
           obj = obj.object
         end
-        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition : @type
+        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition(silence_deprecation_warning: true) : @type
         ctx.query.schema.id_from_object(obj, type, ctx)
       end
     end

data/lib/graphql/relay/page_info.rb

@@ -2,6 +2,6 @@
 module GraphQL
   module Relay
     # Wrap a Connection and expose its page info
-    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition
+    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition(silence_deprecation_warning: true)
   end
 end

data/lib/graphql/rubocop/graphql/base_cop.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require "rubocop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      class BaseCop < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        # Return the source of `send_node`, but without the keyword argument represented by `pair_node`
+        def source_without_keyword_argument(send_node, pair_node)
+          # work back to the preceeding comma
+          first_pos = pair_node.location.expression.begin_pos
+          end_pos = pair_node.location.expression.end_pos
+          node_source = send_node.source_range.source
+          node_first_pos = send_node.location.expression.begin_pos
+
+          relative_first_pos = first_pos - node_first_pos
+          relative_last_pos = end_pos - node_first_pos
+
+          begin_removal_pos = relative_first_pos
+          while node_source[begin_removal_pos] != ","
+            begin_removal_pos -= 1
+            if begin_removal_pos < 1
+              raise "Invariant: somehow backtracked to beginning of node looking for a comma (node source: #{node_source.inspect})"
+            end
+          end
+
+          end_removal_pos = relative_last_pos
+          cleaned_node_source = node_source[0...begin_removal_pos] + node_source[end_removal_pos..-1]
+          cleaned_node_source
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop/graphql/default_null_true.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative "base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any field configuration which duplicates
+      # the default `null: true` property.
+      #
+      # `null: true` is default because nullable fields can always be converted
+      # to non-null fields (`null: false`) without a breaking change. (The opposite change, from `null: false`
+      # to `null: true`, change.)
+      #
+      # @example
+      #   # Both of these define `name: String` in GraphQL:
+      #
+      #   # bad
+      #   field :name, String, null: true
+      #
+      #   # good
+      #   field :name, String
+      #
+      class DefaultNullTrue < BaseCop
+        MSG = "`null: true` is the default and can be removed."
+
+        def_node_matcher :field_config_with_null_true?, <<-Pattern
+        (
+          send nil? :field ... (hash $(pair (sym :null) (true)) ...)
+        )
+        Pattern
+
+        def on_send(node)
+          field_config_with_null_true?(node) do |null_config|
+            add_offense(null_config) do |corrector|
+              cleaned_node_source = source_without_keyword_argument(node, null_config)
+              corrector.replace(node.source_range, cleaned_node_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop/graphql/default_required_true.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative "./base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any argument configuration which duplicates
+      # the default `required: true` property.
+      #
+      # `required: true` is default because required arguments can always be converted
+      # to optional arguments (`required: false`) without a breaking change. (The opposite change, from `required: false`
+      # to `required: true`, change.)
+      #
+      # @example
+      #   # Both of these define `id: ID!` in GraphQL:
+      #
+      #   # bad
+      #   argument :id, ID, required: true
+      #
+      #   # good
+      #   argument :id, ID
+      #
+      class DefaultRequiredTrue < BaseCop
+        MSG = "`required: true` is the default and can be removed."
+
+        def_node_matcher :argument_config_with_required_true?, <<-Pattern
+        (
+          send nil? :argument ... (hash <$(pair (sym :required) (true)) ...>)
+        )
+        Pattern
+
+        def on_send(node)
+          argument_config_with_required_true?(node) do |required_config|
+            add_offense(required_config) do |corrector|
+                cleaned_node_source = source_without_keyword_argument(node, required_config)
+                corrector.replace(node, cleaned_node_source)
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "graphql/rubocop/graphql/default_null_true"
+require "graphql/rubocop/graphql/default_required_true"

data/lib/graphql/schema/addition.rb

@@ -24,7 +24,13 @@ module GraphQL
       end
 
       def get_type(name)
-        @types[name] || @schema.get_type(name)
+        local_type = @types[name]
+        # This isn't really sophisticated, but
+        # I think it's good enough to support the current usage of LateBoundTypes
+        if local_type.is_a?(Array)
+          local_type = local_type.first
+        end
+        local_type || @schema.get_type(name)
       end
 
       # Lookup using `own_types` here because it's ok to override
@@ -77,13 +83,13 @@ module GraphQL
 
       def update_type_owner(owner, type)
         case owner
-        when Class
+        when Module
           if owner.kind.union?
             # It's a union with possible_types
             # Replace the item by class name
             owner.assign_type_membership_object_type(type)
             @possible_types[owner.graphql_name] = owner.possible_types
-          elsif type.kind.interface? && owner.kind.object?
+          elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
             new_interfaces = []
             owner.interfaces.each do |int_t|
               if int_t.is_a?(String) && int_t == type.graphql_name
@@ -98,12 +104,11 @@ module GraphQL
             owner.implements(*new_interfaces)
             new_interfaces.each do |int|
               pt = @possible_types[int.graphql_name] ||= []
-              if !pt.include?(owner)
+              if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
             end
           end
-
         when nil
           # It's a root type
           @types[type.graphql_name] = type
@@ -148,42 +153,42 @@ module GraphQL
           um << owner
         end
 
-        if (prev_type = get_local_type(type.graphql_name))
-          if prev_type != type
-            raise DuplicateTypeNamesError.new(
-              type_name: type.graphql_name,
-              first_definition: prev_type,
-              second_definition: type,
-              path: path,
-            )
-          else
-            # This type was already added
-          end
+        if (prev_type = get_local_type(type.graphql_name)) && prev_type == type
+          # No need to re-visit
         elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
           @directives << type
-          type.arguments.each do |name, arg|
+          type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
             references_to(arg_type, from: arg)
-            add_type(arg_type, owner: arg, late_types: late_types, path: path + [name])
+            add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
             if arg.default_value?
               @arguments_with_default_values << arg
             end
           end
         else
-          @types[type.graphql_name] = type
+          prev_type = @types[type.graphql_name]
+          if prev_type.nil?
+            @types[type.graphql_name] = type
+          elsif prev_type.is_a?(Array)
+            prev_type << type
+          else
+            @types[type.graphql_name] = [prev_type, type]
+          end
+
           add_directives_from(type)
           if type.kind.fields?
-            type.fields.each do |name, field|
+            type.all_field_definitions.each do |field|
+              name = field.graphql_name
               field_type = field.type.unwrap
               references_to(field_type, from: field)
               field_path = path + [name]
               add_type(field_type, owner: field, late_types: late_types, path: field_path)
               add_directives_from(field)
-              field.arguments.each do |arg_name, arg|
+              field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
                 references_to(arg_type, from: arg)
-                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg_name])
+                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg.graphql_name])
                 if arg.default_value?
                   @arguments_with_default_values << arg
                 end
@@ -191,19 +196,19 @@ module GraphQL
             end
           end
           if type.kind.input_object?
-            type.arguments.each do |arg_name, arg|
+            type.all_argument_definitions.each do |arg|
               add_directives_from(arg)
               arg_type = arg.type.unwrap
               references_to(arg_type, from: arg)
-              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg_name])
+              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
               if arg.default_value?
                 @arguments_with_default_values << arg
               end
             end
           end
           if type.kind.union?
-            @possible_types[type.graphql_name] = type.possible_types
-            type.possible_types.each do |t|
+            @possible_types[type.graphql_name] = type.all_possible_types
+            type.all_possible_types.each do |t|
               add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
             end
           end
@@ -213,13 +218,17 @@ module GraphQL
             end
           end
           if type.kind.object?
-            @possible_types[type.graphql_name] = [type]
+            possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
+            possible_types_for_this_name << type
+          end
+
+          if type.kind.object? || type.kind.interface?
             type.interface_type_memberships.each do |interface_type_membership|
               case interface_type_membership
               when Schema::TypeMembership
                 interface_type = interface_type_membership.abstract_type
                 # We can get these now; we'll have to get late-bound types later
-                if interface_type.is_a?(Module)
+                if interface_type.is_a?(Module) && type.is_a?(Class)
                   implementers = @possible_types[interface_type.graphql_name] ||= []
                   implementers << type
                 end

data/lib/graphql/schema/argument.rb

@@ -2,10 +2,6 @@
 module GraphQL
   class Schema
     class Argument
-      if !String.method_defined?(:-@)
-        using GraphQL::StringDedupBackport
-      end
-
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
@@ -52,7 +48,7 @@ module GraphQL
       # @param directives [Hash{Class => Hash}]
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, &definition_block)
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
@@ -86,6 +82,10 @@ module GraphQL
         end
       end
 
+      def inspect
+        "#<#{self.class} #{path}: #{type.to_type_signature}#{description ? " @description=#{description.inspect}" : ""}>"
+      end
+
       # @return [Object] the value used when the client doesn't provide a value for this argument
       attr_reader :default_value
 
@@ -147,7 +147,7 @@ module GraphQL
             end
           end
         elsif as_type.kind.input_object?
-          as_type.arguments.each do |_name, input_obj_arg|
+          as_type.arguments(ctx).each do |_name, input_obj_arg|
             input_obj_arg = input_obj_arg.type_class
             # TODO: this skips input objects whose values were alread replaced with application objects.
             # See: https://github.com/rmosolgo/graphql-ruby/issues/2633
@@ -161,6 +161,8 @@ module GraphQL
         true
       end
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       def to_graphql
         argument = GraphQL::Argument.new
         argument.name = @name

data/lib/graphql/schema/build_from_definition.rb

@@ -3,12 +3,7 @@ require "graphql/schema/build_from_definition/resolve_map"
 
 module GraphQL
   class Schema
-    # TODO Populate `.directive(...)` from here
     module BuildFromDefinition
-      if !String.method_defined?(:-@)
-        using GraphQL::StringDedupBackport
-      end
-
       class << self
         # @see {Schema.from_definition}
         def from_definition(definition_string, parser: GraphQL.default_parser, **kwargs)
@@ -394,6 +389,11 @@ module GraphQL
             include GraphQL::Schema::Interface
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
+            interface_type_definition.interfaces.each do |interface_name|
+              "Implements: #{interface_type_definition} -> #{interface_name}"
+              interface_defn = type_resolver.call(interface_name)
+              implements(interface_defn)
+            end
             ast_node(interface_type_definition)
             builder.build_directives(self, interface_type_definition, type_resolver)
 

data/lib/graphql/schema/directive/feature.rb

@@ -42,7 +42,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :flag, String, required: true,
+        argument :flag, String,
           description: "The name of the feature to check before continuing"
 
         # Implement the Directive API