graphql 1.13.24 → 2.5.11

data/lib/graphql/analysis/analyze_query.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    module_function
-
-    def use(schema_class)
-      schema = schema_class.is_a?(Class) ? schema_class : schema_class.target
-      schema.analysis_engine = self
-    end
-
-    # @return [void]
-    def analyze_multiplex(multiplex, analyzers)
-      multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
-        reducer_states = analyzers.map { |r| ReducerState.new(r, multiplex) }
-        query_results = multiplex.queries.map do |query|
-          if query.valid?
-            analyze_query(query, query.analyzers, multiplex_states: reducer_states)
-          else
-            []
-          end
-        end
-
-        multiplex_results = reducer_states.map(&:finalize_reducer)
-        multiplex_errors = analysis_errors(multiplex_results)
-
-        multiplex.queries.each_with_index do |query, idx|
-          query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
-        end
-      end
-      nil
-    end
-
-    # Visit `query`'s internal representation, calling `analyzers` along the way.
-    #
-    # - First, query analyzers are filtered down by calling `.analyze?(query)`, if they respond to that method
-    # - Then, query analyzers are initialized by calling `.initial_value(query)`, if they respond to that method.
-    # - Then, they receive `.call(memo, visit_type, irep_node)`, where visit type is `:enter` or `:leave`.
-    # - Last, they receive `.final_value(memo)`, if they respond to that method.
-    #
-    # It returns an array of final `memo` values in the order that `analyzers` were passed in.
-    #
-    # @param query [GraphQL::Query]
-    # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
-    # @return [Array<Any>] Results from those analyzers
-    def analyze_query(query, analyzers, multiplex_states: [])
-      GraphQL::Deprecation.warn "Legacy analysis will be removed in GraphQL-Ruby 2.0, please upgrade to AST Analysis: https://graphql-ruby.org/queries/ast_analysis.html (schema: #{query.schema})"
-
-      query.trace("analyze_query", { query: query }) do
-        analyzers_to_run = analyzers.select do |analyzer|
-          if analyzer.respond_to?(:analyze?)
-            analyzer.analyze?(query)
-          else
-            true
-          end
-        end
-
-        reducer_states = analyzers_to_run.map { |r| ReducerState.new(r, query) } + multiplex_states
-
-        irep = query.internal_representation
-
-        irep.operation_definitions.each do |name, op_node|
-          reduce_node(op_node, reducer_states)
-        end
-
-        reducer_states.map(&:finalize_reducer)
-      end
-    end
-
-    private
-
-    module_function
-
-    # Enter the node, visit its children, then leave the node.
-    def reduce_node(irep_node, reducer_states)
-      visit_analyzers(:enter, irep_node, reducer_states)
-
-      irep_node.typed_children.each do |type_defn, children|
-        children.each do |name, child_irep_node|
-          reduce_node(child_irep_node, reducer_states)
-        end
-      end
-
-      visit_analyzers(:leave, irep_node, reducer_states)
-    end
-
-    def visit_analyzers(visit_type, irep_node, reducer_states)
-      reducer_states.each do |reducer_state|
-        next_memo = reducer_state.call(visit_type, irep_node)
-
-        reducer_state.memo = next_memo
-      end
-    end
-
-    def analysis_errors(results)
-      results.flatten.select { |r| r.is_a?(GraphQL::AnalysisError) }
-    end
-  end
-end

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

