graphql 2.1.1 → 2.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9997a74f471a1d4abbca1fe24f276db80bbad6f87b278a8083491ced64354906
-  data.tar.gz: 4265a7d1e76f784ad3df4739328fedfae1698e26dc4a1fee982971650e553c47
+  metadata.gz: ab900a93fdb2a8326a75035bf03e27e4874cc959c916d9ac8f85602c78f55c53
+  data.tar.gz: ca2c67da2b27b4a661759f5e00b49178d12ae312f77d536959e7d825ecd516af
 SHA512:
-  metadata.gz: 2b1c5bed0660b9c194814e889384b3a37a27967c1f808aff55e693431056729434a2556cf85e9dd4c184262f8ad1344fe86316c3ffa12afc2c87315d69773f04
-  data.tar.gz: 0b2c961d00651a479ce183e0c77d23d2090df85f46490aac53d724d0f657f9cfe1c49bda191feec4b3a90f1cf671cd55f0a6a97d0c79c20d567fc47e214f921d
+  metadata.gz: 47639dd694f5c027bd05a2b4fae198fad2b98154ba024785f6fcd844917be5b9bf841ed82b1753061ba9890c5881a8082a62e619090492c7247b345163f45322
+  data.tar.gz: df76cec39f5bba1ab58958595d508869fd70610feea72af54ff40c0cd4649b8a9bc6ad6d891907b9b69fc517602bf50057d86dab563223988fb5f4ccd2763c0b

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

@@ -28,17 +28,22 @@ module GraphQL
         def initialize(query)
           @max_depth = 0
           @current_depth = 0
+          @count_introspection_fields = query.schema.count_introspection_fields
           super
         end
 
         def on_enter_field(node, parent, visitor)
-          return if visitor.skipping? || visitor.visiting_fragment_definition?
+          return if visitor.skipping? ||
+            visitor.visiting_fragment_definition? ||
+              (@count_introspection_fields == false && visitor.field_definition.introspection?)
 
           @current_depth += 1
         end
 
         def on_leave_field(node, parent, visitor)
-          return if visitor.skipping? || visitor.visiting_fragment_definition?
+          return if visitor.skipping? ||
+            visitor.visiting_fragment_definition? ||
+            (@count_introspection_fields == false && visitor.field_definition.introspection?)
 
           if @max_depth < @current_depth
             @max_depth = @current_depth

data/lib/graphql/dataloader.rb

@@ -61,6 +61,32 @@ module GraphQL
       @nonblocking
     end
 
+    # This is called before the fiber is spawned, from the parent context (i.e. from
+    # the thread or fiber that it is scheduled from).
+    #
+    # @return [Hash<Symbol, Object>] Current fiber-local variables
+    def get_fiber_variables
+      fiber_vars = {}
+      Thread.current.keys.each do |fiber_var_key|
+        # This variable should be fresh in each new fiber
+        if fiber_var_key != :__graphql_runtime_info
+          fiber_vars[fiber_var_key] = Thread.current[fiber_var_key]
+        end
+      end
+      fiber_vars
+    end
+
+    # Set up the fiber variables in a new fiber.
+    #
+    # This is called within the fiber, right after it is spawned.
+    #
+    # @param vars [Hash<Symbol, Object>] Fiber-local variables from {get_fiber_variables}
+    # @return [void]
+    def set_fiber_variables(vars)
+      vars.each { |k, v| Thread.current[k] = v }
+      nil
+    end
+
     # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
     #
     # @param source_class [Class<GraphQL::Dataloader::Source]
@@ -295,23 +321,16 @@ module GraphQL
     #
     # @see https://github.com/rmosolgo/graphql-ruby/issues/3449
     def spawn_fiber
-      fiber_locals = {}
-
-      Thread.current.keys.each do |fiber_var_key|
-        # This variable should be fresh in each new fiber
-        if fiber_var_key != :__graphql_runtime_info
-          fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
-        end
-      end
+      fiber_vars = get_fiber_variables
 
       if @nonblocking
         Fiber.new(blocking: false) do
-          fiber_locals.each { |k, v| Thread.current[k] = v }
+          set_fiber_variables(fiber_vars)
           yield
         end
       else
         Fiber.new do
-          fiber_locals.each { |k, v| Thread.current[k] = v }
+          set_fiber_variables(fiber_vars)
           yield
         end
       end

data/lib/graphql/execution/interpreter/runtime/graphql_result.rb

@@ -107,7 +107,7 @@ module GraphQL
               when GraphQLResultArray
                 # There's no special handling of arrays because currently, there's no way to split the execution
                 # of a list over several concurrent flows.
