graphql 2.1.3 → 2.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b61b3465f091edb902adf9b7b1abe7e882e8c64235ad62f60984657b751eb4c
-  data.tar.gz: 9614fe43c3cf10bf16665cfe1179ca7faec9f3fbea566999220c03629143a07f
+  metadata.gz: 6c20f3924267df0e3f7b2a0b65a642572677d6f5cb041c37a098f8bb0cfaa32e
+  data.tar.gz: 8dacd2476d5471297a82348551ea8e34429d14edef9dbb1c2c8f34073c18abfc
 SHA512:
-  metadata.gz: 1aafd36c2d108a61f0275b6a7a439835401da9fda7ba743963a57130ce8e51a9730c1c243756af7ee87c1d52acdc851054daed27c93bbe970d7e9ae352452397
-  data.tar.gz: 5b4568baeb216f86857e6c2829de3440bc21af24407fa4cb9e164e179af9cfb83c01c7e828429b22546d9c836aab59515ae265f65993283ed1a0a0d6fc8579e1
+  metadata.gz: f1fb9466a19755ce3e7f0ee9693428d1b2e5c8017287909e624975e49727376729ec5fda28318953ec6fda606a693f842c1caad5419dc410938a59506c994fae
+  data.tar.gz: d048fc02aece1781f4d15a700bc2cde8c1baf929917f35a9ae23567d5f720dabd5f4d18e47e3b8af2d9d6ecc6dde146f750a08b28de9fef769a960dc60ac0444

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

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)

data/lib/graphql/schema/interface.rb

@@ -20,6 +20,15 @@ module GraphQL
         # - Added as class methods to this interface
         # - Added as class methods to all child interfaces
         def definition_methods(&block)
+          # Use an instance variable to tell whether it's been included previously or not;
+          # You can't use constant detection because constants are brought into scope
+          # by `include`, which has already happened at this point.
+          if !defined?(@_definition_methods)
+            defn_methods_module = Module.new
+            @_definition_methods = defn_methods_module
+            const_set(:DefinitionMethods, defn_methods_module)
+            extend(self::DefinitionMethods)
+          end
           self::DefinitionMethods.module_eval(&block)
         end
 
@@ -47,20 +56,11 @@ module GraphQL
 
             child_class.type_membership_class(self.type_membership_class)
             child_class.ancestors.reverse_each do |ancestor|
-              if ancestor.const_defined?(:DefinitionMethods)
+              if ancestor.const_defined?(:DefinitionMethods) && ancestor != child_class
                 child_class.extend(ancestor::DefinitionMethods)
               end
             end
 
-            # Use an instance variable to tell whether it's been included previously or not;
-            # You can't use constant detection because constants are brought into scope
-            # by `include`, which has already happened at this point.
-            if !child_class.instance_variable_defined?(:@_definition_methods)
-              defn_methods_module = Module.new
-              child_class.instance_variable_set(:@_definition_methods, defn_methods_module)
-              child_class.const_set(:DefinitionMethods, defn_methods_module)
-              child_class.extend(child_class::DefinitionMethods)
-            end
             child_class.introspection(introspection)
             child_class.description(description)
             # If interfaces are mixed into each other, only define this class once

data/lib/graphql/schema/loader.rb

@@ -176,7 +176,6 @@ module GraphQL
             while (of_type = unwrapped_field_hash["ofType"])
               unwrapped_field_hash = of_type
             end
-            type_name = unwrapped_field_hash["name"]
 
             type_defn.field(
               field_hash["name"],
@@ -186,7 +185,6 @@ module GraphQL
               null: true,
               camelize: false,
               connection_extension: nil,
-              connection: type_name.end_with?("Connection"),
             ) do
               if field_hash["args"].any?
                 loader.build_arguments(self, field_hash["args"], type_resolver)

data/lib/graphql/schema/member/has_arguments.rb

@@ -109,7 +109,7 @@ module GraphQL
         end
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
-        def arguments(context = GraphQL::Query::NullContext)
+        def arguments(context = GraphQL::Query::NullContext.instance)
           if own_arguments.any?
             own_arguments_that_apply = {}
             own_arguments.each do |name, args_entry|
@@ -133,7 +133,7 @@ module GraphQL
           end
 
           module InheritedArguments
-            def arguments(context = GraphQL::Query::NullContext)
+            def arguments(context = GraphQL::Query::NullContext.instance)
               own_arguments = super
               inherited_arguments = superclass.arguments(context)
 
@@ -166,7 +166,7 @@ module GraphQL
             end
 
 
-            def get_argument(argument_name, context = GraphQL::Query::NullContext)
+            def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
               warden = Warden.from_context(context)
               for ancestor in ancestors
                 if ancestor.respond_to?(:own_arguments) &&
