graphql 2.3.5 → 2.3.14

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.3.5
+  version: 2.3.14
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-13 00:00:00.000000000 Z
+date: 2024-08-13 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
@@ -409,6 +422,8 @@ files:
 - lib/graphql/rubocop/graphql/base_cop.rb
 - lib/graphql/rubocop/graphql/default_null_true.rb
 - lib/graphql/rubocop/graphql/default_required_true.rb
+- lib/graphql/rubocop/graphql/field_type_in_block.rb
+- lib/graphql/rubocop/graphql/root_types_in_block.rb
 - lib/graphql/runtime_type_error.rb
 - lib/graphql/schema.rb
 - lib/graphql/schema/addition.rb
@@ -440,7 +455,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 +485,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
@@ -615,6 +632,7 @@ files:
 - lib/graphql/types/relay/page_info.rb
 - lib/graphql/types/relay/page_info_behaviors.rb
 - lib/graphql/types/string.rb
+- lib/graphql/unauthorized_enum_value_error.rb
 - lib/graphql/unauthorized_error.rb
 - lib/graphql/unauthorized_field_error.rb
 - lib/graphql/unresolved_type_error.rb
@@ -645,7 +663,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

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

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

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    # Calculate the complexity of a query, using {Field#complexity} values.
-    module AST
-      class QueryComplexity < Analyzer
-        # State for the query complexity calculation:
-        # - `complexities_on_type` holds complexity scores for each type
-        def initialize(query)
-          super
-          @skip_introspection_fields = !query.schema.max_complexity_count_introspection_fields
-          @complexities_on_type_by_query = {}
-        end
-
-        # Override this method to use the complexity result
-        def result
-          max_possible_complexity
-        end
-
-        # ScopedTypeComplexity models a tree of GraphQL types mapped to inner selections, ie:
-        # Hash<GraphQL::BaseType, Hash<String, ScopedTypeComplexity>>
-        class ScopedTypeComplexity < Hash
-          # A proc for defaulting empty namespace requests as a new scope hash.
-          DEFAULT_PROC = ->(h, k) { h[k] = {} }
-
-          attr_reader :field_definition, :response_path, :query
-
-          # @param parent_type [Class] The owner of `field_definition`
-          # @param field_definition [GraphQL::Field, GraphQL::Schema::Field] Used for getting the `.complexity` configuration
-          # @param query [GraphQL::Query] Used for `query.possible_types`
-          # @param response_path [Array<String>] The path to the response key for the field
-          # @return [Hash<GraphQL::BaseType, Hash<String, ScopedTypeComplexity>>]
-          def initialize(parent_type, field_definition, query, response_path)
-            super(&DEFAULT_PROC)
-            @parent_type = parent_type
-            @field_definition = field_definition
-            @query = query
-            @response_path = response_path
-            @nodes = []
-          end
-
-          # @return [Array<GraphQL::Language::Nodes::Field>]
-          attr_reader :nodes
-
-          def own_complexity(child_complexity)
-            @field_definition.calculate_complexity(query: @query, nodes: @nodes, child_complexity: child_complexity)
-          end
-        end
-
-        def on_enter_field(node, parent, visitor)
-          # We don't want to visit fragment definitions,
-          # we'll visit them when we hit the spreads instead
-          return if visitor.visiting_fragment_definition?
-          return if visitor.skipping?
-          return if @skip_introspection_fields && visitor.field_definition.introspection?
-          parent_type = visitor.parent_type_definition
-          field_key = node.alias || node.name
-
-          # Find or create a complexity scope stack for this query.
-          scopes_stack = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query, visitor.response_path)]
-
-          # Find or create the complexity costing node for this field.
-          scope = scopes_stack.last[parent_type][field_key] ||= ScopedTypeComplexity.new(parent_type, visitor.field_definition, visitor.query, visitor.response_path)
-          scope.nodes.push(node)
-          scopes_stack.push(scope)
-        end
-
-        def on_leave_field(node, parent, visitor)
-          # We don't want to visit fragment definitions,
-          # we'll visit them when we hit the spreads instead
-          return if visitor.visiting_fragment_definition?
-          return if visitor.skipping?
-          return if @skip_introspection_fields && visitor.field_definition.introspection?
-          scopes_stack = @complexities_on_type_by_query[visitor.query]
-          scopes_stack.pop
-        end
-
-        private
-
-        # @return [Integer]
-        def max_possible_complexity
-          @complexities_on_type_by_query.reduce(0) do |total, (query, scopes_stack)|
-            total + merged_max_complexity_for_scopes(query, [scopes_stack.first])
-          end
-        end
-
-        # @param query [GraphQL::Query] Used for `query.possible_types`
-        # @param scopes [Array<ScopedTypeComplexity>] Array of scoped type complexities
-        # @return [Integer]
-        def merged_max_complexity_for_scopes(query, scopes)
-          # Aggregate a set of all possible scope types encountered (scope keys).
-          # Use a hash, but ignore the values; it's just a fast way to work with the keys.
-          possible_scope_types = scopes.each_with_object({}) do |scope, memo|
-            memo.merge!(scope)
-          end
-
-          # Expand abstract scope types into their concrete implementations;
-          # overlapping abstracts coalesce through their intersecting types.
-          possible_scope_types.keys.each do |possible_scope_type|
-            next unless possible_scope_type.kind.abstract?
-
-            query.possible_types(possible_scope_type).each do |impl_type|
-              possible_scope_types[impl_type] ||= true
-            end
-            possible_scope_types.delete(possible_scope_type)
-          end
-
-          # Aggregate the lexical selections that may apply to each possible type,
-          # and then return the maximum cost among possible typed selections.
-          possible_scope_types.each_key.reduce(0) do |max, possible_scope_type|
-            # Collect inner selections from all scopes that intersect with this possible type.
-            all_inner_selections = scopes.each_with_object([]) do |scope, memo|
-              scope.each do |scope_type, inner_selections|
-                memo << inner_selections if types_intersect?(query, scope_type, possible_scope_type)
-              end
-            end
-
-            # Find the maximum complexity for the scope type among possible lexical branches.
-            complexity = merged_max_complexity(query, all_inner_selections)
-            complexity > max ? complexity : max
-          end
-        end
-
-        def types_intersect?(query, a, b)
-          return true if a == b
-
-          a_types = query.possible_types(a)
-          query.possible_types(b).any? { |t| a_types.include?(t) }
-        end
-
-        # A hook which is called whenever a field's max complexity is calculated.
-        # Override this method to capture individual field complexity details.
-        #
-        # @param scoped_type_complexity [ScopedTypeComplexity]
-        # @param max_complexity [Numeric] Field's maximum complexity including child complexity
-        # @param child_complexity [Numeric, nil] Field's child complexity
-        def field_complexity(scoped_type_complexity, max_complexity:, child_complexity: nil)
-        end
-
-        # @param inner_selections [Array<Hash<String, ScopedTypeComplexity>>] Field selections for a scope
-        # @return [Integer] Total complexity value for all these selections in the parent scope
-        def merged_max_complexity(query, inner_selections)
-          # Aggregate a set of all unique field selection keys across all scopes.
-          # Use a hash, but ignore the values; it's just a fast way to work with the keys.
-          unique_field_keys = inner_selections.each_with_object({}) do |inner_selection, memo|
-            memo.merge!(inner_selection)
-          end
-
-          # Add up the total cost for each unique field name's coalesced selections
-          unique_field_keys.each_key.reduce(0) do |total, field_key|
-            composite_scopes = nil
-            field_cost = 0
-
-            # Collect composite selection scopes for further aggregation,
-            # leaf selections report their costs directly.
-            inner_selections.each do |inner_selection|
-              child_scope = inner_selection[field_key]
-              next unless child_scope
-
-              # Empty child scopes are leaf nodes with zero child complexity.
-              if child_scope.empty?
-                field_cost = child_scope.own_complexity(0)
-                field_complexity(child_scope, max_complexity: field_cost, child_complexity: nil)
-              else
-                composite_scopes ||= []
-                composite_scopes << child_scope
-              end
-            end
-
-            if composite_scopes
-              child_complexity = merged_max_complexity_for_scopes(query, composite_scopes)
-
-              # This is the last composite scope visited; assume it's representative (for backwards compatibility).
-              # Note: it would be more correct to score each composite scope and use the maximum possibility.
-              field_cost = composite_scopes.last.own_complexity(child_complexity)
-              field_complexity(composite_scopes.last, max_complexity: field_cost, child_complexity: child_complexity)
-            end
-
-            total + field_cost
-          end
-        end
-      end
-    end
-  end
-end