graphql 1.13.24 → 2.5.11

data/lib/graphql/query/partial.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # This class is _like_ a {GraphQL::Query}, except it can run on an arbitrary path within a query string.
+    #
+    # It depends on a "parent" {Query}.
+    #
+    # During execution, it calls query-related tracing hooks but passes itself as `query:`.
+    #
+    # The {Partial} will use your {Schema.resolve_type} hook to find the right GraphQL type to use for
+    # `object` in some cases.
+    #
+    # @see Query#run_partials Run via {Query#run_partials}
+    class Partial
+      include Query::Runnable
+
+      # @param path [Array<String, Integer>] A path in `query.query_string` to start executing from
+      # @param object [Object] A starting object for execution
+      # @param query [GraphQL::Query] A full query instance that this partial is based on. Caches are shared.
+      # @param context [Hash] Extra context values to merge into `query.context`, if provided
+      # @param fragment_node [GraphQL::Language::Nodes::InlineFragment, GraphQL::Language::Nodes::FragmentDefinition]
+      def initialize(path: nil, object:, query:, context: nil, fragment_node: nil, type: nil)
+        @path = path
+        @object = object
+        @query = query
+        @schema = query.schema
+        context_vals = @query.context.to_h
+        if context
+          context_vals = context_vals.merge(context)
+        end
+        @context = GraphQL::Query::Context.new(query: self, schema: @query.schema, values: context_vals)
+        @multiplex = nil
+        @result_values = nil
+        @result = nil
+
+        if fragment_node
+          @ast_nodes = [fragment_node]
+          @root_type = type || raise(ArgumentError, "Pass `type:` when using `node:`")
+          # This is only used when `@leaf`
+          @field_definition = nil
+        elsif path.nil?
+          raise ArgumentError, "`path:` is required if `node:` is not given; add `path:`"
+        else
+          set_type_info_from_path
+        end
+
+        @leaf = @root_type.unwrap.kind.leaf?
+      end
+
+      def leaf?
+        @leaf
+      end
+
+      attr_reader :context, :query, :ast_nodes, :root_type, :object, :field_definition, :path, :schema
+
+      attr_accessor :multiplex, :result_values
+
+      class Result < GraphQL::Query::Result
+        def path
+          @query.path
+        end
+
+        # @return [GraphQL::Query::Partial]
+        def partial
+          @query
+        end
+      end
+
+      def result
+        @result ||= Result.new(query: self, values: result_values)
+      end
+
+      def current_trace
+        @query.current_trace
+      end
+
+      def types
+        @query.types
+      end
+
+      def resolve_type(...)
+        @query.resolve_type(...)
+      end
+
+      def variables
+        @query.variables
+      end
+
+      def fragments
+        @query.fragments
+      end
+
+      def valid?
+        @query.valid?
+      end
+
+      def analyzers
+        EmptyObjects::EMPTY_ARRAY
+      end
+
+      def analysis_errors=(_ignored)
+        # pass
+      end
+
+      def subscription?
+        @query.subscription?
+      end
+
+      def selected_operation
+        ast_nodes.first
+      end
+
+      def static_errors
+        @query.static_errors
+      end
+
+      def selected_operation_name
+        @query.selected_operation_name
+      end
+
+      private
+
+      def set_type_info_from_path
+        selections = [@query.selected_operation]
+        type = @query.root_type
+        parent_type = nil
+        field_defn = nil
+
+        @path.each do |name_in_doc|
+          if name_in_doc.is_a?(Integer)
+            if type.list?
+              type = type.unwrap
+              next
+            else
+              raise ArgumentError, "Received path with index `#{name_in_doc}`, but type wasn't a list. Type: #{type.to_type_signature}, path: #{@path}"
+            end
+          end
+
+          next_selections = []
+          selections.each do |selection|
+            selections_to_check = []
+            selections_to_check.concat(selection.selections)
+            while (sel = selections_to_check.shift)
+              case sel
+              when GraphQL::Language::Nodes::InlineFragment
+                selections_to_check.concat(sel.selections)
+              when GraphQL::Language::Nodes::FragmentSpread
+                fragment = @query.fragments[sel.name]
+                selections_to_check.concat(fragment.selections)
+              when GraphQL::Language::Nodes::Field
+                if sel.alias == name_in_doc || sel.name == name_in_doc
+                  next_selections << sel
+                end
+              else
+                raise "Unexpected selection in partial path: #{sel.class}, #{sel.inspect}"
+              end
+            end
+          end
+
+          if next_selections.empty?
+            raise ArgumentError, "Path `#{@path.inspect}` is not present in this query. `#{name_in_doc.inspect}` was not found. Try a different path or rewrite the query to include it."
+          end
+          field_name = next_selections.first.name
+          field_defn = @schema.get_field(type, field_name, @query.context) || raise("Invariant: no field called #{field_name} on #{type.graphql_name}")
+          parent_type = type
+          type = field_defn.type
+          if type.non_null?
+            type = type.of_type
+          end
+          selections = next_selections
+        end
+
+        @ast_nodes = selections
+        @root_type = type
+        @field_definition = field_defn
+      end
+    end
+  end
+end

data/lib/graphql/query/validation_pipeline.rb

@@ -14,11 +14,10 @@ module GraphQL
     #
     # @api private
     class ValidationPipeline
-      attr_reader :max_depth, :max_complexity
+      attr_reader :max_depth, :max_complexity, :validate_timeout_remaining
 
       def initialize(query:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
         @validation_errors = []
-        @internal_representation = nil
         @parse_error = parse_error
         @operation_name_error = operation_name_error
         @query = query
@@ -41,17 +40,15 @@ module GraphQL
         @validation_errors
       end
 
-      # @return [Hash<String, nil => GraphQL::InternalRepresentation::Node] Operation name -> Irep node pairs
-      def internal_representation
-        ensure_has_validated
-        @internal_representation
-      end
-
       def analyzers
         ensure_has_validated
         @query_analyzers
       end
 
+      def has_validated?
+        @has_validated == true
+      end
+
       private
 
       # If the pipeline wasn't run yet, run it.
@@ -62,7 +59,7 @@ module GraphQL
 
         if @parse_error
           # This is kind of crazy: we push the parse error into `ctx`
-          # in {DefaultParseError} so that users can _opt out_ by redefining that hook.
+          # in `def self.parse_error` by default so that users can _opt out_ by redefining that hook.
           # That means we can't _re-add_ the error here (otherwise we'd either
           # add it twice _or_ override the user's choice to not add it).
           # So we just have to know that it was invalid and go from there.
@@ -71,10 +68,10 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
+          validator = @query.static_validator || @schema.static_validator
+          validation_result = validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
-          @internal_representation = validation_result[:irep]
-
+          @validate_timeout_remaining = validation_result[:remaining_timeout]
           if @validation_errors.empty?
             @validation_errors.concat(@query.variables.errors)
           end
@@ -99,35 +96,15 @@ module GraphQL
       def build_analyzers(schema, max_depth, max_complexity)
         qa = schema.query_analyzers.dup
 
-        # Filter out the built in authorization analyzer.
-        # It is deprecated and does not have an AST analyzer alternative.
-        qa = qa.select do |analyzer|
-          if analyzer == GraphQL::Authorization::Analyzer && schema.using_ast_analysis?
-            raise "The Authorization analyzer is not supported with AST Analyzers"
-          else
-            true
-          end
-        end
-
         if max_depth || max_complexity
           # Depending on the analysis engine, we must use different analyzers
           # remove this once everything has switched over to AST analyzers
-          if schema.using_ast_analysis?
-            if max_depth
-              qa << GraphQL::Analysis::AST::MaxQueryDepth
-            end
-            if max_complexity
-              qa << GraphQL::Analysis::AST::MaxQueryComplexity
-            end
-          else
-            if max_depth
-              qa << GraphQL::Analysis::MaxQueryDepth.new(max_depth)
-            end
-            if max_complexity
-              qa << GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)
-            end
+          if max_depth
+            qa << GraphQL::Analysis::MaxQueryDepth
+          end
+          if max_complexity
+            qa << GraphQL::Analysis::MaxQueryComplexity
           end
-
           qa
         else
           qa

data/lib/graphql/query/variable_validation_error.rb

@@ -10,7 +10,7 @@ module GraphQL
 
         msg ||= "Variable $#{variable_ast.name} of type #{type.to_type_signature} was provided invalid value"
 
-        if problem_fields.any?
+        if !problem_fields.empty?
           msg += " for #{problem_fields.join(", ")}"
         end
 

data/lib/graphql/query/variables.rb

@@ -14,7 +14,7 @@ module GraphQL
         schema = ctx.schema
         @context = ctx
 
-        @provided_variables = GraphQL::Argument.deep_stringify(provided_variables)
+        @provided_variables = deep_stringify(provided_variables)
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
           if schema.validate_max_errors && schema.validate_max_errors <= @errors.count
@@ -26,7 +26,7 @@ module GraphQL
           # - Then, fall back to the default value from the query string
           # If it's still nil, raise an error if it's required.
           variable_type = schema.type_from_ast(ast_variable.type, context: ctx)
-          if variable_type.nil?
+          if variable_type.nil? || !variable_type.unwrap.kind.input?
             # Pass -- it will get handled by a validator
           else
             variable_name = ast_variable.name
@@ -39,25 +39,12 @@ module GraphQL
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = if ctx.interpreter?
-                    provided_value
-                  elsif provided_value.nil?
-                    nil
-                  else
-                    schema.error_handler.with_error_handling(context) do
-                      variable_type.coerce_input(provided_value, ctx)
-                    end
-                  end
+                  memo[variable_name] = provided_value
                 elsif default_value != nil
-                  memo[variable_name] = if ctx.interpreter?
-                    if default_value.is_a?(Language::Nodes::NullValue)
-                      nil
-                    else
-                      default_value
-                    end
+                  memo[variable_name] = if default_value.is_a?(Language::Nodes::NullValue)
+                    nil
                   else
-                    # Add the variable if it wasn't provided but it has a default value (including `null`)
-                    GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                    default_value
                   end
                 end
               end