graphql 1.9.17 → 2.0.21

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
 
@@ -143,9 +75,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:
@@ -154,8 +86,115 @@ 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
+        NO_PATH = GraphQL::EmptyObjects::EMPTY_ARRAY
+        NO_CONTEXT = GraphQL::EmptyObjects::EMPTY_HASH
+
+        def initialize(query_context)
+          @query_context = query_context
+          @scoped_contexts = nil
+          @all_keys = nil
+        end
+
+        def merged_context
+          if @scoped_contexts.nil?
+            NO_CONTEXT
+          else
+            merged_ctx = {}
+            each_present_path_ctx do |path_ctx|
+              merged_ctx = path_ctx.merge(merged_ctx)
+            end
+            merged_ctx
+          end
+        end
+
+        def merge!(hash)
+          @all_keys ||= Set.new
+          @all_keys.merge(hash.keys)
+          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 key?(key)
+          if @all_keys && @all_keys.include?(key)
+            each_present_path_ctx do |path_ctx|
+              if path_ctx.key?(key)
+                return true
+              end
+            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 current_path
+          @query_context.current_path || NO_PATH
+        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
+          if ctx.nil?
+            # no-op
+          else
+            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
+      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 +204,96 @@ 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)
+          if key == :current_path
+            current_path
+          else
+            (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+              (current_runtime_state.public_send(key))
+          end
+        else
+          # not found
+          nil
+        end
+      end
+
+      def current_path
+        current_runtime_state = Thread.current[:__graphql_runtime_info]
+        path = current_runtime_state &&
+          (result = current_runtime_state.current_result) &&
+          (result.path)
+        if path && (rn = current_runtime_state.current_result_name)
+          path = path.dup
+          path.push(rn)
+        end
+        path
+      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)
+          (runtime = Thread.current[:__graphql_runtime_info]) &&
+            (runtime.public_send(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)
+          (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+            (obj = current_runtime_state.public_send(key)) &&
+            obj.dig(*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,149 +302,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
-
-
-GraphQL::Schema::Context = GraphQL::Query::Context

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,18 +4,27 @@ 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,
+          GraphQL::Filter.new(silence_deprecation_warning: true),
           context: self,
           schema: @schema,
         )
@@ -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