@@ -1,84 +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
-
-        # 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,55 +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
-        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, visitor.field_definition)
-          # 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,
-          }
-        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
-
-            if argument.definition.type.kind.input_object?
-              extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
-            elsif argument.definition.type.list? && !argument.value.nil?
-              argument
-                .value
-                .select { |value| value.respond_to?(:arguments) }
-                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) } # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require_relative "./query_complexity"
-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,230 +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 in an IRep node
-        def initialize(query)
-          super
-          @complexities_on_type_by_query = {}
-        end
-
-        # Overide this method to use the complexity result
-        def result
-          max_possible_complexity
-        end
-
-        class ScopedTypeComplexity
-          # A single proc for {#scoped_children} hashes. Use this to avoid repeated allocations,
-          # since the lexical binding isn't important.
-          HASH_CHILDREN = ->(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
-          def initialize(parent_type, field_definition, query, response_path)
-            @parent_type = parent_type
-            @field_definition = field_definition
-            @query = query
-            @response_path = response_path
-            @scoped_children = nil
-            @nodes = []
-          end
-
-          # @return [Array<GraphQL::Language::Nodes::Field>]
-          attr_reader :nodes
-
-          # Returns true if this field has no selections, ie, it's a scalar.
-          # We need a quick way to check whether we should continue traversing.
-          def terminal?
-            @scoped_children.nil?
-          end
-
-          # This value is only calculated when asked for to avoid needless hash allocations.
-          # Also, if it's never asked for, we determine that this scope complexity
-          # is a scalar field ({#terminal?}).
-          # @return [Hash<Hash<Class => ScopedTypeComplexity>]
-          def scoped_children
-            @scoped_children ||= Hash.new(&HASH_CHILDREN)
-          end
-
-          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?
-          parent_type = visitor.parent_type_definition
-          field_key = node.alias || node.name
-          # Find the complexity calculation for this field --
-          # if we're re-entering a selection, we'll already have one.
-          # Otherwise, make a new one and store it.
-          #
-          # `node` and `visitor.field_definition` may appear from a cache,
-          # but I think that's ok. If the arguments _didn't_ match,
-          # then the query would have been rejected as invalid.
-          complexities_on_type = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query, visitor.response_path)]
-
-          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(parent_type, visitor.field_definition, visitor.query, visitor.response_path)
-          complexity.nodes.push(node)
-          # Push it on the stack.
-          complexities_on_type.push(complexity)
-        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?
-          complexities_on_type = @complexities_on_type_by_query[visitor.query]
-          complexities_on_type.pop
-        end
-
-        private
-
-        # @return [Integer]
-        def max_possible_complexity
-          @complexities_on_type_by_query.reduce(0) do |total, (query, complexities_on_type)|
-            root_complexity = complexities_on_type.last
-            # Use this entry point to calculate the total complexity
-            total_complexity_for_query = merged_max_complexity_for_scopes(query, [root_complexity.scoped_children])
-            total + total_complexity_for_query
-          end
-        end
-
-        # @param query [GraphQL::Query] Used for `query.possible_types`
-        # @param scoped_children_hashes [Array<Hash>] Array of scoped children hashes
-        # @return [Integer]
-        def merged_max_complexity_for_scopes(query, scoped_children_hashes)
-          # Figure out what scopes are possible here.
-          # Use a hash, but ignore the values; it's just a fast way to work with the keys.
-          all_scopes = {}
-          scoped_children_hashes.each do |h|
-            all_scopes.merge!(h)
-          end
-
-          # If an abstract scope is present, but _all_ of its concrete types
-          # are also in the list, remove it from the list of scopes to check,
-          # because every possible type is covered by a concrete type.
-          # (That is, there are no remainder types to check.)
-          prev_keys = all_scopes.keys
-          prev_keys.each do |scope|
-            next unless scope.kind.abstract?
-
-            missing_concrete_types = query.possible_types(scope).select { |t| !all_scopes.key?(t) }
-            # This concrete type is possible _only_ as a member of the abstract type.
-            # So, attribute to it the complexity which belongs to the abstract type.
-            missing_concrete_types.each do |concrete_scope|
-              all_scopes[concrete_scope] = all_scopes[scope]
-            end
-            all_scopes.delete(scope)
-          end
-
-          # This will hold `{ type => int }` pairs, one for each possible branch
-          complexity_by_scope = {}
-
-          # For each scope,
-          # find the lexical selections that might apply to it,
-          # and gather them together into an array.
-          # Then, treat the set of selection hashes
-          # as a set and calculate the complexity for them as a unit
-          all_scopes.each do |scope, _|
-            # These will be the selections on `scope`
-            children_for_scope = []
-            scoped_children_hashes.each do |sc_h|
-              sc_h.each do |inner_scope, children_hash|
-                if applies_to?(query, scope, inner_scope)
-                  children_for_scope << children_hash
-                end
-              end
-            end
-
-            # Calculate the complexity for `scope`, merging all
-            # possible lexical branches.
-            complexity_value = merged_max_complexity(query, children_for_scope)
-            complexity_by_scope[scope] = complexity_value
-          end
-
-          # Return the max complexity among all scopes
-          complexity_by_scope.each_value.max
-        end
-
-        def applies_to?(query, left_scope, right_scope)
-          if left_scope == right_scope
-            # This can happen when several branches are being analyzed together
-            true
-          else
-            # Check if these two scopes have _any_ types in common.
-            possible_right_types = query.possible_types(right_scope)
-            possible_left_types = query.possible_types(left_scope)
-            !(possible_right_types & possible_left_types).empty?
-          end
-        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 children_for_scope [Array<Hash>] An array of `scoped_children[scope]` hashes
-        # (`{field_key => complexity}`)
-        # @return [Integer] Complexity value for all these selections in the current scope
-        def merged_max_complexity(query, children_for_scope)
-          all_keys = []
-          children_for_scope.each do |c|
-            all_keys.concat(c.keys)
-          end
-          all_keys.uniq!
-          complexity_for_keys = {}
-
-          all_keys.each do |child_key|
-            scoped_children_for_key = nil
-            complexity_for_key = nil
-            children_for_scope.each do |children_hash|
-              next unless children_hash.key?(child_key)
-
-              complexity_for_key = children_hash[child_key]
-              if complexity_for_key.terminal?
-                # Assume that all terminals would return the same complexity
-                # Since it's a terminal, its child complexity is zero.
-                complexity = complexity_for_key.own_complexity(0)
-                complexity_for_keys[child_key] = complexity
-
-                field_complexity(complexity_for_key, max_complexity: complexity, child_complexity: nil)
-              else
-                scoped_children_for_key ||= []
-                scoped_children_for_key << complexity_for_key.scoped_children
-              end
-            end
-
-            next unless scoped_children_for_key
-
-            child_complexity = merged_max_complexity_for_scopes(query, scoped_children_for_key)
-            # This is the _last_ one we visited; assume it's representative.
-            max_complexity = complexity_for_key.own_complexity(child_complexity)
-
-            field_complexity(complexity_for_key, max_complexity: max_complexity, child_complexity: child_complexity)
-
-            complexity_for_keys[child_key] = max_complexity
-          end
-
-          # Calculate the child complexity by summing the complexity of all selections
-          complexity_for_keys.each_value.inject(0, &:+)
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    # A query reducer for measuring the depth of a given query.
-    #
-    # See https://graphql-ruby.org/queries/ast_analysis.html for more examples.
-    #
-    # @example Logging the depth of a query
-    #   class LogQueryDepth < GraphQL::Analysis::QueryDepth
-    #     def result
-    #       log("GraphQL query depth: #{@max_depth}")
-    #     end
-    #   end
-    #
-    #   # In your Schema file:
-    #
-    #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Analysis::AST
-    #     query_analyzer LogQueryDepth
-    #   end
-    #
-    #   # When you run the query, the depth will get logged:
-    #
-    #   Schema.execute(query_str)
-    #   # GraphQL query depth: 8
-    #
-    module AST
-      class QueryDepth < Analyzer
-        def initialize(query)
-          @max_depth = 0
-          @current_depth = 0
-          super
-        end
-
-        def on_enter_field(node, parent, visitor)
-          return if visitor.skipping? || visitor.visiting_fragment_definition?
-
-          @current_depth += 1
-        end
-
-        def on_leave_field(node, parent, visitor)
-          return if visitor.skipping? || visitor.visiting_fragment_definition?
-
-          if @max_depth < @current_depth
-            @max_depth = @current_depth
-          end
-          @current_depth -= 1
-        end
-
-        def result
-          @max_depth
-        end
-      end
-    end
-  end
-end