graphql 1.9.21 → 2.0.16

data/lib/graphql/query/context.rb

@@ -1,55 +1,14 @@
 # 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.
     # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
     class Context
       module SharedMethods
-        # @return [Object] The target for field resolution
-        attr_accessor :object
-
-        # @return [Hash, Array, String, Integer, Float, Boolean, nil] The resolved value for this field
-        attr_reader :value
-
-        # @return [Boolean] were any fields of this selection skipped?
-        attr_reader :skipped
-        alias :skipped? :skipped
-
-        # @api private
-        attr_writer :skipped
-
         # Return this value to tell the runtime
         # to exclude this field from the response altogether
         def skip
-          GraphQL::Execution::Execute::SKIP
-        end
-
-        # @return [Boolean] True if this selection has been nullified by a null child
-        def invalid_null?
-          @invalid_null
-        end
-
-        # Remove this child from the result value
-        # (used for null propagation and skip)
-        # @api private
-        def delete(child_ctx)
-          @value.delete(child_ctx.key)
-        end
-
-        # Create a child context to use for `key`
-        # @param key [String, Integer] The key in the response (name or index)
-        # @param irep_node [InternalRepresentation::Node] The node being evaluated
-        # @api private
-        def spawn_child(key:, irep_node:, object:)
-          FieldResolutionContext.new(
-            @context,
-            key,
-            irep_node,
-            self,
-            object
-          )
+          GraphQL::Execution::SKIP
         end
 
         # Add error at query-level.
@@ -74,12 +33,6 @@ module GraphQL
         def execution_errors
           @execution_errors ||= ExecutionErrors.new(self)
         end
-
-        def lookahead
-          ast_nodes = irep_node.ast_nodes
-          field = irep_node.definition.metadata[:type_class] || raise("Lookahead is only compatible with class-based schemas")
-          Execution::Lookahead.new(query: query, ast_nodes: ast_nodes, field: field)
-        end
       end
 
       class ExecutionErrors
@@ -107,27 +60,6 @@ module GraphQL
       include SharedMethods
       extend Forwardable
 
-      attr_reader :execution_strategy
-      # `strategy` is required by GraphQL::Batch
-      alias_method :strategy, :execution_strategy
-
-      def execution_strategy=(new_strategy)
-        # GraphQL::Batch re-assigns this value but it was previously not used
-        # (ExecutionContext#strategy was used instead)
-        # now it _is_ used, but it breaks GraphQL::Batch tests
-        @execution_strategy ||= new_strategy
-      end
-
-      # @return [GraphQL::InternalRepresentation::Node] The internal representation for this query node
-      def irep_node
-        @irep_node ||= query.irep_selection
-      end
-
-      # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
-      def ast_node
-        @irep_node.ast_node
-      end
-
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
 
@@ -154,8 +86,101 @@ module GraphQL
         @errors = []
         @path = []
         @value = nil
-        @context = self # for SharedMethods
-        @scoped_context = {}
+        @context = self # for SharedMethods TODO delete sharedmethods
+        @scoped_context = ScopedContext.new(self)
+      end
+
+      class ScopedContext
+        def initialize(query_context)
+          @query_context = query_context
+          @scoped_contexts = {}
+          @no_path = [].freeze
+        end
+
+        def merged_context
+          merged_ctx = {}
+          each_present_path_ctx do |path_ctx|
+            merged_ctx = path_ctx.merge(merged_ctx)
+          end
+          merged_ctx
+        end
+
+        def merge!(hash)
+          ctx = @scoped_contexts
+          current_path.each do |path_part|
+            ctx = ctx[path_part] ||= { parent: ctx }
+          end
+          this_scoped_ctx = ctx[:scoped_context] ||= {}
+          this_scoped_ctx.merge!(hash)
+        end
+
+        def current_path
+          thread_info = Thread.current[:__graphql_runtime_info]
+          (thread_info && thread_info[:current_path]) || @no_path
+        end
+
+        def key?(key)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              return true
+            end
+          end
+          false
+        end
+
+        def [](key)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              return path_ctx[key]
+            end
+          end
+          nil
+        end
+
+        def dig(key, *other_keys)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              found_value = path_ctx[key]
+              if other_keys.any?
+                return found_value.dig(*other_keys)
+              else
+                return found_value
+              end
+            end
+          end
+          nil
+        end
+
+        private
+
+        # Start at the current location,
+        # but look up the tree for previously-assigned scoped values
+        def each_present_path_ctx
+          ctx = @scoped_contexts
+          current_path.each do |path_part|
+            if ctx.key?(path_part)
+              ctx = ctx[path_part]
+            else
+              break
+            end
+          end
+
+          while ctx
+            if (scoped_ctx = ctx[:scoped_context])
+              yield(scoped_ctx)
+            end
+            ctx = ctx[:parent]
+          end
+        end
+      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
@@ -165,24 +190,79 @@ module GraphQL
       attr_writer :value
 
       # @api private
-      attr_accessor :scoped_context
+      attr_reader :scoped_context
+
+      def []=(key, value)
+        @provided_values[key] = value
+      end
 
-      def_delegators :@provided_values, :[]=
-      def_delegators :to_h, :fetch, :dig
       def_delegators :@query, :trace, :interpreter?
 
