graphql 2.3.4 → 2.3.6

data/lib/graphql/schema/field.rb

@@ -41,6 +41,14 @@ module GraphQL
         end
       end
 
+      def directives
+        if @resolver_class
+          @resolver_class.directives
+        else
+          super
+        end
+      end
+
       # @return [Class] The thing this field was defined on (type, mutation, resolver)
       attr_accessor :owner
 

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/resolver.rb

@@ -25,6 +25,7 @@ module GraphQL
       extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
+      extend Schema::Member::HasDirectives
 
       # @param object [Object] The application object that this field is being resolved on
       # @param context [GraphQL::Query::Context]

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/subscriptions/broadcast_analyzer.rb

@@ -9,7 +9,7 @@ module GraphQL
     # Assign the result to `context.namespace(:subscriptions)[:subscription_broadcastable]`
     # @api private
     # @see Subscriptions#broadcastable? for a public API
-    class BroadcastAnalyzer < GraphQL::Analysis::AST::Analyzer
+    class BroadcastAnalyzer < GraphQL::Analysis::Analyzer
       def initialize(subject)
         super
         @default_broadcastable = subject.schema.subscriptions.default_broadcastable

data/lib/graphql/subscriptions.rb

@@ -235,7 +235,7 @@ module GraphQL
       if !query.valid?
         raise "Invalid query: #{query.validation_errors.map(&:to_h).inspect}"
       end
-      GraphQL::Analysis::AST.analyze_query(query, @schema.query_analyzers)
+      GraphQL::Analysis.analyze_query(query, @schema.query_analyzers)
       query.context.namespace(:subscriptions)[:subscription_broadcastable]
     end
 

data/lib/graphql/type_kinds.rb

@@ -16,7 +16,7 @@ module GraphQL
         @description = description
       end
 
-      # Does this TypeKind have multiple possible implementors?
+      # Does this TypeKind have multiple possible implementers?
       # @deprecated Use `abstract?` instead of `resolves?`.
       def resolves?;  @abstract;  end
       # Is this TypeKind abstract?

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -6,14 +6,6 @@ require "singleton"
 require "forwardable"
 
 module GraphQL
-  # forwards-compat for argument handling
-  module Ruby2Keywords
-    if RUBY_VERSION < "2.7"
-      def ruby2_keywords(*)
-      end
-    end
-  end
-
   class Error < StandardError
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.3.4
+  version: 2.3.6
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-21 00:00:00.000000000 Z
+date: 2024-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -306,14 +306,13 @@ files:
 - lib/generators/graphql/union_generator.rb
 - lib/graphql.rb
 - lib/graphql/analysis.rb
-- lib/graphql/analysis/ast.rb
-- lib/graphql/analysis/ast/analyzer.rb
-- lib/graphql/analysis/ast/field_usage.rb
-- lib/graphql/analysis/ast/max_query_complexity.rb
-- lib/graphql/analysis/ast/max_query_depth.rb
-- lib/graphql/analysis/ast/query_complexity.rb
-- lib/graphql/analysis/ast/query_depth.rb
-- lib/graphql/analysis/ast/visitor.rb
+- lib/graphql/analysis/analyzer.rb
+- lib/graphql/analysis/field_usage.rb
+- lib/graphql/analysis/max_query_complexity.rb
+- lib/graphql/analysis/max_query_depth.rb
+- lib/graphql/analysis/query_complexity.rb
+- lib/graphql/analysis/query_depth.rb
+- lib/graphql/analysis/visitor.rb
 - lib/graphql/analysis_error.rb
 - lib/graphql/backtrace.rb
 - lib/graphql/backtrace/inspect_result.rb
