graphql 2.3.5 → 2.3.12

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

@@ -16,11 +16,11 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
-        args = defn.arguments(context.query.context)
+        args = @context.query.types.arguments(defn)
         return if args.empty?
         present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = context.warden.arguments(defn)
-          .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
+        required_argument_names = context.query.types.arguments(defn)
+          .select { |a| a.type.kind.non_null? && !a.default_value? && context.query.types.argument(defn, a.name) }
           .map!(&:name)
 
         missing_names = required_argument_names - present_argument_names

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

@@ -26,7 +26,7 @@ module GraphQL
           context.directive_definition || context.field_definition
         end
 
-        parent_type = context.warden.get_argument(defn, parent_name(parent, defn))
+        parent_type = context.types.argument(defn, parent_name(parent, defn))
         parent_type ? parent_type.type.unwrap : nil
       end
 
@@ -34,7 +34,7 @@ module GraphQL
         parent_type = get_parent_type(context, parent)
         return unless parent_type && parent_type.kind.input_object?
 
-        required_fields = context.warden.arguments(parent_type)
+        required_fields = context.types.arguments(parent_type)
           .select{ |arg| arg.type.kind.non_null? && !arg.default_value? }
           .map!(&:graphql_name)
 
@@ -43,7 +43,7 @@ module GraphQL
 
         missing_fields.each do |missing_field|
           path = [*context.path, missing_field]
-          missing_field_type = context.warden.get_argument(parent_type, missing_field).type
+          missing_field_type = context.types.argument(parent_type, missing_field).type
           add_error(RequiredInputObjectAttributesArePresentError.new(
             "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
             argument_name: missing_field,

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

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     module SubscriptionRootExists
       def on_operation_definition(node, _parent)
-        if node.operation_type == "subscription" && context.warden.root_type_for_operation("subscription").nil?
+        if node.operation_type == "subscription" && context.types.subscription_root.nil?
           add_error(GraphQL::StaticValidation::SubscriptionRootExistsError.new(
             'Schema is not configured for subscriptions',
             nodes: node

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

@@ -5,36 +5,27 @@ module GraphQL
       def on_variable_definition(node, parent)
         if !node.default_value.nil?
           value = node.default_value
-          if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
-            add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
-              "Non-null variable $#{node.name} can't have a default value",
-              nodes: node,
-              name: node.name,
-              error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_ON_NON_NULL]
-            ))
+          type = context.schema.type_from_ast(node.type, context: context)
+          if type.nil?
+            # This is handled by another validator
           else
-            type = context.schema.type_from_ast(node.type, context: context)
-            if type.nil?
-              # This is handled by another validator
-            else
-              validation_result = context.validate_literal(value, type)
+            validation_result = context.validate_literal(value, type)
 
-              if !validation_result.valid?
-                problems = validation_result.problems
-                first_problem = problems && problems.first
-                if first_problem
-                  error_message = first_problem["explanation"]
-                end
-
-                error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
-                add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
-                  error_message,
-                  nodes: node,
-                  name: node.name,
-                  type: type.to_type_signature,
-                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE],
-                ))
+            if !validation_result.valid?
+              problems = validation_result.problems
+              first_problem = problems && problems.first
+              if first_problem
+                error_message = first_problem["explanation"]
               end
+
+              error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
+              add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
+                error_message,
+                nodes: node,
+                name: node.name,
+                type: type.to_type_signature,
+                error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE],
+              ))
             end
           end
         end

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

@@ -65,7 +65,7 @@ module GraphQL
           end
         end
 
-        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
+        arg_defn = @types.argument(argument_owner, arg_node.name)
         arg_defn_type = arg_defn.type
 
         # If the argument is non-null, but it was given a default value,

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

@@ -4,7 +4,7 @@ module GraphQL
     module VariablesAreInputTypes
       def on_variable_definition(node, parent)
         type_name = get_type_name(node.type)
