graphql 2.3.3 → 2.3.5

data/lib/graphql/language/parser.rb

@@ -379,7 +379,12 @@ module GraphQL
             v_loc = pos
             description = if at?(:STRING); string_value; end
             defn_loc = pos
-            enum_value = parse_enum_name
+            # Any identifier, but not true, false, or null
+            enum_value = if at?(:TRUE) || at?(:FALSE) || at?(:NULL)
+              expect_token(:IDENTIFIER)
+            else
+              parse_name
+            end
             v_directives = parse_directives
             list << EnumValueDefinition.new(pos: v_loc, definition_pos: defn_loc, description: description, name: enum_value, directives: v_directives, filename: @filename, source: self)
           end
@@ -478,7 +483,7 @@ module GraphQL
         end
 
         if at?(:BANG)
-          type = Nodes::NonNullType.new(pos: pos, of_type: type)
+          type = Nodes::NonNullType.new(pos: pos, of_type: type, source: self)
           expect_token(:BANG)
         end
         type
@@ -487,7 +492,7 @@ module GraphQL
       def list_type
         loc = pos
         expect_token(:LBRACKET)
-        type = Nodes::ListType.new(pos: loc, of_type: self.type)
+        type = Nodes::ListType.new(pos: loc, of_type: self.type, source: self)
         expect_token(:RBRACKET)
         type
       end
@@ -615,9 +620,6 @@ module GraphQL
         when :ON
           advance_token
           "on"
-        when :DIRECTIVE
-          advance_token
-          "directive"
         when :EXTEND
           advance_token
           "extend"
@@ -634,15 +636,6 @@ module GraphQL
         end
       end
 
-      # Any identifier, but not true, false, or null
-      def parse_enum_name
-        if at?(:TRUE) || at?(:FALSE) || at?(:NULL)
-          expect_token(:IDENTIFIER)
-        else
-          parse_name
-        end
-      end
-
       def parse_type_name
         TypeName.new(pos: pos, name: parse_name, filename: @filename, source: self)
       end
@@ -733,6 +726,54 @@ module GraphQL
           loc = pos
           advance_token
           VariableIdentifier.new(pos: loc, name: parse_name, filename: @filename, source: self)
+        when :SCHEMA
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "schema", filename: @filename, source: self)
+        when :SCALAR
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "scalar", filename: @filename, source: self)
+        when :IMPLEMENTS
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "implements", filename: @filename, source: self)
+        when :INTERFACE
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "interface", filename: @filename, source: self)
+        when :UNION
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "union", filename: @filename, source: self)
+        when :ENUM
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "enum", filename: @filename, source: self)
+        when :INPUT
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "input", filename: @filename, source: self)
+        when :DIRECTIVE
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "directive", filename: @filename, source: self)
+        when :TYPE
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "type", filename: @filename, source: self)
+        when :QUERY
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "query", filename: @filename, source: self)
+        when :MUTATION
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "mutation", filename: @filename, source: self)
+        when :SUBSCRIPTION
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "subscription", filename: @filename, source: self)
+        when :FRAGMENT
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "fragment", filename: @filename, source: self)
+        when :REPEATABLE
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "repeatable", filename: @filename, source: self)
+        when :ON
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "on", filename: @filename, source: self)
+        when :EXTEND
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "extend", filename: @filename, source: self)
         else
           expect_token(:VALUE)
         end

data/lib/graphql/query.rb

@@ -222,7 +222,7 @@ module GraphQL
     end
 
     # Get the result for this query, executing it once
-    # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
+    # @return [GraphQL::Query::Result] A Hash-like GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
         Execution::Interpreter.run_all(@schema, [self], context: @context)
@@ -304,7 +304,7 @@ module GraphQL
 
     # @return [String] An opaque hash for identifying this query's given query string and selected operation
     def operation_fingerprint
-      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string)}"
+      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string || "")}"
     end
 
     # @return [String] An opaque hash for identifying this query's given a variable values (not including defaults)

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

@@ -9,7 +9,7 @@ module GraphQL
 
         # 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
+          # work back to the preceding comma
           first_pos = pair_node.location.expression.begin_pos
           end_pos = pair_node.location.expression.end_pos
           node_source = send_node.source_range.source

data/lib/graphql/schema/addition.rb

