graphql 1.9.5 → 1.13.19

data/lib/graphql/query/arguments.rb

@@ -9,26 +9,28 @@ 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|
-            expose_as = -arg_definition.expose_as.to_s
-            expose_as_underscored = -GraphQL::Schema::Member::BuildType.underscore(expose_as)
-            method_names = [expose_as, expose_as_underscored].uniq
-            method_names.each do |method_name|
-              # Don't define a helper method if it would override something.
-              if method_defined?(method_name)
-                warn(
-                  "Unable to define a helper for argument with name '#{method_name}' "\
-                  "as this is a reserved name. If you're using an argument such as "\
-                  "`argument #{method_name}`, consider renaming this argument.`"
-                )
-              else
-                define_method(method_name) do
-                  # Always use `expose_as` here, since #[] doesn't accept underscored names
-                  self[expose_as]
+            if arg_definition.method_access?
+              expose_as = arg_definition.expose_as.to_s.freeze
+              expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as).freeze
+              method_names = [expose_as, expose_as_underscored].uniq
+              method_names.each do |method_name|
+                # Don't define a helper method if it would override something.
+                if method_defined?(method_name)
+                  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."
+                  )
+                else
+                  define_method(method_name) do
+                    # Always use `expose_as` here, since #[] doesn't accept underscored names
+                    self[expose_as]
+                  end
                 end
               end
             end
@@ -84,7 +86,12 @@ 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
+      end
 
       # Access each key, value and type for the arguments in this set.
       # @yield [argument_value] The {ArgumentValue} for each argument
@@ -96,7 +103,7 @@ module GraphQL
       end
 
       class << self
-        attr_accessor :argument_definitions
+        attr_accessor :argument_definitions, :argument_owner
       end
 
       NoArguments = Class.new(self) do
@@ -117,6 +124,8 @@ module GraphQL
         ruby_kwargs
       end
 
+      alias :to_hash :to_kwargs
+
       private
 
       class ArgumentValue
@@ -149,7 +158,8 @@ module GraphQL
             wrap_value(value, arg_defn_type.of_type, context)
           when GraphQL::InputObjectType
             if value.is_a?(Hash)
-              arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
+              result = arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
+              result.prepare
             else
               value
             end

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
 
@@ -143,9 +141,9 @@ module GraphQL
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
-      def initialize(query:, values: , object:)
+      def initialize(query:, schema: query.schema, values:, object:)
         @query = query
-        @schema = query.schema
+        @schema = schema
         @provided_values = values || {}
         @object = object
         # Namespaced storage, where user-provided values are in `nil` namespace:
@@ -155,6 +153,16 @@ module GraphQL
         @path = []
         @value = nil
         @context = self # for SharedMethods
+        @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
@@ -163,21 +171,69 @@ module GraphQL
       # @api private
       attr_writer :value
 
-      def_delegators :@provided_values, :[], :[]=, :to_h, :to_hash, :key?, :fetch, :dig
-      def_delegators :@query, :trace, :interpreter?
+      # @api private
+      attr_accessor :scoped_context
+
+      def []=(key, value)
+        @provided_values[key] = value
+      end
 
-      # @!method [](key)
-      #   Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
+      # Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def [](key)
+        return @scoped_context[key] if @scoped_context.key?(key)
+        @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
+      alias :to_hash :to_h
+
+      def key?(key)
+        @scoped_context.key?(key) || @provided_values.key?(key)
+      end
 
       # @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
@@ -185,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
@@ -195,6 +256,15 @@ module GraphQL
         @value = nil
       end
 
+      def scoped_merge!(hash)
+        @scoped_context = @scoped_context.merge(hash)
+      end
+
+      def scoped_set!(key, value)
+        scoped_merge!(key => value)
+        nil
+      end
+
       class FieldResolutionContext
         include SharedMethods
         include Tracing::Traceable
@@ -268,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
@@ -309,6 +379,3 @@ module GraphQL
     end
   end
 end
-
-
-GraphQL::Schema::Context = GraphQL::Query::Context

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,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

@@ -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,
@@ -21,14 +33,22 @@ module GraphQL
         )
       end
 
+      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