graphql 1.9.17 → 2.0.20

data/lib/graphql/query/validation_pipeline.rb

@@ -16,10 +16,8 @@ module GraphQL
     class ValidationPipeline
       attr_reader :max_depth, :max_complexity
 
-      def initialize(query:, validate:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
+      def initialize(query:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
         @validation_errors = []
-        @internal_representation = nil
-        @validate = validate
         @parse_error = parse_error
         @operation_name_error = operation_name_error
         @query = query
@@ -36,23 +34,21 @@ module GraphQL
         @valid
       end
 
-      # @return [Array<GraphQL::StaticValidation::Error >] 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
       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.
@@ -63,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.
@@ -72,9 +68,8 @@ 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: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
-          @internal_representation = validation_result[:irep]
 
           if @validation_errors.empty?
             @validation_errors.concat(@query.variables.errors)
@@ -90,6 +85,9 @@ module GraphQL
         end
 
         @valid = @validation_errors.empty?
+      rescue SystemStackError => err
+        @valid = false
+        @schema.query_stack_error(@query, err)
       end
 
       # If there are max_* values, add them,
@@ -97,35 +95,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::AST::MaxQueryDepth
+          end
+          if max_complexity
+            qa << GraphQL::Analysis::AST::MaxQueryComplexity
           end
-
           qa
         else
           qa

data/lib/graphql/query/variable_validation_error.rb

@@ -4,11 +4,11 @@ module GraphQL
     class VariableValidationError < GraphQL::ExecutionError
       attr_accessor :value, :validation_result
 
-      def initialize(variable_ast, type, value, validation_result)
+      def initialize(variable_ast, type, value, validation_result, msg: nil)
         @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(", ")}"
@@ -23,7 +23,7 @@ module GraphQL
         # 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
+          if oldValue.respond_to?(:merge)
             oldValue.merge(newValue)
           else
             newValue

data/lib/graphql/query/variables.rb

@@ -14,14 +14,18 @@ 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
+            add_max_errors_reached_message
+            break
+          end
           # 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,27 +33,27 @@ module GraphQL
             default_value = ast_variable.default_value
             provided_value = @provided_variables[variable_name]
             value_was_provided =  @provided_variables.key?(variable_name)
-
+            max_errors = schema.validate_max_errors - @errors.count if schema.validate_max_errors
             begin
-              validation_result = variable_type.validate_input(provided_value, ctx)
+              validation_result = variable_type.validate_input(provided_value, ctx, max_errors: max_errors)
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = schema.error_handler.with_error_handling(context) do
-                    variable_type.coerce_input(provided_value, ctx)
-                  end
+                  memo[variable_name] = provided_value
                 elsif default_value != nil
-                  # 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)
+                  memo[variable_name] = if default_value.is_a?(Language::Nodes::NullValue)
+                    nil
+                  else
+                    default_value
+                  end
                 end
               end
-            rescue GraphQL::CoercionError, GraphQL::ExecutionError => ex
+            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)
+              validation_result = GraphQL::Query::InputValidationResult.from_problem(ex.message)
             end
 
             if !validation_result.valid?
@@ -60,6 +64,29 @@ module GraphQL
       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    
+
+      def add_max_errors_reached_message
+        message = "Too many errors processing variables, max validation error limit reached. Execution aborted"
+        validation_result = GraphQL::Query::InputValidationResult.from_problem(message)
+        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message) 
+      end
     end
   end
 end

data/lib/graphql/query.rb

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
-require "graphql/query/arguments"
-require "graphql/query/arguments_cache"
 require "graphql/query/context"
-require "graphql/query/executor"
-require "graphql/query/literal_input"
+require "graphql/query/fingerprint"
 require "graphql/query/null_context"
 require "graphql/query/result"
-require "graphql/query/serial_execution"
 require "graphql/query/variables"
 require "graphql/query/input_validation_result"
 require "graphql/query/variable_validation_error"