@@ -645,7 +644,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.12
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    module AST
-      # Query analyzer for query ASTs. Query analyzers respond to visitor style methods
-      # but are prefixed by `enter` and `leave`.
-      #
-      # When an analyzer is initialized with a Multiplex, you can always get the current query from
-      # `visitor.query` in the visit methods.
-      #
-      # @param [GraphQL::Query, GraphQL::Execution::Multiplex] The query or multiplex to analyze
-      class Analyzer
-        def initialize(subject)
-          @subject = subject
-
-          if subject.is_a?(GraphQL::Query)
-            @query = subject
-            @multiplex = nil
-          else
-            @multiplex = subject
-            @query = nil
-          end
-        end
-
-        # Analyzer hook to decide at analysis time whether a query should
-        # be analyzed or not.
-        # @return [Boolean] If the query should be analyzed or not
-        def analyze?
-          true
-        end
-
-        # Analyzer hook to decide at analysis time whether analysis
-        # requires a visitor pass; can be disabled for precomputed results.
-        # @return [Boolean] If analysis requires visitation or not
-        def visit?
-          true
-        end
-
-        # The result for this analyzer. Returning {GraphQL::AnalysisError} results
-        # in a query error.
-        # @return [Any] The analyzer result
-        def result
-          raise GraphQL::RequiredImplementationMissingError
-        end
-
-        class << self
-          private
-
-          def build_visitor_hooks(member_name)
-            class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-              def on_enter_#{member_name}(node, parent, visitor)
-              end
-
-              def on_leave_#{member_name}(node, parent, visitor)
-              end
-            EOS
-          end
-        end
-
-        build_visitor_hooks :argument
-        build_visitor_hooks :directive
-        build_visitor_hooks :document
-        build_visitor_hooks :enum
-        build_visitor_hooks :field
-        build_visitor_hooks :fragment_spread
-        build_visitor_hooks :inline_fragment
-        build_visitor_hooks :input_object
-        build_visitor_hooks :list_type
-        build_visitor_hooks :non_null_type
-        build_visitor_hooks :null_value
-        build_visitor_hooks :operation_definition
-        build_visitor_hooks :type_name
-        build_visitor_hooks :variable_definition
-        build_visitor_hooks :variable_identifier
-        build_visitor_hooks :abstract_node
-
-        protected
-
-        # @return [GraphQL::Query, GraphQL::Execution::Multiplex] Whatever this analyzer is analyzing
-        attr_reader :subject
-
-        # @return [GraphQL::Query, nil] `nil` if this analyzer is visiting a multiplex
-        #  (When this is `nil`, use `visitor.query` inside visit methods to get the current query)
-        attr_reader :query
-
-        # @return [GraphQL::Execution::Multiplex, nil] `nil` if this analyzer is visiting a query
-        attr_reader :multiplex
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    module AST
-      class FieldUsage < Analyzer
-        def initialize(query)
-          super
-          @used_fields = Set.new
-          @used_deprecated_fields = Set.new
-          @used_deprecated_arguments = Set.new
-          @used_deprecated_enum_values = Set.new
-        end
-
-        def on_leave_field(node, parent, visitor)
-          field_defn = visitor.field_definition
-          field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
-          @used_fields << field
-          @used_deprecated_fields << field if field_defn.deprecation_reason
-          arguments = visitor.query.arguments_for(node, field_defn)
-          # If there was an error when preparing this argument object,
-          # then this might be an error or something:
-          if arguments.respond_to?(:argument_values)
-            extract_deprecated_arguments(arguments.argument_values)
-          end
-        end
-
-        def result
-          {
-            used_fields: @used_fields.to_a,
-            used_deprecated_fields: @used_deprecated_fields.to_a,
-            used_deprecated_arguments: @used_deprecated_arguments.to_a,
-            used_deprecated_enum_values: @used_deprecated_enum_values.to_a,
-          }
-        end
-
-        private
-
-        def extract_deprecated_arguments(argument_values)
-          argument_values.each_pair do |_argument_name, argument|
-            if argument.definition.deprecation_reason
-              @used_deprecated_arguments << argument.definition.path
-            end
-
-            arg_val = argument.value
-
-            next if arg_val.nil?
-
-            argument_type = argument.definition.type
-            if argument_type.non_null?
-              argument_type = argument_type.of_type
-            end
-
-            if argument_type.kind.input_object?
-              extract_deprecated_arguments(argument.original_value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
-            elsif argument_type.kind.enum?
-              extract_deprecated_enum_value(argument_type, arg_val)
-            elsif argument_type.list?
-              inner_type = argument_type.unwrap
-              case inner_type.kind
-              when TypeKinds::INPUT_OBJECT
-                argument.original_value.each do |value|
-                  extract_deprecated_arguments(value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
-                end
-              when TypeKinds::ENUM
-                arg_val.each do |value|
-                  extract_deprecated_enum_value(inner_type, value)
-                end
-              else
-                # Not a kind of input that we track
-              end
-            end
-          end
-        end
-
-        def extract_deprecated_enum_value(enum_type, value)
-          enum_value = @query.warden.enum_values(enum_type).find { |ev| ev.value == value }
-          if enum_value&.deprecation_reason
-            @used_deprecated_enum_values << enum_value.path
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    module AST
-      # Used under the hood to implement complexity validation,
-      # see {Schema#max_complexity} and {Query#max_complexity}
-      class MaxQueryComplexity < QueryComplexity
-        def result
-          return if subject.max_complexity.nil?
-
-          total_complexity = max_possible_complexity
-
-          if total_complexity > subject.max_complexity
-            GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{subject.max_complexity}")
-          else
-            nil
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    module AST
-      class MaxQueryDepth < QueryDepth
-        def result
-          configured_max_depth = if query
-            query.max_depth
-          else
-            multiplex.schema.max_depth
-          end
-
-          if configured_max_depth && @max_depth > configured_max_depth
-            GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{configured_max_depth}")
-          else
-            nil
-          end
-        end
-      end
-    end
-  end
-end