+      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
       # @!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]
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        elsif @provided_values.key?(key)
+          @provided_values[key]
+        elsif RUNTIME_METADATA_KEYS.include?(key)
+          thread_info = Thread.current[:__graphql_runtime_info]
+          thread_info && thread_info[key]
+        else
+          # not found
+          nil
+        end
+      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 RUNTIME_METADATA_KEYS.include?(key)
+          (thread_info = Thread.current[:__graphql_runtime_info]) &&
+            thread_info[key]
+        elsif @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)
+        if RUNTIME_METADATA_KEYS.include?(key)
+          (thread_info = Thread.current[:__graphql_runtime_info]).key?(key) &&
+            thread_info.dig(key, *other_keys)
+        elsif @scoped_context.key?(key)
+          @scoped_context.dig(key, *other_keys)
+        else
+          @provided_values.dig(key, *other_keys)
+        end
       end
 
       def to_h
-        @provided_values.merge(@scoped_context)
+        if (current_scoped_context = @scoped_context.merged_context)
+          @provided_values.merge(current_scoped_context)
+        else
+          @provided_values
+        end
       end
+
       alias :to_hash :to_h
 
       def key?(key)
@@ -191,146 +271,40 @@ 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
       def namespace(ns)
-        @storage[ns]
+        if ns == :interpreter
+          self
+        else
+          @storage[ns]
+        end
       end
 
-      def inspect
-        "#<Query::Context ...>"
+      # @return [Boolean] true if this namespace was accessed before
+      def namespace?(ns)
+        @storage.key?(ns)
       end
 
-      # @api private
-      def received_null_child
-        @invalid_null = true
-        @value = nil
+      def inspect
+        "#<Query::Context ...>"
       end
 
       def scoped_merge!(hash)
-        @scoped_context = @scoped_context.merge(hash)
+        @scoped_context.merge!(hash)
       end
 
       def scoped_set!(key, value)
         scoped_merge!(key => value)
         nil
       end
-
-      class FieldResolutionContext
-        include SharedMethods
-        include Tracing::Traceable
-        extend Forwardable
-
-        attr_reader :irep_node, :field, :parent_type, :query, :schema, :parent, :key, :type
-        alias :selection :irep_node
-
-        def initialize(context, key, irep_node, parent, object)
-          @context = context
-          @key = key
-          @parent = parent
-          @object = object
-          @irep_node = irep_node
-          @field = irep_node.definition
-          @parent_type = irep_node.owner_type
-          @type = field.type
-          # This is needed constantly, so set it ahead of time:
-          @query = context.query
-          @schema = context.schema
-          @tracers = @query.tracers
-          # This hack flag is required by ConnectionResolve
-          @wrapped_connection = false
-          @wrapped_object = false
-        end
-
-        # @api private
-        attr_accessor :wrapped_connection, :wrapped_object
-
-        def path
-          @path ||= @parent.path.dup << @key
-        end
-
-        def_delegators :@context,
-          :[], :[]=, :key?, :fetch, :to_h, :namespace, :dig,
-          :spawn, :warden, :errors,
-          :execution_strategy, :strategy, :interpreter?
-
-        # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
-        def ast_node
-          @irep_node.ast_node
-        end
-
-        # Add error to current field resolution.
-        # @param error [GraphQL::ExecutionError] an execution error
-        # @return [void]
-        def add_error(error)
-          super
-          error.ast_node ||= irep_node.ast_node
-          error.path ||= path
-          nil
-        end
-
-        def inspect
-          "#<GraphQL Context @ #{irep_node.owner_type.name}.#{field.name}>"
-        end
-
-        # Set a new value for this field in the response.
-        # It may be updated after resolving a {Lazy}.
-        # If it is {Execute::PROPAGATE_NULL}, tell the owner to propagate null.
-        # If it's {Execute::Execution::SKIP}, remove this field result from its parent
-        # @param new_value [Any] The GraphQL-ready value
-        # @api private
-        def value=(new_value)
-          case new_value
-          when GraphQL::Execution::Execute::PROPAGATE_NULL, nil
-            @invalid_null = true
-            @value = nil
-            if @type.kind.non_null?
-              @parent.received_null_child
-            end
-          when GraphQL::Execution::Execute::SKIP
-            @parent.skipped = true
-            @parent.delete(self)
-          else
-            @value = new_value
-          end
-        end
-
-        protected
-
-        def received_null_child
-          case @value
-          when Hash
-            self.value = GraphQL::Execution::Execute::PROPAGATE_NULL
-          when Array
-            if list_of_non_null_items?(@type)
-              self.value = GraphQL::Execution::Execute::PROPAGATE_NULL
-            end
-          when nil
-            # TODO This is a hack
-            # It was already nulled out but it's getting reassigned
-          else
-            raise "Unexpected value for received_null_child (#{self.value.class}): #{value}"
-          end
-        end
-
-        private
-
-        def list_of_non_null_items?(type)
-          case type
-          when GraphQL::NonNullType
-            # Unwrap [T]!
-            list_of_non_null_items?(type.of_type)
-          when GraphQL::ListType
-            type.of_type.is_a?(GraphQL::NonNullType)
-          else
-            raise "Unexpected list_of_non_null_items check: #{type}"
-          end
-        end
-      end
     end
   end
 end

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?
+        return if inner_result.nil? || 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/null_context.rb

@@ -4,16 +4,25 @@ 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
+      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 +32,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/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