@@ -12,7 +12,7 @@ module GraphQL
         @possible_types = {}
         @types = {}
         @union_memberships = {}
-        @references = Hash.new { |h, k| h[k] = [] }
+        @references = Hash.new { |h, k| h[k] = Set.new }
         @arguments_with_default_values = []
         add_type_and_traverse(new_types)
       end
@@ -20,7 +20,7 @@ module GraphQL
       private
 
       def references_to(thing, from:)
-        @references[thing] << from
+        @references[thing].add(from)
       end
 
       def get_type(name)
@@ -95,7 +95,7 @@ module GraphQL
             # 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
+            @possible_types[owner] = owner.possible_types
           elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
             new_interfaces = []
             owner.interfaces.each do |int_t|
@@ -110,7 +110,7 @@ module GraphQL
             end
             owner.implements(*new_interfaces)
             new_interfaces.each do |int|
-              pt = @possible_types[int.graphql_name] ||= []
+              pt = @possible_types[int] ||= []
               if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
@@ -126,6 +126,7 @@ module GraphQL
           @types[type.graphql_name] = type
         when GraphQL::Schema::Field, GraphQL::Schema::Argument
           orig_type = owner.type
+          unwrapped_t = type
           # Apply list/non-null wrapper as needed
           if orig_type.respond_to?(:of_type)
             transforms = []
@@ -142,6 +143,7 @@ module GraphQL
             transforms.reverse_each { |t| type = type.public_send(t) }
           end
           owner.type = type
+          references_to(unwrapped_t, from: owner)
         else
           raise "Unexpected update: #{owner.inspect} #{type.inspect}"
         end
@@ -164,7 +166,9 @@ module GraphQL
           @directives << type
           type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
-            references_to(arg_type, from: arg)
+            if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+              references_to(arg_type, from: arg)
+            end
             path.push(arg.graphql_name)
             add_type(arg_type, owner: arg, late_types: late_types, path: path)
             path.pop
@@ -187,14 +191,18 @@ module GraphQL
             type.all_field_definitions.each do |field|
               name = field.graphql_name
               field_type = field.type.unwrap
-              references_to(field_type, from: field)
+              if !field_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(field_type, from: field)
+              end
               path.push(name)
               add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
-                references_to(arg_type, from: arg)
+                if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                  references_to(arg_type, from: arg)
+                end
                 path.push(arg.graphql_name)
                 add_type(arg_type, owner: arg, late_types: late_types, path: path)
                 path.pop
@@ -209,7 +217,9 @@ module GraphQL
             type.all_argument_definitions.each do |arg|
               add_directives_from(arg)
               arg_type = arg.type.unwrap
-              references_to(arg_type, from: arg)
+              if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(arg_type, from: arg)
+              end
               path.push(arg.graphql_name)
               add_type(arg_type, owner: arg, late_types: late_types, path: path)
               path.pop
@@ -219,7 +229,7 @@ module GraphQL
             end
           end
           if type.kind.union?
-            @possible_types[type.graphql_name] = type.all_possible_types
+            @possible_types[type] = type.all_possible_types
             path.push("possible_types")
             type.all_possible_types.each do |t|
               add_type(t, owner: type, late_types: late_types, path: path)
@@ -234,7 +244,7 @@ module GraphQL
             path.pop
           end
           if type.kind.object?
-            possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
+            possible_types_for_this_name = @possible_types[type] ||= []
             possible_types_for_this_name << type
           end
 
@@ -246,7 +256,7 @@ module GraphQL
                 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) && type.is_a?(Class)
-                  implementers = @possible_types[interface_type.graphql_name] ||= []
+                  implementers = @possible_types[interface_type] ||= []
                   implementers << type
                 end
               when String, Schema::LateBoundType

data/lib/graphql/schema/has_single_input_argument.rb

@@ -47,6 +47,7 @@ module GraphQL
         def dummy
           @dummy ||= begin
             d = Class.new(GraphQL::Schema::Resolver)
+            d.graphql_name "#{self.graphql_name}DummyResolver"
             d.argument_class(self.argument_class)
             # TODO make this lazier?
             d.argument(:input, input_type, description: "Parameters for #{self.graphql_name}")

data/lib/graphql/schema/input_object.rb