@@ -181,7 +181,7 @@ module GraphQL
         end
 
         module FieldConfigured
-          def arguments(context = GraphQL::Query::NullContext)
+          def arguments(context = GraphQL::Query::NullContext.instance)
             own_arguments = super
             if @resolver_class
               inherited_arguments = @resolver_class.field_arguments(context)
@@ -236,7 +236,7 @@ module GraphQL
         end
 
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
-        def get_argument(argument_name, context = GraphQL::Query::NullContext)
+        def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
           if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
             visible_arg
@@ -379,44 +379,52 @@ module GraphQL
           def authorize_application_object(argument, id, context, loaded_application_object)
             context.query.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?
-                err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-                load_application_object_failed(err)
+                err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object)
+                application_object = load_application_object_failed(err)
               end
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
-              maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
-              context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
-                if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
-                  application_object_type, application_object = resolve_type_result
-                else
-                  application_object_type = resolve_type_result
-                  # application_object is already assigned
-                end
+              if application_object.nil?
+                nil
+              else
+                maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
+                context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
+                  if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
+                    application_object_type, application_object = resolve_type_result
+                  else
+                    application_object_type = resolve_type_result
+                    # application_object is already assigned
+                  end
 
-                if !(
-                    context.warden.possible_types(argument.loads).include?(application_object_type) ||
-                    context.warden.loadable?(argument.loads, context)
-                  )
-                  err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-                  load_application_object_failed(err)
-                else
-                  # This object was loaded successfully
-                  # and resolved to the right type,
-                  # now apply the `.authorized?` class method if there is one
-                  context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
-                    if authed
-                      application_object
-                    else
-                      err = GraphQL::UnauthorizedError.new(
-                        object: application_object,
-                        type: application_object_type,
-                        context: context,
-                      )
-                      if self.respond_to?(:unauthorized_object)
-                        err.set_backtrace(caller)
-                        unauthorized_object(err)
+                  if !(
+                      context.warden.possible_types(argument.loads).include?(application_object_type) ||
+                      context.warden.loadable?(argument.loads, context)
+                    )
+                    err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object)
+                    application_object = load_application_object_failed(err)
+                  end
+
+                  if application_object.nil?
+                    nil
+                  else
+                    # This object was loaded successfully
+                    # and resolved to the right type,
+                    # now apply the `.authorized?` class method if there is one
+                    context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
+                      if authed
+                        application_object
                       else
-                        raise err
+                        err = GraphQL::UnauthorizedError.new(
+                          object: application_object,
+                          type: application_object_type,
+                          context: context,
+                        )
+                        if self.respond_to?(:unauthorized_object)
+                          err.set_backtrace(caller)
+                          unauthorized_object(err)
+                        else
+                          raise err
+                        end
                       end
                     end
                   end

data/lib/graphql/schema/member/has_fields.rb

@@ -97,7 +97,7 @@ module GraphQL
         end
 
         module InterfaceMethods
-          def get_field(field_name, context = GraphQL::Query::NullContext)
+          def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
             for ancestor in ancestors
               if ancestor.respond_to?(:own_fields) &&
@@ -110,7 +110,7 @@ module GraphQL
           end
 
           # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