@@ -38,7 +34,16 @@ module GraphQL
     attr_accessor :operation_name
 
     # @return [Boolean] if false, static validation is skipped (execution behavior for invalid queries is undefined)
-    attr_accessor :validate
+    attr_reader :validate
+
+    # @param new_validate [Boolean] if false, static validation is skipped. This can't be reasssigned after validation.
+    def validate=(new_validate)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#validate= after validation has run, remove this assignment."
+      else
+        @validate = new_validate
+      end
+    end
 
     attr_writer :query_string
 
@@ -78,29 +83,37 @@ 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: 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)
+    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 ||= {}
       @schema = schema
       @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, []) : [])
+      context_tracers = (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + context_tracers
+
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
+        context_tracers += [GraphQL::Backtrace::Tracer]
         @tracers << GraphQL::Backtrace::Tracer
       end
 
+      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::LegacyTrace)
+        raise ArgumentError, "context[:tracers] and context[:backtrace] are not supported without `tracer_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
+      end
+
+
       @analysis_errors = []
       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
@@ -110,6 +123,10 @@ module GraphQL
         raise ArgumentError, "Query should only be provided a query string or a document, not both."
       end
 
+      if @query_string && !@query_string.is_a?(String)
+        raise ArgumentError, "Query string argument should be a String, got #{@query_string.class.name} instead."
+      end
+
       # A two-layer cache of type resolution:
       # { abstract_type => { value => resolved_type } }
       @resolved_types_cache = Hash.new do |h1, k1|
@@ -118,8 +135,6 @@ module GraphQL
         end
       end
 
-      @arguments_cache = ArgumentsCache.build(self)
-
       # Trying to execute a document
       # with no operations returns an empty hash
       @ast_variables = []
@@ -134,7 +149,6 @@ module GraphQL
       @executed = false
 
       # TODO add a general way to define schema-level filters
-      # TODO also add this to schema dumps
       if @schema.respond_to?(:visible?)
         merge_filters(only: @schema.method(:visible?))
       end
@@ -145,7 +159,16 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def_delegators :@schema, :interpreter?
+    def interpreter?
+      true
+    end
+
+    attr_accessor :multiplex
+
+    # @return [GraphQL::Tracing::Trace]
+    def current_trace
+      @current_trace ||= multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self)
+    end
 
     def subscription_update?
       @subscription_topic && subscription?
@@ -157,7 +180,6 @@ module GraphQL
       @lookahead ||= begin
         ast_node = selected_operation
         root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
-        root_type = root_type.metadata[: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
@@ -187,9 +209,7 @@ 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::Interpreter.run_all(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end
@@ -227,28 +247,60 @@ module GraphQL
       end
     end
 
-    def irep_selection
-      @selection ||= begin
-        if selected_operation && internal_representation
-          internal_representation.operation_definitions[selected_operation.name]
-        else
-          nil
-        end
-      end
+    # Node-level cache for calculating arguments. Used during execution and query analysis.
+    # @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)
+      arguments_cache.fetch(ast_node, definition, parent_object)
     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]
+    def arguments_cache
+      @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
+    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 {
+        schema.sanitized_printer.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,
+    def_delegators :validation_pipeline, :validation_errors,
                    :analyzers, :ast_analyzers, :max_depth, :max_complexity
 
     attr_accessor :analysis_errors
@@ -301,10 +353,8 @@ module GraphQL
     end
 
     # @api private
-    def with_error_handling
-      schema.error_handler.with_error_handling(context) do
-        yield
-      end
+    def handle_or_reraise(err)
+      schema.handle_or_reraise(context, err)
     end
 
     private
@@ -321,12 +371,11 @@ 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
-          GraphQL.parse(query_string, tracer: self)
+          GraphQL.parse(query_string, trace: self.current_trace)
         end
       rescue GraphQL::ParseError => err
         parse_error = err
@@ -375,7 +424,6 @@ module GraphQL
 
       @validation_pipeline = GraphQL::Query::ValidationPipeline.new(
         query: self,
-        validate: @validate,
         parse_error: parse_error,
         operation_name_error: operation_name_error,
         max_depth: @max_depth,

data/lib/graphql/railtie.rb

@@ -1,108 +1,12 @@
 # frozen_string_literal: true
-
-
 module GraphQL
   class Railtie < Rails::Railtie
-    rake_tasks do
-      # Defer this so that you only need the `parser` gem when you _run_ the upgrader
-      def load_upgraders
-        require_relative './upgrader/member'
-        require_relative './upgrader/schema'
-      end
-
-      namespace :graphql do
-        task :upgrade, [:dir] do |t, args|
-          unless (dir = args[:dir])
-            fail 'You have to give me a directory where your GraphQL schema and types live. ' \
-             'For example: `bin/rake graphql:upgrade[app/graphql/**/*]`'
-          end
-
-          Dir[dir].each do |file|
-            # Members (types, interfaces, etc.)
-            if file =~ /.*_(type|interface|enum|union|)\.rb$/
-              Rake::Task["graphql:upgrade:member"].execute(Struct.new(:member_file).new(file))
-            end
-          end
-
-          puts "Upgrade complete! Note that this is a best-effort approach, and may very well contain some bugs."
-          puts "Don't forget to create the base objects. For example, you could run:"
-          puts "\tbin/rake graphql:upgrade:create_base_objects[app/graphql]"
-        end
-
-        namespace :upgrade do
-          task :create_base_objects, [:base_dir] do |t, args|
-            unless (base_dir = args[:base_dir])
-              fail 'You have to give me a directory where your GraphQL types live. ' \
-                   'For example: `bin/rake graphql:upgrade:create_base_objects[app/graphql]`'
-            end
-
-            destination_file = File.join(base_dir, "types", "base_scalar.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_input_object.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_enum.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_union.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseUnion < GraphQL::Schema::Union\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_interface.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_object.rb")
-            unless File.exists?(destination_file)
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseObject < GraphQL::Schema::Object\nend"
-              end
-            end
-          end
-
-          task :schema, [:schema_file] do |t, args|
-            schema_file = args.schema_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Schema.new File.read(schema_file)
-
-            puts "- Transforming schema #{schema_file}"
-            File.open(schema_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-
-          task :member, [:member_file] do |t, args|
-            member_file = args.member_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Member.new File.read(member_file)
-            next unless upgrader.upgradeable?
-
-            puts "- Transforming member #{member_file}"
-            File.open(member_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-        end
+    config.before_configuration do
+      # Bootsnap compile cache has similar expiration properties,
+      # so we assume that if the user has bootsnap setup it's ok
+      # to piggy back on it.
+      if ::Object.const_defined?("Bootsnap::CompileCache::ISeq") && Bootsnap::CompileCache::ISeq.cache_dir
+        Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
       end
     end
   end

data/lib/graphql/rake_task/validate.rb

@@ -7,12 +7,15 @@ module GraphQL
     desc "Get the checksum of a graphql-pro version and compare it to published versions on GitHub and graphql-ruby.org"
     task "graphql:pro:validate", [:gem_version] do |t, args|
       version = args[:gem_version]
+      if version.nil?
+        raise ArgumentError, "A specific version is required, eg `rake graphql:pro:validate[1.12.0]`"
+      end
       check = "\e[32m✓\e[0m"
       ex = "\e[31m✘\e[0m"
       puts "Validating graphql-pro v#{version}"
       puts "  - Checking for graphql-pro credentials..."
 
-      creds = `bundle config gems.graphql.pro`[/[a-z0-9]{11}:[a-z0-9]{11}/]
+      creds = `bundle config gems.graphql.pro --parseable`[/[a-z0-9]{11}:[a-z0-9]{11}/]
       if creds.nil?
         puts "    #{ex} failed, please set with `bundle config gems.graphql.pro $MY_CREDENTIALS`"
         exit(1)