-        type = context.warden.get_type(type_name)
+        type = context.query.types.type(type_name)
 
         if type.nil?
           add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(

data/lib/graphql/static_validation/validation_context.rb

@@ -13,14 +13,14 @@ module GraphQL
 
       attr_reader :query, :errors, :visitor,
         :on_dependency_resolve_handlers,
-        :max_errors, :warden, :schema
+        :max_errors, :types, :schema
 
 
       def_delegators :@query, :document, :fragments, :operations
 
       def initialize(query, visitor_class, max_errors)
         @query = query
-        @warden = query.warden
+        @types = query.types # TODO update migrated callers to use this accessor
         @schema = query.schema
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []

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
@@ -28,9 +28,8 @@ module GraphQL
         end
 
         current_field = visitor.field_definition
-        apply_broadcastable(current_field)
-
         current_type = visitor.parent_type_definition
+        apply_broadcastable(current_type, current_field)
         if current_type.kind.interface?
           pt = @query.possible_types(current_type)
           pt.each do |object_type|
@@ -38,7 +37,7 @@ module GraphQL
             # Inherited fields would be exactly the same object;
             # only check fields that are overrides of the inherited one
             if ot_field && ot_field != current_field
-              apply_broadcastable(ot_field)
+              apply_broadcastable(object_type, ot_field)
             end
           end
         end
@@ -55,10 +54,16 @@ module GraphQL
       private
 
       # Modify `@subscription_broadcastable` based on `field_defn`'s configuration (and/or the default value)
-      def apply_broadcastable(field_defn)
+      def apply_broadcastable(owner_type, field_defn)
         current_field_broadcastable = field_defn.introspection? || field_defn.broadcastable?
+
+        if current_field_broadcastable.nil? && owner_type.respond_to?(:default_broadcastable?)
+          current_field_broadcastable = owner_type.default_broadcastable?
+        end
+
         case current_field_broadcastable
         when nil
+          query.logger.debug { "`broadcastable: nil` for field: #{field_defn.path}" }
           # If the value wasn't set, mix in the default value:
           # - If the default is false and the current value is true, make it false
           # - If the default is true and the current value is true, it stays true
@@ -66,6 +71,7 @@ module GraphQL
           # - If the default is true and the current value is false, keep it false
           @subscription_broadcastable = @subscription_broadcastable && @default_broadcastable
         when false
+          query.logger.debug { "`broadcastable: false` for field: #{field_defn.path}" }
           # One non-broadcastable field is enough to make the whole subscription non-broadcastable
           @subscription_broadcastable = false
         when true

data/lib/graphql/subscriptions/event.rb

@@ -137,7 +137,7 @@ module GraphQL
         end
 
         def get_arg_definition(arg_owner, arg_name, context)
-          arg_owner.get_argument(arg_name, context) || arg_owner.arguments(context).each_value.find { |v| v.keyword.to_s == arg_name }
+          context.types.argument(arg_owner, arg_name) || context.types.arguments(arg_owner).find { |v| v.keyword.to_s == arg_name }
         end
       end
     end

data/lib/graphql/subscriptions.rb

@@ -64,12 +64,12 @@ module GraphQL
       event_name = event_name.to_s
 
       # Try with the verbatim input first:
-      field = @schema.get_field(@schema.subscription, event_name, context)
+      field = dummy_query.types.field(@schema.subscription, event_name) # rubocop:disable Development/ContextIsPassedCop
 
       if field.nil?
         # And if it wasn't found, normalize it:
         normalized_event_name = normalize_name(event_name)
-        field = @schema.get_field(@schema.subscription, normalized_event_name, context)
+        field = dummy_query.types.field(@schema.subscription, normalized_event_name) # rubocop:disable Development/ContextIsPassedCop
         if field.nil?
           raise InvalidTriggerError, "No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
         end
@@ -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/testing/helpers.rb

@@ -43,7 +43,7 @@ module GraphQL
         type_name, *field_names = field_path.split(".")
         dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context)
         query_context = dummy_query.context
-        object_type = dummy_query.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
+        object_type = dummy_query.types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
         if object_type
           graphql_result = object
           field_names.each do |field_name|
@@ -52,7 +52,7 @@ module GraphQL
             if graphql_result.nil?
               return nil
             end
-            visible_field = dummy_query.get_field(object_type, field_name)
+            visible_field = dummy_query.types.field(object_type, field_name) # rubocop:disable Development/ContextIsPassedCop
             if visible_field
               dummy_query.context.dataloader.run_isolated {
                 field_args = visible_field.coerce_arguments(graphql_result, arguments, query_context)
@@ -90,10 +90,13 @@ module GraphQL
             end
           end
           graphql_result
-        elsif schema.has_defined_type?(type_name)
-          raise TypeNotVisibleError.new(type_name: type_name)
         else
-          raise TypeNotDefinedError.new(type_name: type_name)
+          unfiltered_type = Schema::Subset.pass_thru(schema: schema, context: context).type(type_name)
+          if unfiltered_type
+            raise TypeNotVisibleError.new(type_name: type_name)
+          else
+            raise TypeNotDefinedError.new(type_name: type_name)
+          end
         end
       end
 

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -18,6 +18,7 @@ module GraphQL
             self.node_type = nil
             self.edge_class = nil
           }
