graphql 1.8.0 → 1.12.12

data/lib/graphql/query/literal_input.rb

@@ -12,8 +12,8 @@ module GraphQL
         when Language::Nodes::VariableIdentifier
           variables[ast_node.name]
         else
-          case type
-          when GraphQL::ScalarType
+          case type.kind.name
+          when "SCALAR"
             # TODO smell
             # This gets used for plain values during subscriber.trigger
             if variables
@@ -21,7 +21,7 @@ module GraphQL
             else
               type.coerce_isolated_input(ast_node)
             end
-          when GraphQL::EnumType
+          when "ENUM"
             # TODO smell
             # This gets used for plain values sometimes
             v = ast_node.is_a?(GraphQL::Language::Nodes::Enum) ? ast_node.name : ast_node
@@ -30,18 +30,20 @@ module GraphQL
             else
               type.coerce_isolated_input(v)
             end
-          when GraphQL::NonNullType
+          when "NON_NULL"
             LiteralInput.coerce(type.of_type, ast_node, variables)
-          when GraphQL::ListType
+          when "LIST"
             if ast_node.is_a?(Array)
               ast_node.map { |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
             else
               [LiteralInput.coerce(type.of_type, ast_node, variables)]
             end
-          when GraphQL::InputObjectType
+          when "INPUT_OBJECT"
             # TODO smell: handling AST vs handling plain Ruby
             next_args = ast_node.is_a?(Hash) ? ast_node : ast_node.arguments
             from_arguments(next_args, type, variables)
+          else
+            raise "Invariant: unexpected type to coerce to: #{type}"
           end
         end
       end
@@ -78,7 +80,10 @@ module GraphQL
             if (!value_is_a_variable || (value_is_a_variable && variables.key?(arg_value.name)))
 
               value = coerce(arg_defn.type, arg_value, variables)
-              value = arg_defn.prepare(value, context)
+              # Legacy `prepare` application
+              if arg_defn.is_a?(GraphQL::Argument)
+                value = arg_defn.prepare(value, context)
+              end
 
               if value.is_a?(GraphQL::ExecutionError)
                 value.ast_node = ast_arg
@@ -98,7 +103,9 @@ module GraphQL
             defaults_used << arg_name
             # `context` isn't present when pre-calculating defaults
             if context
-              value = arg_defn.prepare(value, context)
+              if arg_defn.is_a?(GraphQL::Argument)
+                value = arg_defn.prepare(value, context)
+              end
               if value.is_a?(GraphQL::ExecutionError)
                 value.ast_node = ast_arg
                 raise value
@@ -108,7 +115,21 @@ module GraphQL
           end
         end
 
-        argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
+        if argument_owner.is_a?(Class) || argument_owner.is_a?(GraphQL::Schema::Field)
+          # A Schema::InputObject, Schema::GraphQL::Field, Schema::Directive, logic from Query::Arguments#to_kwargs
+          ruby_kwargs = {}
+          values_hash.each do |key, value|
+            ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = value
+          end
+          if argument_owner.is_a?(Class) && argument_owner < GraphQL::Schema::InputObject
+            argument_owner.new(ruby_kwargs: ruby_kwargs, context: context, defaults_used: defaults_used)
+          else
+            ruby_kwargs
+          end
+        else
+          result = argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
+          result.prepare
+        end
       end
     end
   end

data/lib/graphql/query/null_context.rb

@@ -9,10 +9,17 @@ module GraphQL
         def visible_type?(t); true; end
       end
 
-      attr_reader :schema, :query, :warden
+      class NullQuery
+        def with_error_handling
+          yield
+        end
+      end
+
+      attr_reader :schema, :query, :warden, :dataloader
 
       def initialize
-        @query = nil
+        @query = NullQuery.new
+        @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = GraphQL::Schema.new
         @warden = NullWarden.new(
           GraphQL::Filter.new,
@@ -21,14 +28,22 @@ module GraphQL
         )
       end
 
+      def [](key); end
+
+      def interpreter?
+        false
+      end
+
       class << self
         extend Forwardable
 
+        def [](key); end
+
         def instance
           @instance = self.new
         end
 
-        def_delegators :instance, :query, :schema, :warden
+        def_delegators :instance, :query, :schema, :warden, :interpreter?, :dataloader
       end
     end
   end

data/lib/graphql/query/result.rb

@@ -37,7 +37,7 @@ module GraphQL
       end
 
       def inspect
-        "#<GraphQL::Query::Result @query=... @to_h=#{@to_h} >"
+        "#<GraphQL::Query::Result @query=... @to_h=#{@to_h}>"
       end
 
       # A result is equal to another object when:

data/lib/graphql/query/serial_execution.rb

@@ -16,6 +16,7 @@ module GraphQL
       # @param query_object [GraphQL::Query] the query object for this execution
       # @return [Hash] a spec-compliant GraphQL result, as a hash
       def execute(ast_operation, root_type, query_object)
+        GraphQL::Deprecation.warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
         operation_resolution.resolve(
           query_object.irep_selection,
           root_type,

data/lib/graphql/query/validation_pipeline.rb

@@ -14,9 +14,10 @@ module GraphQL
     #
     # @api private
     class ValidationPipeline
+      attr_reader :max_depth, :max_complexity
+
       def initialize(query:, validate:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
         @validation_errors = []
-        @analysis_errors = []
         @internal_representation = nil
         @validate = validate
         @parse_error = parse_error
@@ -35,13 +36,7 @@ module GraphQL
         @valid
       end
 
-      # @return [Array<GraphQL::AnalysisError>] Errors for this particular query run (eg, exceeds max complexity)
-      def analysis_errors
-        ensure_has_validated
-        @analysis_errors
-      end
-
-      # @return [Array<GraphQL::StaticValidation::Message>] Static validation errors for the query string
+      # @return [Array<GraphQL::StaticValidation::Error, GraphQL::Query::VariableValidationError>] Static validation errors for the query string
       def validation_errors
         ensure_has_validated
         @validation_errors
@@ -77,42 +72,66 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @validate)
+          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout)
           @validation_errors.concat(validation_result[:errors])
           @internal_representation = validation_result[:irep]
 
-          if @validation_errors.none?
+          if @validation_errors.empty?
             @validation_errors.concat(@query.variables.errors)
           end
 
-          if @validation_errors.none?
-            @query_analyzers = build_analyzers(@schema, @max_depth, @max_complexity)
-            # if query_analyzers.any?
-            #   analysis_results = GraphQL::Analysis.analyze_query(@query, query_analyzers)
-            #   @analysis_errors = analysis_results
-            #     .flatten # accept n-dimensional array
-            #     .select { |r| r.is_a?(GraphQL::AnalysisError) }
-            # end
+          if @validation_errors.empty?
+            @query_analyzers = build_analyzers(
+              @schema,
+              @max_depth,
+              @max_complexity
+            )
           end
         end
 
-        @valid = @validation_errors.none? && @analysis_errors.none?
+        @valid = @validation_errors.empty?
+      rescue SystemStackError => err
+        @valid = false
+        @schema.query_stack_error(@query, err)
       end
 
       # If there are max_* values, add them,
       # otherwise reuse the schema's list of analyzers.
       def build_analyzers(schema, max_depth, max_complexity)
-        if max_depth || max_complexity
-          qa = schema.query_analyzers.dup
-          if max_depth
-            qa << GraphQL::Analysis::MaxQueryDepth.new(max_depth)
+        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
-          if max_complexity
-            qa << GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)
+        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
           end