-                next_result.set_child_result(key, value)
+                into_result.set_child_result(key, value)
               else
                 # We have to assume that, since this passed the `fields_will_merge` selection,
                 # that the old and new values are the same.

data/lib/graphql/execution/interpreter/runtime.rb

@@ -52,13 +52,6 @@ module GraphQL
           # { Class => Boolean }
           @lazy_cache = {}
           @lazy_cache.compare_by_identity
-
-          @gathered_selections_cache = Hash.new { |h, k|
-            cache = {}
-            cache.compare_by_identity
-            h[k] = cache
-          }
-          @gathered_selections_cache.compare_by_identity
         end
 
         def final_result
@@ -98,7 +91,7 @@ module GraphQL
             @response = nil
           else
             call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
-              gathered_selections = gather_selections(runtime_object, root_type, nil, root_operation.selections)
+              gathered_selections = gather_selections(runtime_object, root_type, root_operation.selections)
               # This is kind of a hack -- `gathered_selections` is an Array if any of the selections
               # require isolation during execution (because of runtime directives). In that case,
               # make a new, isolated result hash for writing the result into. (That isolated response
@@ -143,18 +136,11 @@ module GraphQL
           nil
         end
 
-        def gather_selections(owner_object, owner_type, ast_node_for_caching, selections, selections_to_run = nil, selections_by_name = nil)
-          if ast_node_for_caching && (cached_selections = @gathered_selections_cache[ast_node_for_caching][owner_type])
-            return cached_selections
-          end
-          selections_by_name ||= {} # allocate this default here so we check the cache first
-
-          should_cache = true
+        def gather_selections(owner_object, owner_type, selections, selections_to_run = nil, selections_by_name = {})
 
           selections.each do |node|
             # Skip gathering this if the directive says so
             if !directives_include?(node, owner_object, owner_type)
-              should_cache = false
               next
             end
 
@@ -179,7 +165,6 @@ module GraphQL
               if @runtime_directive_names.any? && node.directives.any? { |d| @runtime_directive_names.include?(d.name) }
                 next_selections = {}
                 next_selections[:graphql_directives] = node.directives
-                should_cache = false
                 if selections_to_run
                   selections_to_run << next_selections
                 else
@@ -197,28 +182,24 @@ module GraphQL
                   type_defn = schema.get_type(node.type.name, context)
 
                   if query.warden.possible_types(type_defn).include?(owner_type)
-                    gather_selections(owner_object, owner_type, nil, node.selections, selections_to_run, next_selections)
+                    gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
                   end
                 else
                   # it's an untyped fragment, definitely continue
-                  gather_selections(owner_object, owner_type, nil, node.selections, selections_to_run, next_selections)
+                  gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
                 end
               when GraphQL::Language::Nodes::FragmentSpread
                 fragment_def = query.fragments[node.name]
                 type_defn = query.get_type(fragment_def.type.name)
                 if query.warden.possible_types(type_defn).include?(owner_type)
-                  gather_selections(owner_object, owner_type, nil, fragment_def.selections, selections_to_run, next_selections)
+                  gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
                 end
               else
                 raise "Invariant: unexpected selection class: #{node.class}"
               end
             end
           end
-          result = selections_to_run || selections_by_name
-          if should_cache
-            @gathered_selections_cache[ast_node_for_caching][owner_type] = result
-          end
-          result
+          selections_to_run || selections_by_name
         end
 
         NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
@@ -619,7 +600,7 @@ module GraphQL
                 response_hash = GraphQLResultHash.new(result_name, selection_result, is_non_null)
                 set_result(selection_result, result_name, response_hash, true, is_non_null)
 
-                gathered_selections = gather_selections(continue_value, current_type, ast_node, next_selections)
+                gathered_selections = gather_selections(continue_value, current_type, next_selections)
                 # There are two possibilities for `gathered_selections`:
                 # 1. All selections of this object should be evaluated together (there are no runtime directives modifying execution).
                 #    This case is handled below, and the result can be written right into the main `response_hash` above.

data/lib/graphql/execution/lookahead.rb

@@ -80,6 +80,22 @@ module GraphQL
         selection(field_name, selected_type: selected_type, arguments: arguments).selected?
       end
 