+          child_class.default_broadcastable(nil)
           add_page_info_field(child_class)
         end
 
@@ -31,12 +32,21 @@ module GraphQL
             child_class.edge_type = nil
             child_class.node_type = nil
             child_class.edge_class = nil
+            child_class.default_broadcastable(default_broadcastable?)
           end
 
           def default_relay?
             true
           end
 
+          def default_broadcastable?
+            @default_broadcastable
+          end
+
+          def default_broadcastable(new_value)
+            @default_broadcastable = new_value
+          end
+
           # @return [Class]
           attr_reader :node_type
 

data/lib/graphql/types/relay/edge_behaviors.rb

@@ -10,6 +10,7 @@ module GraphQL
           child_class.extend(ClassMethods)
           child_class.class_eval { self.node_type = nil }
           child_class.node_nullable(true)
+          child_class.default_broadcastable(nil)
         end
 
         def node
@@ -24,12 +25,21 @@ module GraphQL
             super
             child_class.node_type = nil
             child_class.node_nullable = nil
+            child_class.default_broadcastable(default_broadcastable?)
           end
 
           def default_relay?
             true
           end
 
+          def default_broadcastable?
+            @default_broadcastable
+          end
+
+          def default_broadcastable(new_value)
+            @default_broadcastable = new_value
+          end
+
           # Get or set the Object type that this edge wraps.
           #
           # @param node_type [Class] A `Schema::Object` subclass

data/lib/graphql/types/relay/page_info_behaviors.rb

@@ -24,6 +24,10 @@ module GraphQL
         def default_relay?
           true
         end
+
+        def default_broadcastable?
+          true
+        end
       end
     end
   end

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -4,6 +4,7 @@ require "json"
 require "set"
 require "singleton"
 require "forwardable"
+require "fiber/storage"
 
 module GraphQL
   class Error < StandardError
@@ -121,3 +122,4 @@ require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
 require "graphql/testing"
+require "graphql/current"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.3.5
+  version: 2.3.12
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-13 00:00:00.000000000 Z
+date: 2024-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fiber-storage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -306,14 +320,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
@@ -322,6 +335,7 @@ files:
 - lib/graphql/backtrace/traced_error.rb
 - lib/graphql/backtrace/tracer.rb
 - lib/graphql/coercion_error.rb
+- lib/graphql/current.rb
 - lib/graphql/dataloader.rb
 - lib/graphql/dataloader/async_dataloader.rb
 - lib/graphql/dataloader/null_dataloader.rb
@@ -377,7 +391,6 @@ files:
 - lib/graphql/language/printer.rb
 - lib/graphql/language/sanitized_printer.rb
 - lib/graphql/language/static_visitor.rb
-- lib/graphql/language/token.rb
 - lib/graphql/language/visitor.rb
 - lib/graphql/load_application_object_failed_error.rb
 - lib/graphql/name_validator.rb
@@ -440,7 +453,6 @@ files:
 - lib/graphql/schema/input_object.rb
 - lib/graphql/schema/interface.rb
 - lib/graphql/schema/introspection_system.rb
-- lib/graphql/schema/invalid_type_error.rb
 - lib/graphql/schema/late_bound_type.rb
 - lib/graphql/schema/list.rb
 - lib/graphql/schema/loader.rb
@@ -471,12 +483,15 @@ files:
 - lib/graphql/schema/resolver/has_payload_type.rb
 - lib/graphql/schema/scalar.rb
 - lib/graphql/schema/subscription.rb
+- lib/graphql/schema/subset.rb
 - lib/graphql/schema/timeout.rb
 - lib/graphql/schema/type_expression.rb
 - lib/graphql/schema/type_membership.rb
+- lib/graphql/schema/types_migration.rb
 - lib/graphql/schema/union.rb
 - lib/graphql/schema/unique_within_type.rb
 - lib/graphql/schema/validator.rb
+- lib/graphql/schema/validator/all_validator.rb
 - lib/graphql/schema/validator/allow_blank_validator.rb
 - lib/graphql/schema/validator/allow_null_validator.rb
 - lib/graphql/schema/validator/exclusion_validator.rb
@@ -645,7 +660,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.3.7
 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