@@ -136,6 +136,7 @@ module GraphQL
             def #{method_name}
               self[#{method_name.inspect}]
             end
+            alias_method :#{method_name}, :#{method_name}
           RUBY
           argument_defn
         end

data/lib/graphql/schema/introspection_system.rb

@@ -25,10 +25,10 @@ module GraphQL
           load_constant(:DirectiveLocationEnum)
         ]
         @types = {}
-        @possible_types = {}
+        @possible_types = {}.tap(&:compare_by_identity)
         type_defns.each do |t|
           @types[t.graphql_name] = t
-          @possible_types[t.graphql_name] = [t]
+          @possible_types[t] = [t]
         end
         @entry_point_fields =
           if schema.disable_introspection_entry_points?

data/lib/graphql/schema/late_bound_type.rb

@@ -25,6 +25,10 @@ module GraphQL
         @to_list_type ||= GraphQL::Schema::List.new(self)
       end
 
+      def to_type_signature
+        name
+      end
+
       def inspect
         "#<LateBoundType @name=#{name}>"
       end

data/lib/graphql/schema/list.rb

@@ -52,7 +52,7 @@ module GraphQL
           unless item_result.valid?
             if max_errors
               if max_errors == 0
-                add_max_errros_reached_message(result)
+                add_max_errors_reached_message(result)
                 break
               end
 
@@ -76,7 +76,7 @@ module GraphQL
         end
       end
 
-      def add_max_errros_reached_message(result)
+      def add_max_errors_reached_message(result)
         message = "Too many errors processing list variable, max validation error limit reached. Execution aborted"
         item_result = GraphQL::Query::InputValidationResult.from_problem(message)
         result.merge_result!(nil, item_result)

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

@@ -38,39 +38,6 @@ module GraphQL
           end
           arg_defn = self.argument_class.new(*args, **kwargs, &block)
           add_argument(arg_defn)
-
-          if self.is_a?(Class) && !method_defined?(:"load_#{arg_defn.keyword}")
-            method_owner = if self < GraphQL::Schema::InputObject || self < GraphQL::Schema::Directive
-              "self."
-            elsif self < GraphQL::Schema::Resolver
-              ""
-            else
-              raise "Unexpected argument owner: #{self}"
-            end
-            if loads && arg_defn.type.list?
-              class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
-                argument = get_argument("#{arg_defn.graphql_name}", context || self.context)
-                (context || self.context).query.after_lazy(values) do |values2|
-                  GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, value, context || self.context) })
-                end
-              end
-              RUBY
-            elsif loads
-              class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method_owner}load_#{arg_defn.keyword}(value, context = nil)
-                argument = get_argument("#{arg_defn.graphql_name}", context || self.context)
-                load_application_object(argument, value, context || self.context)
-              end
-              RUBY
-            else
-              class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method_owner}load_#{arg_defn.keyword}(value, _context = nil)
-                value
-              end
-              RUBY
-            end
-          end
           arg_defn
         end
 
@@ -259,8 +226,8 @@ module GraphQL
         #
         # @param values [Hash<String, Object>]
         # @param context [GraphQL::Query::Context]
-        # @yield [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
-        # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        # @yield [Interpreter::Arguments, Execution::Lazy<Interpreter::Arguments>]
+        # @return [Interpreter::Arguments, Execution::Lazy<Interpreter::Arguments>]
         def coerce_arguments(parent_object, values, context, &block)
           # Cache this hash to avoid re-merging it
           arg_defns = context.warden.arguments(self)

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

@@ -91,7 +91,7 @@ module GraphQL
           private
 
           # Modify `target` by adding items from `dirs` such that:
-          # - Any name conflict is overriden by the incoming member of `dirs`
+          # - Any name conflict is overridden by the incoming member of `dirs`
           # - Any other member of `dirs` is appended
           # @param target [Array<GraphQL::Schema::Directive>]
           # @param dirs [Array<GraphQL::Schema::Directive>]

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

@@ -76,7 +76,7 @@ module GraphQL
 
         private
 
-        # If one of thse values is accessed, initialize all the instance variables to retain
+        # If one of these values is accessed, initialize all the instance variables to retain
         # a consistent object shape.
         def initialize_relay_metadata
           if !defined?(@connection_type)

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

@@ -4,12 +4,11 @@ module GraphQL
   class Schema
     class Member
       module TypeSystemHelpers