+
           qa
         else
-          schema.query_analyzers
+          qa
         end
       end
     end

data/lib/graphql/query/variable_validation_error.rb

@@ -8,13 +8,36 @@ module GraphQL
         @value = value
         @validation_result = validation_result
 
-        msg = "Variable #{variable_ast.name} of type #{type} was provided invalid value"
+        msg = "Variable $#{variable_ast.name} of type #{type.to_type_signature} was provided invalid value"
+
+        if problem_fields.any?
+          msg += " for #{problem_fields.join(", ")}"
+        end
+
         super(msg)
         self.ast_node = variable_ast
       end
 
       def to_h
-        super.merge({ "value" => value, "problems" => validation_result.problems })
+        # It is possible there are other extension items in this error, so handle
+        # a one level deep merge explicitly. However beyond that only show the
+        # latest value and problems.
+        super.merge({ "extensions" => { "value" => value, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
+          if oldValue.respond_to?(:merge)
+            oldValue.merge(newValue)
+          else
+            newValue
+          end
+        end
+      end
+
+      private
+
+      def problem_fields
+        @problem_fields ||= @validation_result
+          .problems
+          .reject { |problem| problem["path"].empty? }
+          .map { |problem| "#{problem['path'].join('.')} (#{problem['explanation']})" }
       end
     end
   end

data/lib/graphql/query/variables.rb

@@ -14,14 +14,14 @@ module GraphQL
         schema = ctx.schema
         @context = ctx
 
-        @provided_variables = deep_stringify(provided_variables)
+        @provided_variables = GraphQL::Argument.deep_stringify(provided_variables)
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
           # Find the right value for this variable:
           # - First, use the value provided at runtime
           # - 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)
+          variable_type = schema.type_from_ast(ast_variable.type, context: ctx)
           if variable_type.nil?
             # Pass -- it will get handled by a validator
           else
@@ -29,40 +29,46 @@ module GraphQL
             default_value = ast_variable.default_value
             provided_value = @provided_variables[variable_name]
             value_was_provided =  @provided_variables.key?(variable_name)
+            begin
+              validation_result = variable_type.validate_input(provided_value, ctx)
+              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
+                elsif default_value != nil
+                  memo[variable_name] = if ctx.interpreter?
+                    default_value
+                  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)
+                  end
+                end
+              end
+            rescue GraphQL::ExecutionError => ex
+              # TODO: This should really include the path to the problematic node in the variable value
+              # like InputValidationResults generated by validate_non_null_input but unfortunately we don't
+              # have this information available in the coerce_input call chain. Note this path is the path
+              # that appears under errors.extensions.problems.path and NOT the result path under errors.path.
+              validation_result = GraphQL::Query::InputValidationResult.new
+              validation_result.add_problem(ex.message)
+            end
 
-            validation_result = variable_type.validate_input(provided_value, ctx)
             if !validation_result.valid?
-              # This finds variables that were required but not provided
               @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
-            elsif value_was_provided
-              # Add the variable if a value was provided
-              memo[variable_name] = variable_type.coerce_input(provided_value, ctx)
-            elsif default_value
-              # Add the variable if it wasn't provided but it has a default value (including `null`)
-              memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
             end
           end
         end
       end
 
       def_delegators :@storage, :length, :key?, :[], :fetch, :to_h
-
-      private
-
-      def deep_stringify(val)
-        case val
-        when Array
-          val.map { |v| deep_stringify(v) }
-        when Hash
-          new_val = {}
-          val.each do |k, v|
-            new_val[k.to_s] = deep_stringify(v)
-          end
-          new_val
-        else
-          val
-        end
-      end
     end
   end
 end

data/lib/graphql/query.rb

@@ -3,6 +3,7 @@ require "graphql/query/arguments"
 require "graphql/query/arguments_cache"
 require "graphql/query/context"
 require "graphql/query/executor"
+require "graphql/query/fingerprint"
 require "graphql/query/literal_input"
 require "graphql/query/null_context"
 require "graphql/query/result"
@@ -29,7 +30,7 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :context, :warden, :provided_variables
+    attr_reader :schema, :context, :provided_variables
 
     # The value for root types
     attr_accessor :root_value
@@ -40,11 +41,16 @@ module GraphQL
     # @return [Boolean] if false, static validation is skipped (execution behavior for invalid queries is undefined)
     attr_accessor :validate
 
-    attr_accessor :query_string
+    attr_writer :query_string
 
     # @return [GraphQL::Language::Nodes::Document]
     def document
-      with_prepared_ast { @document }
+      # It's ok if this hasn't been assigned yet
+      if @query_string || @document
+        with_prepared_ast { @document }
+      else
+        nil
+      end
     end
 
     def inspect
@@ -60,9 +66,6 @@ module GraphQL
     # @return [String, nil] the triggered event, if this query is a subscription update
     attr_reader :subscription_topic
 
-    # @return [String, nil]
-    attr_reader :operation_name
-
     attr_reader :tracers
 
     # Prepare query `query_string` on `schema`
@@ -76,17 +79,25 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: {}, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
+      # Even if `variables: nil` is passed, use an empty hash for simpler logic
+      variables ||= {}
+
+      # Use the `.graphql_definition` here which will return legacy types instead of classes
+      if schema.is_a?(Class) && !schema.interpreter?
+        schema = schema.graphql_definition
+      end
       @schema = schema
+      @interpreter = @schema.interpreter?
       @filter = schema.default_filter.merge(except: except, only: only)
       @context = schema.context_class.new(query: self, object: root_value, values: context)
+      @warden = warden
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
       @operations = nil
       @validate = validate
-      # TODO: remove support for global tracers
-      @tracers = schema.tracers + GraphQL::Tracing.tracers + (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
         @tracers << GraphQL::Backtrace::Tracer
@@ -96,7 +107,7 @@ module GraphQL
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
       else
-        @provided_variables = variables
+        @provided_variables = variables || {}
       end
 
       @query_string = query_string || query
@@ -114,8 +125,6 @@ module GraphQL
         end
       end
 
-      @arguments_cache = ArgumentsCache.build(self)
-
       # Trying to execute a document
       # with no operations returns an empty hash
       @ast_variables = []
@@ -123,17 +132,44 @@ module GraphQL
       @operation_name = operation_name
       @prepared_ast = false
       @validation_pipeline = nil
-      @max_depth = max_depth || schema.max_depth
-      @max_complexity = max_complexity || schema.max_complexity
+      @max_depth = max_depth
+      @max_complexity = max_complexity
 
       @result_values = nil
       @executed = false
+
+      # TODO add a general way to define schema-level filters
+      if @schema.respond_to?(:visible?)
+        merge_filters(only: @schema.method(:visible?))
+      end
     end
 
+    # If a document was provided to `GraphQL::Schema#execute` instead of the raw query string, we will need to get it from the document
+    def query_string
+      @query_string ||= (document ? document.to_query_string : nil)
+    end
+
+    def interpreter?
+      @interpreter
+    end
+
+    attr_accessor :multiplex
+
     def subscription_update?
       @subscription_topic && subscription?
     end
 
+    # A lookahead for the root selections of this query
+    # @return [GraphQL::Execution::Lookahead]
+    def lookahead
+      @lookahead ||= begin
+        ast_node = selected_operation
+        root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
+        root_type = root_type.type_class || raise("Invariant: `lookahead` only works with class-based types")
+        GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
+      end
+    end
+
     # @api private
     def result_values=(result_hash)
       if @executed
@@ -159,13 +195,15 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self], context: @context)
-        }
+        Execution::Multiplex.run_queries(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end
 
+    def executed?
+      @executed
+    end
+
     def static_errors
       validation_errors + analysis_errors + context.errors
     end
@@ -206,26 +244,72 @@ module GraphQL
     end
 
     # Node-level cache for calculating arguments. Used during execution and query analysis.
-    # @api private
-    # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
-    def arguments_for(irep_or_ast_node, definition)
-      @arguments_cache[irep_or_ast_node][definition]
+    # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
+    # @param definition [GraphQL::Schema::Field]
+    # @param parent_object [GraphQL::Schema::Object]
+    # @return Hash{Symbol => Object}
+    def arguments_for(ast_node, definition, parent_object: nil)
+      if interpreter?
+        arguments_cache.fetch(ast_node, definition, parent_object)
+      else
+        arguments_cache[ast_node][definition]
+      end
     end
 
-    # @return [GraphQL::Language::Nodes::OperationDefinition, nil]
-    def selected_operation
-      with_prepared_ast { @selected_operation }
+    def arguments_cache
+      if interpreter?
+        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
+      else
+        @arguments_cache ||= ArgumentsCache.build(self)
+      end
+    end
+
+    # A version of the given query string, with:
+    # - Variables inlined to the query
+    # - Strings replaced with `<REDACTED>`
+    # @return [String, nil] Returns nil if the query is invalid.
+    def sanitized_query_string(inline_variables: true)
+      with_prepared_ast {
+        GraphQL::Language::SanitizedPrinter.new(self, inline_variables: inline_variables).sanitized_query_string
+      }
+    end
+
+    # This contains a few components:
+    #
+    # - The selected operation name (or `anonymous`)
+    # - The fingerprint of the query string
+    # - The number of given variables (for readability)
+    # - The fingerprint of the given variables
+    #
+    # This fingerprint can be used to track runs of the same operation-variables combination over time.
+    #
+    # @see operation_fingerprint
+    # @see variables_fingerprint
+    # @return [String] An opaque hash identifying this operation-variables combination
+    def fingerprint
+      @fingerprint ||= "#{operation_fingerprint}/#{variables_fingerprint}"
+    end
+
+    # @return [String] An opaque hash for identifying this query's given query string and selected operation
+    def operation_fingerprint
+      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string)}"
+    end
+
+    # @return [String] An opaque hash for identifying this query's given a variable values (not including defaults)
+    def variables_fingerprint
+      @variables_fingerprint ||= "#{provided_variables.size}/#{Fingerprint.generate(provided_variables.to_json)}"
     end
 
     def validation_pipeline
       with_prepared_ast { @validation_pipeline }
     end
 
-    def_delegators :validation_pipeline, :validation_errors, :internal_representation, :analyzers
+    def_delegators :validation_pipeline, :validation_errors, :internal_representation,
+                   :analyzers, :ast_analyzers, :max_depth, :max_complexity
 
     attr_accessor :analysis_errors
     def valid?
-      validation_pipeline.valid? && analysis_errors.none?
+      validation_pipeline.valid? && analysis_errors.empty?
     end
 
     def warden
@@ -272,6 +356,13 @@ module GraphQL
       with_prepared_ast { @subscription }
     end
 
+    # @api private
+    def with_error_handling
+      schema.error_handler.with_error_handling(context) do
+        yield
+      end
+    end
+
     private
 
     def find_operation(operations, operation_name)
@@ -286,8 +377,7 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden = GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
-
+      @warden ||= GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string
@@ -344,7 +434,7 @@ module GraphQL
         parse_error: parse_error,
         operation_name_error: operation_name_error,
         max_depth: @max_depth,
-        max_complexity: @max_complexity || schema.max_complexity,
+        max_complexity: @max_complexity
       )
     end