+      # True if this node has a selection with alias matching `alias_name`.
+      # If `alias_name` is a String, it is treated as a GraphQL-style (camelized)
+      # field name and used verbatim. If `alias_name` is a Symbol, it is
+      # treated as a Ruby-style (underscored) name and camelized before comparing.
+      #
+      # If `arguments:` is provided, each provided key/value will be matched
+      # against the arguments in the next selection. This method will return false
+      # if any of the given `arguments:` are not present and matching in the next selection.
+      # (But, the next selection may contain _more_ than the given arguments.)
+      # @param alias_name [String, Symbol]
+      # @param arguments [Hash] Arguments which must match in the selection
+      # @return [Boolean]
+      def selects_alias?(alias_name, arguments: nil)
+        alias_selection(alias_name, arguments: arguments).selected?
+      end
+
       # @return [Boolean] True if this lookahead represents a field that was requested
       def selected?
         true
@@ -105,6 +121,7 @@ module GraphQL
               .tap(&:flatten!)
           end
 
+
           if (match_by_orig_name = all_fields.find { |f| f.original_name == field_name })
             match_by_orig_name
           else
@@ -114,23 +131,29 @@ module GraphQL
             @query.get_field(selected_type, guessed_name)
           end
         end
+        lookahead_for_selection(next_field_defn, selected_type, arguments)
+      end
 
-        if next_field_defn
-          next_nodes = []
-          @ast_nodes.each do |ast_node|
-            ast_node.selections.each do |selection|
-              find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
-            end
-          end
+      # Like {#selection}, but for aliases.
+      # It returns a null object (check with {#selected?})
+      # @return [GraphQL::Execution::Lookahead]
+      def alias_selection(alias_name, selected_type: @selected_type, arguments: nil)
+        alias_cache_key = [alias_name, arguments]
+        return alias_selections[key] if alias_selections.key?(alias_name)
 
-          if next_nodes.any?
-            Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
-          else
-            NULL_LOOKAHEAD
-          end
-        else
-          NULL_LOOKAHEAD
+        alias_node = lookup_alias_node(ast_nodes, alias_name)
+        return NULL_LOOKAHEAD unless alias_node
+
+        next_field_defn = @query.get_field(selected_type, alias_node.name)
+
+        alias_arguments = @query.arguments_for(alias_node, next_field_defn)
+        if alias_arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments)
+          alias_arguments = alias_arguments.keyword_arguments
         end
+
+        return NULL_LOOKAHEAD if arguments && arguments != alias_arguments
+
+        alias_selections[alias_cache_key] = lookahead_for_selection(next_field_defn, selected_type, alias_arguments, alias_name)
       end
 
       # Like {#selection}, but for all nodes.
@@ -258,7 +281,7 @@ module GraphQL
             end
             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})")
+            frag_defn = lookup_fragment(ast_selection)
             # Again, assuming a valid AST
             on_type = @query.get_type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
@@ -271,11 +294,11 @@ 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_defn, arguments:, matches:)
+      def find_selected_nodes(node, field_name, field_defn, arguments:, matches:, alias_name: NOT_CONFIGURED)
         return if skipped_by_directive?(node)
         case node
         when GraphQL::Language::Nodes::Field
-          if node.name == field_defn.graphql_name
+          if node.name == field_name && (NOT_CONFIGURED.equal?(alias_name) || node.alias == alias_name)
             if arguments.nil? || arguments.empty?
               # No constraint applied
               matches << node
@@ -284,10 +307,10 @@ module GraphQL
             end
           end
         when GraphQL::Language::Nodes::InlineFragment
-          node.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
+          node.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches, alias_name: alias_name) }
         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_defn, arguments: arguments, matches: matches) }
+          frag_defn = lookup_fragment(node)
+          frag_defn.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches, alias_name: alias_name) }
         else
           raise "Unexpected selection comparison on #{node.class.name} (#{node})"
         end
@@ -306,6 +329,50 @@ module GraphQL
           query_kwargs.key?(arg_name_sym) && query_kwargs[arg_name_sym] == arg_value
         end
       end
+
+      def lookahead_for_selection(field_defn, selected_type, arguments, alias_name = NOT_CONFIGURED)
+        return NULL_LOOKAHEAD unless field_defn
+
+        next_nodes = []
+        field_name = field_defn.name
+        @ast_nodes.each do |ast_node|
+          ast_node.selections.each do |selection|
+            find_selected_nodes(selection, field_name, field_defn, arguments: arguments, matches: next_nodes, alias_name: alias_name)
+          end
+        end
+
+        return NULL_LOOKAHEAD if next_nodes.empty?
+
+        Lookahead.new(query: @query, ast_nodes: next_nodes, field: field_defn, owner_type: selected_type)
+      end
+
+      def alias_selections
+        return @alias_selections if defined?(@alias_selections)
+        @alias_selections ||= {}
+      end
+
+      def lookup_alias_node(nodes, name)
+        return if nodes.empty?
+
+        nodes.flat_map(&:children)
+             .flat_map { |child| unwrap_fragments(child) }
+             .find { |child| child.is_a?(GraphQL::Language::Nodes::Field) && child.alias == name }
+      end
+
+      def unwrap_fragments(node)
+        case node
+        when GraphQL::Language::Nodes::InlineFragment
+          node.children
+        when GraphQL::Language::Nodes::FragmentSpread
+          lookup_fragment(node).children
+        else
+          [node]
+        end
+      end
+
+      def lookup_fragment(ast_selection)
+        @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
+      end
     end
   end
 end