-        def initialize(*args, &block)
+        def initialize(...)
           super
           @to_non_null_type ||= nil
           @to_list_type ||= nil
         end
-        ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
 
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type

data/lib/graphql/schema/warden.rb

@@ -295,7 +295,7 @@ module GraphQL
               true
             else
               if @context.respond_to?(:logger) && (logger = @context.logger)
-                logger.debug { "Interface `#{type_defn.graphql_name}` hidden because it has no visible implementors" }
+                logger.debug { "Interface `#{type_defn.graphql_name}` hidden because it has no visible implementers" }
               end
               false
             end
@@ -363,8 +363,7 @@ module GraphQL
       end
 
       def referenced?(type_defn)
-        graphql_name = type_defn.unwrap.graphql_name
-        members = @schema.references_to(graphql_name)
+        members = @schema.references_to(type_defn)
         members.any? { |m| visible?(m) }
       end
 

data/lib/graphql/schema.rb

@@ -187,7 +187,7 @@ module GraphQL
       # {default_trace_mode} is used when no `trace_mode: ...` is requested.
       #
       # When a `trace_class` is added this way, it will _not_ receive other modules added with `trace_with(...)`
-      # unless `trace_mode` is explicitly given. (This class will not recieve any default trace modules.)
+      # unless `trace_mode` is explicitly given. (This class will not receive any default trace modules.)
       #
       # Subclasses of the schema will use `trace_class` as a base class for this mode and those
       # subclass also will _not_ receive default tracing modules.
@@ -506,7 +506,7 @@ module GraphQL
           if type.kind.union?
             type.possible_types(context: context)
           else
-            stored_possible_types = own_possible_types[type.graphql_name]
+            stored_possible_types = own_possible_types[type]
             visible_possible_types = if stored_possible_types && type.kind.interface?
               stored_possible_types.select do |possible_type|
                 possible_type.interfaces(context).include?(type)
@@ -515,7 +515,7 @@ module GraphQL
               stored_possible_types
             end
             visible_possible_types ||
-              introspection_system.possible_types[type.graphql_name] ||
+              introspection_system.possible_types[type] ||
               (
                 superclass.respond_to?(:possible_types) ?
                   superclass.possible_types(type, context) :
@@ -553,14 +553,9 @@ module GraphQL
       attr_writer :dataloader_class
 
       def references_to(to_type = nil, from: nil)
-        @own_references_to ||= {}
         if to_type
-          if !to_type.is_a?(String)
-            to_type = to_type.graphql_name
-          end
-
           if from
-            refs = @own_references_to[to_type] ||= []
+            refs = own_references_to[to_type] ||= []
             refs << from
           else
             get_references_to(to_type) || EMPTY_ARRAY
@@ -571,9 +566,9 @@ module GraphQL
           # So optimize the most common case -- don't create a duplicate Hash.
           inherited_value = find_inherited_value(:references_to, EMPTY_HASH)
           if inherited_value.any?
-            inherited_value.merge(@own_references_to)
+            inherited_value.merge(own_references_to)
           else
-            @own_references_to
+            own_references_to
           end
         end
       end
@@ -1287,7 +1282,7 @@ module GraphQL
 
       # Execute a query on itself.
       # @see {Query#initialize} for arguments.
-      # @return [Hash] query result, ready to be serialized as JSON
+      # @return [GraphQL::Query::Result] query result, ready to be serialized as JSON
       def execute(query_str = nil, **kwargs)
         if query_str
           kwargs[:query] = query_str
@@ -1327,7 +1322,7 @@ module GraphQL
       # @see {Execution::Multiplex#run_all} for multiplex keyword arguments
       # @param queries [Array<Hash>] Keyword arguments for each query
       # @param context [Hash] Multiplex-level context
-      # @return [Array<Hash>] One result for each query in the input
+      # @return [Array<GraphQL::Query::Result>] One result for each query in the input
       def multiplex(queries, **kwargs)
         GraphQL::Execution::Interpreter.run_all(self, queries, **kwargs)
       end
@@ -1460,7 +1455,8 @@ module GraphQL
         own_union_memberships.merge!(addition.union_memberships)
 
         addition.references.each { |thing, pointers|
-          pointers.each { |pointer| references_to(thing, from: pointer) }
+          prev_refs = own_references_to[thing] || []
+          own_references_to[thing] = prev_refs | pointers.to_a
         }
 
         addition.directives.each { |dir_class| own_directives[dir_class.graphql_name] = dir_class }
@@ -1488,6 +1484,10 @@ module GraphQL
         @own_types ||= {}
       end
 
+      def own_references_to
+        @own_references_to ||= {}.tap(&:compare_by_identity)
+      end
+
       def non_introspection_types
         find_inherited_value(:non_introspection_types, EMPTY_HASH).merge(own_types)
       end
@@ -1501,7 +1501,7 @@ module GraphQL
       end
 
       def own_possible_types
-        @own_possible_types ||= {}
+        @own_possible_types ||= {}.tap(&:compare_by_identity)
       end
 
       def own_union_memberships
@@ -1529,15 +1529,15 @@ module GraphQL
       end
 
       # This is overridden in subclasses to check the inheritance chain
-      def get_references_to(type_name)
-        @own_references_to[type_name]
+      def get_references_to(type_defn)
+        own_references_to[type_defn]
       end
     end
 
     module SubclassGetReferencesTo
-      def get_references_to(type_name)
-        own_refs = @own_references_to[type_name]
-        inherited_refs = superclass.references_to(type_name)
+      def get_references_to(type_defn)
+        own_refs = own_references_to[type_defn]
+        inherited_refs = superclass.references_to(type_defn)
         if inherited_refs&.any?
           if own_refs&.any?
             own_refs + inherited_refs

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -396,7 +396,7 @@ module GraphQL
       end
 
       # Given two list of parents, find out if they are mutually exclusive
-      # In this context, `parents` represends the "self scope" of the field,
+      # In this context, `parents` represents the "self scope" of the field,
       # what types may be found at this point in the query.
       def mutually_exclusive?(parents1, parents2)
         if parents1.empty? || parents2.empty?

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -107,7 +107,7 @@ module GraphQL
         when 2
           true
         else
-          raise ArgumentError, "#{@serializer} must repond to `.load` accepting one or two arguments"
+          raise ArgumentError, "#{@serializer} must respond to `.load` accepting one or two arguments"
         end
         @transmit_ns = namespace
         super

data/lib/graphql/tracing/prometheus_trace.rb

@@ -25,33 +25,33 @@ module GraphQL
       }.each do |trace_method, platform_key|
         module_eval <<-RUBY, __FILE__, __LINE__
           def #{trace_method}(**data)
-            instrument_execution("#{platform_key}", "#{trace_method}") { super }
+            instrument_prometheus_execution("#{platform_key}", "#{trace_method}") { super }
           end
         RUBY
       end
 
       def platform_execute_field(platform_key, &block)
-        instrument_execution(platform_key, "execute_field", &block)
+        instrument_prometheus_execution(platform_key, "execute_field", &block)
       end
 
       def platform_execute_field_lazy(platform_key, &block)
-        instrument_execution(platform_key, "execute_field_lazy", &block)
+        instrument_prometheus_execution(platform_key, "execute_field_lazy", &block)
       end
 
       def platform_authorized(platform_key, &block)
-        instrument_execution(platform_key, "authorized", &block)
+        instrument_prometheus_execution(platform_key, "authorized", &block)
       end
 
       def platform_authorized_lazy(platform_key, &block)
-        instrument_execution(platform_key, "authorized_lazy", &block)
+        instrument_prometheus_execution(platform_key, "authorized_lazy", &block)
       end
 
       def platform_resolve_type(platform_key, &block)
-        instrument_execution(platform_key, "resolve_type", &block)
+        instrument_prometheus_execution(platform_key, "resolve_type", &block)
       end
 
       def platform_resolve_type_lazy(platform_key, &block)
-        instrument_execution(platform_key, "resolve_type_lazy", &block)
+        instrument_prometheus_execution(platform_key, "resolve_type_lazy", &block)
       end
 
       def platform_field_key(field)
@@ -68,7 +68,7 @@ module GraphQL
 
       private
 
-      def instrument_execution(platform_key, key, &block)
+      def instrument_prometheus_execution(platform_key, key, &block)
         if @keys_whitelist.include?(key)
           start = ::Process.clock_gettime ::Process::CLOCK_MONOTONIC
           result = block.call