graphql 1.9.18 → 1.13.24

data/lib/graphql/query/arguments.rb

@@ -9,8 +9,9 @@ module GraphQL
       include GraphQL::Dig
 
       def self.construct_arguments_class(argument_owner)
-        argument_definitions = argument_owner.arguments
+        argument_definitions = argument_owner.arguments # rubocop:disable Development/ContextIsPassedCop -- legacy-related
         argument_owner.arguments_class = Class.new(self) do
+          self.argument_owner = argument_owner
           self.argument_definitions = argument_definitions
 
           argument_definitions.each do |_arg_name, arg_definition|
@@ -21,7 +22,7 @@ module GraphQL
               method_names.each do |method_name|
                 # Don't define a helper method if it would override something.
                 if method_defined?(method_name)
-                  warn(
+                  GraphQL::Deprecation.warn(
                     "Unable to define a helper for argument with name '#{method_name}' "\
                     "as this is a reserved name. Add `method_access: false` to stop this warning."
                   )
@@ -85,7 +86,8 @@ module GraphQL
         end
       end
 
-      def_delegators :to_h, :keys, :values, :each, :any?
+      def_delegators :to_h, :keys, :values, :each
+      def_delegators :@argument_values, :any?
 
       def prepare
         self
@@ -101,7 +103,7 @@ module GraphQL
       end
 
       class << self
-        attr_accessor :argument_definitions
+        attr_accessor :argument_definitions, :argument_owner
       end
 
       NoArguments = Class.new(self) do

data/lib/graphql/query/arguments_cache.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../query.rb
 module GraphQL
   class Query
     module ArgumentsCache
@@ -8,7 +7,7 @@ module GraphQL
         Hash.new do |h1, irep_or_ast_node|
           h1[irep_or_ast_node] = Hash.new do |h2, definition|
             ast_node = irep_or_ast_node.is_a?(GraphQL::InternalRepresentation::Node) ? irep_or_ast_node.ast_node : irep_or_ast_node
-            h2[definition] = if definition.arguments.empty?
+            h2[definition] = if definition.arguments(query.context).empty?
               GraphQL::Query::Arguments::NO_ARGS
             else
               GraphQL::Query::LiteralInput.from_arguments(

data/lib/graphql/query/context.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../execution/execute.rb
-# test_via: ../execution/lazy.rb
 module GraphQL
   class Query
     # Expose some query-specific info to field resolve functions.
@@ -34,7 +32,7 @@ module GraphQL
         # Remove this child from the result value
         # (used for null propagation and skip)
         # @api private
-        def delete(child_ctx)
+        def delete_child(child_ctx)
           @value.delete(child_ctx.key)
         end
 
@@ -158,6 +156,15 @@ module GraphQL
         @scoped_context = {}
       end
 
+      # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
+      def response_extensions
+        namespace(:__query_result_extensions__)
+      end
+
+      def dataloader
+        @dataloader ||= self[:dataloader] || (query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new)
+      end
+
       # @api private
       attr_writer :interpreter
 
@@ -167,8 +174,10 @@ module GraphQL
       # @api private
       attr_accessor :scoped_context
 
-      def_delegators :@provided_values, :[]=
-      def_delegators :to_h, :fetch, :dig
+      def []=(key, value)
+        @provided_values[key] = value
+      end
+
       def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
@@ -180,6 +189,34 @@ module GraphQL
         @provided_values[key]
       end
 
+      def delete(key)
+        if @scoped_context.key?(key)
+          @scoped_context.delete(key)
+        else
+          @provided_values.delete(key)
+        end
+      end
+
+      UNSPECIFIED_FETCH_DEFAULT = Object.new
+
+      def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        elsif @provided_values.key?(key)
+          @provided_values[key]
+        elsif default != UNSPECIFIED_FETCH_DEFAULT
+          default
+        elsif block_given?
+          yield(self, key)
+        else
+          raise KeyError.new(key: key)
+        end
+      end
+
+      def dig(key, *other_keys)
+        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+      end
+
       def to_h
         @provided_values.merge(@scoped_context)
       end
@@ -191,9 +228,12 @@ module GraphQL
 
       # @return [GraphQL::Schema::Warden]
       def warden
-        @warden ||= @query.warden
+        @warden ||= (@query && @query.warden)
       end
 
+      # @api private
+      attr_writer :warden
+
       # Get an isolated hash for `ns`. Doesn't affect user-provided storage.
       # @param ns [Object] a usage-specific namespace identifier
       # @return [Hash] namespaced storage
@@ -201,6 +241,11 @@ module GraphQL
         @storage[ns]
       end
 
+      # @return [Boolean] true if this namespace was accessed before
+      def namespace?(ns)
+        @storage.key?(ns)
+      end
+
       def inspect
         "#<Query::Context ...>"
       end
@@ -293,7 +338,7 @@ module GraphQL
             end
           when GraphQL::Execution::Execute::SKIP
             @parent.skipped = true
-            @parent.delete(self)
+            @parent.delete_child(self)
           else
             @value = new_value
           end

data/lib/graphql/query/executor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../query.rb
 module GraphQL
   class Query
     class Executor

data/lib/graphql/query/fingerprint.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'digest/sha2'
+
+module GraphQL
+  class Query
+    # @api private
+    # @see Query#query_fingerprint
+    # @see Query#variables_fingerprint
+    # @see Query#fingerprint
+    module Fingerprint
+      # Make an obfuscated hash of the given string (either a query string or variables JSON)
+      # @param string [String]
+      # @return [String] A normalized, opaque hash
+      def self.generate(input_str)
+        # Implemented to be:
+        # - Short (and uniform) length
+        # - Stable
+        # - Irreversibly Opaque (don't want to leak variable values)
+        # - URL-friendly
+        bytes = Digest::SHA256.digest(input_str)
+        Base64.urlsafe_encode64(bytes)
+      end
+    end
+  end
+end

data/lib/graphql/query/input_validation_result.rb

@@ -4,23 +4,49 @@ module GraphQL
     class InputValidationResult
       attr_accessor :problems
 
+      def self.from_problem(explanation, path = nil, extensions: nil, message: nil)
+        result = self.new
+        result.add_problem(explanation, path, extensions: extensions, message: message)
+        result
+      end
+
+      def initialize(valid: true, problems: nil)
+        @valid = valid
+        @problems = problems
+      end
+
       def valid?
-        @problems.nil?
+        @valid
       end
 
-      def add_problem(explanation, path = nil)
+      def add_problem(explanation, path = nil, extensions: nil, message: nil)
         @problems ||= []
-        @problems.push({ "path" => path || [], "explanation" => explanation })
+        @valid = false
+        problem = { "path" => path || [], "explanation" => explanation }
+        if extensions
+          problem["extensions"] = extensions
+        end
+        if message
+          problem["message"] = message
+        end
+        @problems.push(problem)
       end
 
       def merge_result!(path, inner_result)
         return if inner_result.valid?
 
-        inner_result.problems.each do |p|
-          item_path = [path, *p["path"]]
-          add_problem(p["explanation"], item_path)
+        if inner_result.problems
+          inner_result.problems.each do |p|
+            item_path = [path, *p["path"]]
+            add_problem(p["explanation"], item_path, message: p["message"], extensions: p["extensions"])
+          end
         end
+        # It could have been explicitly set on inner_result (if it had no problems)
+        @valid = false
       end
+
+      VALID = self.new
+      VALID.freeze
     end
   end
 end

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
@@ -60,7 +62,7 @@ module GraphQL
           raise ArgumentError, "Unexpected ast_arguments: #{ast_arguments}"
         end
 
-        argument_defns = argument_owner.arguments
+        argument_defns = argument_owner.arguments(context || GraphQL::Query::NullContext)
         argument_defns.each do |arg_name, arg_defn|
           ast_arg = indexed_arguments[arg_name]
           # First, check the argument in the AST.
@@ -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,8 +115,21 @@ module GraphQL
           end
         end
 
-        result = argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
-        result.prepare
+        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

@@ -4,16 +4,28 @@ module GraphQL
     # This object can be `ctx` in places where there is no query
     class NullContext
       class NullWarden < GraphQL::Schema::Warden
-        def visible?(t); true; end
-        def visible_field?(t); true; end
-        def visible_type?(t); true; end
+        def visible_field?(field, ctx); true; end
+        def visible_argument?(arg, ctx); true; end
+        def visible_type?(type, ctx); true; end
+        def visible_enum_value?(ev, ctx); true; end
+        def visible_type_membership?(tm, ctx); true; end
       end
 
-      attr_reader :schema, :query, :warden
+      class NullQuery
+        def with_error_handling
+          yield
+        end
+      end
+
+      class NullSchema < GraphQL::Schema
+      end
+
+      attr_reader :schema, :query, :warden, :dataloader
 
       def initialize
-        @query = nil
-        @schema = GraphQL::Schema.new
+        @query = NullQuery.new
+        @dataloader = GraphQL::Dataloader::NullDataloader.new
+        @schema = NullSchema
         @warden = NullWarden.new(
           GraphQL::Filter.new,
           context: self,
@@ -23,16 +35,20 @@ module GraphQL
 
       def [](key); end
 
+      def interpreter?
+        true
+      end
+
       class << self
         extend Forwardable
 
         def [](key); end
 
         def instance
-          @instance = self.new
+          @instance ||= self.new
         end
 
-        def_delegators :instance, :query, :schema, :warden
+        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader
       end
     end
   end

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -81,7 +81,7 @@ module GraphQL
         # is added to the "errors" key.
         def get_raw_value
           begin
-            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx])
+            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx]) # rubocop:disable Development/ContextIsPassedCop -- unrelated
           rescue GraphQL::ExecutionError => err
             err
           end

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

@@ -16,10 +16,9 @@ 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,7 +35,7 @@ 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
@@ -72,7 +71,7 @@ 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]
 
@@ -90,6 +89,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,

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

@@ -17,11 +17,15 @@ module GraphQL
         @provided_variables = GraphQL::Argument.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,40 @@ 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)
+                  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
-                  # 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 ctx.interpreter?
+                    if default_value.is_a?(Language::Nodes::NullValue)
+                      nil
+                    else
+                      default_value
+                    end
+                  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::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 +77,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