data/lib/graphql/load_application_object_failed_error.rb

@@ -12,10 +12,14 @@ module GraphQL
     attr_reader :id
     # @return [Object] The value found with this ID
     attr_reader :object
-    def initialize(argument:, id:, object:)
+    # @return [GraphQL::Query::Context]
+    attr_reader :context
+
+    def initialize(argument:, id:, object:, context:)
       @id = id
       @argument = argument
       @object = object
+      @context = context
       super("No object found for `#{argument.graphql_name}: #{id.inspect}`")
     end
   end

data/lib/graphql/pagination/connection.rb

@@ -22,10 +22,11 @@ module GraphQL
       attr_reader :context
 
       def context=(new_ctx)
-        current_runtime_state = Thread.current[:__graphql_runtime_info]
-        query_runtime_state = current_runtime_state[new_ctx.query]
-        @was_authorized_by_scope_items = query_runtime_state.was_authorized_by_scope_items
         @context = new_ctx
+        if @was_authorized_by_scope_items.nil?
+          @was_authorized_by_scope_items = detect_was_authorized_by_scope_items
+        end
+        @context
       end
 
       # @return [Object] the object this collection belongs to
@@ -90,13 +91,7 @@ module GraphQL
         else
           default_page_size
         end
-        @was_authorized_by_scope_items = if @context
-          current_runtime_state = Thread.current[:__graphql_runtime_info]
-          query_runtime_state = current_runtime_state[@context.query]
-          query_runtime_state.was_authorized_by_scope_items
-        else
-          nil
-        end
+        @was_authorized_by_scope_items = detect_was_authorized_by_scope_items
       end
 
       def was_authorized_by_scope_items?
@@ -226,6 +221,16 @@ module GraphQL
 
       private
 
+      def detect_was_authorized_by_scope_items
+        if @context &&
+            (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+            (query_runtime_state = current_runtime_state[@context.query])
+          query_runtime_state.was_authorized_by_scope_items
+        else
+          nil
+        end
+      end
+
       # @param argument [nil, Integer] `first` or `last`, as provided by the client
       # @param max_page_size [nil, Integer]
       # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`

data/lib/graphql/pagination/mongoid_relation_connection.rb

@@ -13,8 +13,7 @@ module GraphQL
       end
 
       def relation_count(relation)
-        # Mongo's `.count` doesn't apply limit or skip, which we need. So we have to load _everything_!
-        relation.to_a.count
+        relation.all.count(relation.options.slice(:limit, :skip))
       end
 
       def null_relation(relation)

data/lib/graphql/query/context.rb

@@ -237,6 +237,10 @@ module GraphQL
         @storage.key?(ns)
       end
 
+      def logger
+        @query && @query.logger
+      end
+
       def inspect
         "#<Query::Context ...>"
       end

data/lib/graphql/query/null_context.rb

@@ -3,6 +3,8 @@ module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
     class NullContext
+      include Singleton
+
       class NullQuery
         def after_lazy(value)
           yield(value)
@@ -27,16 +29,6 @@ module GraphQL
       def interpreter?
         true
       end
-
-      class << self
-        extend Forwardable
-
-        def instance
-          @instance ||= self.new
-        end
-
-        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader, :[], :fetch, :dig, :key?
-      end
     end
   end
 end

data/lib/graphql/query.rb

@@ -162,6 +162,14 @@ module GraphQL
 
       @result_values = nil
       @executed = false
+
+      @logger = if context && context[:logger] == false
+        Logger.new(IO::NULL)
+      elsif context && (l = context[:logger])
+        l
+      else
+        schema.default_logger
+      end
     end
 
     # If a document was provided to `GraphQL::Schema#execute` instead of the raw query string, we will need to get it from the document
@@ -369,6 +377,8 @@ module GraphQL
       end
     end
 
+    attr_reader :logger
+
     private
 
     def find_operation(operations, operation_name)

data/lib/graphql/schema/build_from_definition.rb

@@ -432,14 +432,12 @@ module GraphQL
           builder = self
 
           field_definitions.each do |field_definition|
-            type_name = resolve_type_name(field_definition.type)
             resolve_method_name = -"resolve_field_#{field_definition.name}"
             schema_field_defn = owner.field(
               field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
               null: true,
-              connection: type_name.end_with?("Connection"),
               connection_extension: nil,
               deprecation_reason: build_deprecation_reason(field_definition.directives),
               ast_node: field_definition,
@@ -487,15 +485,6 @@ module GraphQL
           }
           resolve_type_proc
         end
-
-        def resolve_type_name(type)
-          case type
-          when GraphQL::Language::Nodes::TypeName
-            return type.name
-          else
-            resolve_type_name(type.of_type)
-          end
-        end
       end
 
       private_constant :Builder

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

@@ -6,6 +6,18 @@ module GraphQL
         description "Requires that exactly one field must be supplied and that field must not be `null`."
         locations(GraphQL::Schema::Directive::INPUT_OBJECT)
         default_directive true
+
+        def initialize(...)
+          super
+
+          owner.extend(IsOneOf)
+        end
+
+        module IsOneOf
+          def one_of?
+            true
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/directive.rb

@@ -119,7 +119,7 @@ module GraphQL
         # - lazy resolution
         # Probably, those won't be needed here, since these are configuration arguments,
         # not runtime arguments.
-        @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext)
+        @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext.instance)
       end
 
       def graphql_name

data/lib/graphql/schema/enum.rb

@@ -68,7 +68,7 @@ module GraphQL
         end
 
         # @return [Array<GraphQL::Schema::EnumValue>] Possible values of this enum
-        def enum_values(context = GraphQL::Query::NullContext)
+        def enum_values(context = GraphQL::Query::NullContext.instance)
           inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
           visible_values = []
           warden = Warden.from_context(context)
@@ -110,7 +110,7 @@ module GraphQL
         end
 
         # @return [Hash<String => GraphQL::Schema::EnumValue>] Possible values of this enum, keyed by name.
-        def values(context = GraphQL::Query::NullContext)
+        def values(context = GraphQL::Query::NullContext.instance)
           enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 

data/lib/graphql/schema/field/scope_extension.rb

@@ -12,9 +12,10 @@ module GraphQL
             if ret_type.respond_to?(:scope_items)
               scoped_items = ret_type.scope_items(value, context)
               if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
-                current_runtime_state = Thread.current[:__graphql_runtime_info]
-                query_runtime_state = current_runtime_state[context.query]
-                query_runtime_state.was_authorized_by_scope_items = true
+                if (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+                    (query_runtime_state = current_runtime_state[context.query])
+                  query_runtime_state.was_authorized_by_scope_items = true
+                end
               end
               scoped_items
             else

data/lib/graphql/schema/field.rb

@@ -138,7 +138,7 @@ module GraphQL
             # As a last ditch, try to force loading the return type:
             type.unwrap.name
           end
-          @connection = return_type_name.end_with?("Connection")
+          @connection = return_type_name.end_with?("Connection") && return_type_name != "Connection"
         else
           @connection
         end
@@ -704,7 +704,7 @@ module GraphQL
                   inner_object.dig(*@dig_keys)
                 elsif inner_object.key?(@method_sym)
                   inner_object[@method_sym]
-                elsif inner_object.key?(@method_str)
+                elsif inner_object.key?(@method_str) || !inner_object.default_proc.nil?
                   inner_object[@method_str]
                 elsif @fallback_value != NOT_CONFIGURED
                   @fallback_value

data/lib/graphql/schema/has_single_input_argument.rb

@@ -54,11 +54,11 @@ module GraphQL
           end
         end
 
-        def field_arguments(context = GraphQL::Query::NullContext)
+        def field_arguments(context = GraphQL::Query::NullContext.instance)
           dummy.arguments(context)
         end
 
-        def get_field_argument(name, context = GraphQL::Query::NullContext)
+        def get_field_argument(name, context = GraphQL::Query::NullContext.instance)
           dummy.get_argument(name, context)
         end
 

data/lib/graphql/schema/input_object.rb

@@ -79,7 +79,7 @@ module GraphQL
       end
 
       def self.one_of?
-        directives.any? { |d| d.is_a?(GraphQL::Schema::Directive::OneOf) }
+        false # Re-defined when `OneOf` is added
       end
 
       def unwrap_value(value)