-          def fields(context = GraphQL::Query::NullContext)
+          def fields(context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields
             visible_fields = {}
@@ -130,7 +130,7 @@ module GraphQL
         end
 
         module ObjectMethods
-          def get_field(field_name, context = GraphQL::Query::NullContext)
+          def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
             ancs = ancestors
@@ -148,7 +148,7 @@ module GraphQL
           end
 
           # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
-          def fields(context = GraphQL::Query::NullContext)
+          def fields(context = GraphQL::Query::NullContext.instance)
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields

data/lib/graphql/schema/member/has_interfaces.rb

@@ -70,7 +70,7 @@ module GraphQL
           end
 
           module InheritedInterfaces
-            def interfaces(context = GraphQL::Query::NullContext)
+            def interfaces(context = GraphQL::Query::NullContext.instance)
               visible_interfaces = super
               inherited_interfaces = superclass.interfaces(context)
               if visible_interfaces.any?
@@ -99,7 +99,7 @@ module GraphQL
         end
 
         # param context [Query::Context] If omitted, skip filtering.
-        def interfaces(context = GraphQL::Query::NullContext)
+        def interfaces(context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
           visible_interfaces = nil
           own_interface_type_memberships.each do |type_membership|

data/lib/graphql/schema/member/validates_input.rb

@@ -17,15 +17,15 @@ module GraphQL
         end
 
         def valid_isolated_input?(v)
-          valid_input?(v, GraphQL::Query::NullContext)
+          valid_input?(v, GraphQL::Query::NullContext.instance)
         end
 
         def coerce_isolated_input(v)
-          coerce_input(v, GraphQL::Query::NullContext)
+          coerce_input(v, GraphQL::Query::NullContext.instance)
         end
 
         def coerce_isolated_result(v)
-          coerce_result(v, GraphQL::Query::NullContext)
+          coerce_result(v, GraphQL::Query::NullContext.instance)
         end
       end
     end

data/lib/graphql/schema/resolver.rb

@@ -205,12 +205,12 @@ module GraphQL
         end
       end
 
-      def get_argument(name, context = GraphQL::Query::NullContext)
+      def get_argument(name, context = GraphQL::Query::NullContext.instance)
         self.class.get_argument(name, context)
       end
 
       class << self
-        def field_arguments(context = GraphQL::Query::NullContext)
+        def field_arguments(context = GraphQL::Query::NullContext.instance)
           arguments(context)
         end
 
@@ -218,7 +218,7 @@ module GraphQL
           any_arguments?
         end
 
-        def get_field_argument(name, context = GraphQL::Query::NullContext)
+        def get_field_argument(name, context = GraphQL::Query::NullContext.instance)
           get_argument(name, context)
         end
 

data/lib/graphql/schema/union.rb

@@ -10,7 +10,7 @@ module GraphQL
           super
         end
 
-        def possible_types(*types, context: GraphQL::Query::NullContext, **options)
+        def possible_types(*types, context: GraphQL::Query::NullContext.instance, **options)
           if types.any?
             types.each do |t|
               assert_valid_union_member(t)

data/lib/graphql/schema/warden.rb

@@ -106,7 +106,7 @@ module GraphQL
         @types = @visible_types = @reachable_types = @visible_parent_fields =
           @visible_possible_types = @visible_fields = @visible_arguments = @visible_enum_arrays =
           @visible_enum_values = @visible_interfaces = @type_visibility = @type_memberships =
-          @visible_and_reachable_type = @unions = @unfiltered_interfaces = @references_to =
+          @visible_and_reachable_type = @unions = @unfiltered_interfaces =
           @reachable_type_set =
             nil
       end
@@ -291,7 +291,14 @@ module GraphQL
           if type_defn.kind.union?
             possible_types(type_defn).any? && (referenced?(type_defn) || orphan_type?(type_defn))
           elsif type_defn.kind.interface?
-            possible_types(type_defn).any?
+            if possible_types(type_defn).any?
+              true
+            else
+              if @context.respond_to?(:logger) && (logger = @context.logger)
+                logger.debug { "Interface `#{type_defn.graphql_name}` hidden because it has no visible implementors" }
+              end
+              false
+            end
           else
             if referenced?(type_defn)
               true
@@ -356,14 +363,11 @@ module GraphQL
       end
 
       def referenced?(type_defn)
-        @references_to ||= @schema.references_to
         graphql_name = type_defn.unwrap.graphql_name
-        members = @references_to[graphql_name] || NO_REFERENCES
+        members = @schema.references_to(graphql_name)
         members.any? { |m| visible?(m) }
       end
 
-      NO_REFERENCES = [].freeze
-
       def orphan_type?(type_defn)
         @schema.orphan_types.include?(type_defn)
       end

data/lib/graphql/schema.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "logger"
 require "graphql/schema/addition"
 require "graphql/schema/always_visible"
 require "graphql/schema/base_64_encoder"
@@ -325,7 +326,7 @@ module GraphQL
       # Build a map of `{ name => type }` and return it
       # @return [Hash<String => Class>] A dictionary of type classes by their GraphQL name
       # @see get_type Which is more efficient for finding _one type_ by name, because it doesn't merge hashes.
-      def types(context = GraphQL::Query::NullContext)
+      def types(context = GraphQL::Query::NullContext.instance)
         all_types = non_introspection_types.merge(introspection_system.types)
         visible_types = {}
         all_types.each do |k, v|
@@ -352,7 +353,7 @@ module GraphQL
 
       # @param type_name [String]
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
-      def get_type(type_name, context = GraphQL::Query::NullContext)
+      def get_type(type_name, context = GraphQL::Query::NullContext.instance)
         local_entry = own_types[type_name]
         type_defn = case local_entry
         when nil
@@ -483,7 +484,7 @@ module GraphQL
       # @param type [Module] The type definition whose possible types you want to see
       # @return [Hash<String, Module>] All possible types, if no `type` is given.
       # @return [Array<Module>] Possible types for `type`, if it's given.
-      def possible_types(type = nil, context = GraphQL::Query::NullContext)
+      def possible_types(type = nil, context = GraphQL::Query::NullContext.instance)
         if type
           # TODO duck-typing `.possible_types` would probably be nicer here
           if type.kind.union?
@@ -536,18 +537,17 @@ module GraphQL
       attr_writer :dataloader_class
 
       def references_to(to_type = nil, from: nil)
-        @own_references_to ||= Hash.new { |h, k| h[k] = [] }
+        @own_references_to ||= {}
         if to_type
           if !to_type.is_a?(String)
             to_type = to_type.graphql_name
           end
 
           if from
-            @own_references_to[to_type] << from
+            refs = @own_references_to[to_type] ||= []
+            refs << from
           else
-            own_refs = @own_references_to[to_type]
-            inherited_refs = find_inherited_value(:references_to, EMPTY_HASH)[to_type] || EMPTY_ARRAY
-            own_refs + inherited_refs
+            get_references_to(to_type) || EMPTY_ARRAY
           end
         else
           # `@own_references_to` can be quite large for big schemas,
@@ -567,7 +567,7 @@ module GraphQL
         GraphQL::Schema::TypeExpression.build_type(type_owner, ast_node)
       end
 
-      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext)
+      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance)
         parent_type = case type_or_name
         when LateBoundType
           get_type(type_or_name.name, context)
@@ -590,7 +590,7 @@ module GraphQL
         end
       end
 
-      def get_fields(type, context = GraphQL::Query::NullContext)
+      def get_fields(type, context = GraphQL::Query::NullContext.instance)
         type.fields(context)
       end
 
@@ -836,6 +836,26 @@ module GraphQL
         end
       end
 
+      def default_logger(new_default_logger = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_default_logger)
+          if defined?(@default_logger)
+            @default_logger
+          elsif superclass.respond_to?(:default_logger)
+            superclass.default_logger
+          elsif defined?(Rails)
+            Rails.logger
+          else
+            def_logger = Logger.new($stdout)
+            def_logger.info! # It doesn't output debug info by default
+            def_logger
+          end
+        elsif new_default_logger == nil
+          @default_logger = Logger.new(IO::NULL)
+        else
+          @default_logger = new_default_logger
+        end
+      end
+
       def context_class(new_context_class = nil)
         if new_context_class
           @context_class = new_context_class
@@ -922,6 +942,7 @@ module GraphQL
       def inherited(child_class)
         if self == GraphQL::Schema
           child_class.directives(default_directives.values)
+          child_class.extend(SubclassGetReferencesTo)
         end
         # Make sure the child class has these built out, so that
         # subclasses can be modified by later calls to `trace_with`
@@ -1397,6 +1418,27 @@ module GraphQL
       def own_multiplex_analyzers
         @own_multiplex_analyzers ||= []
       end
+
+      # This is overridden in subclasses to check the inheritance chain
+      def get_references_to(type_name)
+        @own_references_to[type_name]
+      end
+    end
+
+    module SubclassGetReferencesTo
+      def get_references_to(type_name)
+        own_refs = @own_references_to[type_name]
+        inherited_refs = superclass.references_to(type_name)
+        if inherited_refs&.any?
+          if own_refs&.any?
+            own_refs + inherited_refs
+          else
+            inherited_refs
+          end
+        else
+          own_refs
+        end
+      end
     end
 
     # Install these here so that subclasses will also install it.

data/lib/graphql/subscriptions/event.rb

@@ -37,7 +37,7 @@ module GraphQL
       end
 
       # @return [String] an identifier for this unit of subscription
-      def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext)
+      def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext.instance)
         subscription = field.resolver || GraphQL::Schema::Subscription
         normalized_args = stringify_args(field, arguments.to_h, context)
         subscription.topic_for(arguments: normalized_args, field: field, scope: scope)

data/lib/graphql/subscriptions.rb

@@ -62,7 +62,7 @@ module GraphQL
     # @return [void]
     def trigger(event_name, args, object, scope: nil, context: {})
       # Make something as context-like as possible, even though there isn't a current query:
-      dummy_query = GraphQL::Query.new(@schema, "", validate: false, context: context)
+      dummy_query = GraphQL::Query.new(@schema, "{ __typename }", validate: false, context: context)
       context = dummy_query.context
       event_name = event_name.to_s
 
@@ -83,7 +83,7 @@ module GraphQL
 
       # Normalize symbol-keyed args to strings, try camelizing them
       # Should this accept a real context somehow?
-      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext)
+      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext.instance)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.1.3"
+  VERSION = "2.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.1.4
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-12 00:00:00.000000000 Z
+date: 2023-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: racc
@@ -626,7 +626,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.0.dev
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby