graphql 1.13.24 → 2.5.11

data/lib/graphql/query/context.rb

@@ -1,84 +1,10 @@
 # frozen_string_literal: true
+
 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(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
-          )
-        end
-
-        # Add error at query-level.
-        # @param error [GraphQL::ExecutionError] an execution error
-        # @return [void]
-        def add_error(error)
-          if !error.is_a?(ExecutionError)
-            raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
-          end
-          errors << error
-          nil
-        end
-
-        # @example Print the GraphQL backtrace during field resolution
-        #   puts ctx.backtrace
-        #
-        # @return [GraphQL::Backtrace] The backtrace for this point in query execution
-        def backtrace
-          GraphQL::Backtrace.new(self)
-        end
-
-        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
         def initialize(ctx)
@@ -102,30 +28,8 @@ module GraphQL
         alias :push :add
       end
 
-      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
 
@@ -135,27 +39,21 @@ module GraphQL
       # @return [GraphQL::Schema]
       attr_reader :schema
 
-      # @return [Array<String, Integer>] The current position in the result
-      attr_reader :path
-
       # 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:, schema: query.schema, values:, object:)
+      def initialize(query:, schema: query.schema, values:)
         @query = query
         @schema = schema
         @provided_values = values || {}
-        @object = object
         # Namespaced storage, where user-provided values are in `nil` namespace:
         @storage = Hash.new { |h, k| h[k] = {} }
         @storage[nil] = @provided_values
         @errors = []
-        @path = []
-        @value = nil
-        @context = self # for SharedMethods
-        @scoped_context = {}
+        @scoped_context = ScopedContext.new(self)
       end
 
+      # Modify this hash to return extensions to client.
       # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
       def response_extensions
         namespace(:__query_result_extensions__)
@@ -172,21 +70,85 @@ 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 :@query, :trace, :interpreter?
+      def_delegators :@query, :trace
+
+      def types
+        @types ||= @query.types
+      end
+
+      attr_writer :types
 
+      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path]).freeze
       # @!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 = Fiber[:__graphql_runtime_info]) &&
+              (query_runtime_state = current_runtime_state[@query]) &&
+              (query_runtime_state.public_send(key))
+          end
+        else
+          # not found
+          nil
+        end
+      end
+
+      # Return this value to tell the runtime
+      # to exclude this field from the response altogether
+      def skip
+        GraphQL::Execution::SKIP
+      end
+
+      # Add error at query-level.
+      # @param error [GraphQL::ExecutionError] an execution error
+      # @return [void]
+      def add_error(error)
+        if !error.is_a?(ExecutionError)
+          raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+        end
+        errors << error
+        nil
+      end
+
+      # @example Print the GraphQL backtrace during field resolution
+      #   puts ctx.backtrace
+      #
+      # @return [GraphQL::Backtrace] The backtrace for this point in query execution
+      def backtrace
+        GraphQL::Backtrace.new(self)
+      end
+
+      def execution_errors
+        @execution_errors ||= ExecutionErrors.new(self)
+      end
+
+      def current_path
+        current_runtime_state = Fiber[:__graphql_runtime_info]
+        query_runtime_state = current_runtime_state && current_runtime_state[@query]
+
+        path = query_runtime_state &&
+          (result = query_runtime_state.current_result) &&
+          (result.path)
+        if path && (rn = query_runtime_state.current_result_name)
+          path = path.dup
+          path.push(rn)
+        end
+        path
       end
 
       def delete(key)
@@ -200,8 +162,12 @@ module GraphQL
       UNSPECIFIED_FETCH_DEFAULT = Object.new
 
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
-        if @scoped_context.key?(key)
-          @scoped_context[key]
+        if RUNTIME_METADATA_KEYS.include?(key)
+          (runtime = Fiber[:__graphql_runtime_info]) &&
+            (query_runtime_state = runtime[@query]) &&
+            (query_runtime_state.public_send(key))
+        elsif @scoped_context.key?(key)
+          scoped_context[key]
         elsif @provided_values.key?(key)
           @provided_values[key]
         elsif default != UNSPECIFIED_FETCH_DEFAULT
@@ -214,12 +180,30 @@ module GraphQL
       end
 
       def dig(key, *other_keys)
-        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+        if RUNTIME_METADATA_KEYS.include?(key)
+          (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
+            (query_runtime_state = current_runtime_state[@query]) &&
+            (obj = query_runtime_state.public_send(key)) &&
+            if other_keys.empty?
+              obj
+            else
+              obj.dig(*other_keys)
+            end
+        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)
@@ -238,7 +222,11 @@ module GraphQL
       # @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
 
       # @return [Boolean] true if this namespace was accessed before
@@ -246,18 +234,16 @@ module GraphQL
         @storage.key?(ns)
       end
 
-      def inspect
-        "#<Query::Context ...>"
+      def logger
+        @query && @query.logger
       end
 
-      # @api private
-      def received_null_child
-        @invalid_null = true
-        @value = nil
+      def inspect
+        "#<#{self.class} ...>"
       end
 
       def scoped_merge!(hash)
-        @scoped_context = @scoped_context.merge(hash)
+        @scoped_context.merge!(hash)
       end
 
       def scoped_set!(key, value)
@@ -265,117 +251,37 @@ module GraphQL
         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
+      # Use this when you need to do a scoped set _inside_ a lazy-loaded (or batch-loaded)
+      # block of code.
+      #
+      # @example using scoped context inside a promise
+      #   scoped_ctx = context.scoped
+      #   SomeBatchLoader.load(...).then do |thing|
+      #     # use a scoped_ctx which was created _before_ dataloading:
+      #     scoped_ctx.set!(:thing, thing)
+      #   end
+      # @return [Context::Scoped]
+      def scoped
+        Scoped.new(@scoped_context, current_path)
+      end
 
-        def path
-          @path ||= @parent.path.dup << @key
+      class Scoped
+        def initialize(scoped_context, path)
+          @path = path
+          @scoped_context = scoped_context
         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
+        def merge!(hash)
+          @scoped_context.merge!(hash, at: @path)
         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
+        def set!(key, value)
+          @scoped_context.merge!({ key => value }, at: @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_child(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
+
+require "graphql/query/context/scoped_context"

data/lib/graphql/query/input_validation_result.rb

@@ -33,7 +33,7 @@ module GraphQL
       end
 
       def merge_result!(path, inner_result)
-        return if inner_result.valid?
+        return if inner_result.nil? || inner_result.valid?
 
         if inner_result.problems
           inner_result.problems.each do |p|

data/lib/graphql/query/null_context.rb

@@ -1,54 +1,32 @@
 # frozen_string_literal: true
+require "graphql/query/context"
 module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
-    class NullContext
-      class NullWarden < GraphQL::Schema::Warden
-        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
+    class NullContext < Context
+      include Singleton
 
       class NullQuery
-        def with_error_handling
-          yield
+        def after_lazy(value)
+          yield(value)
         end
       end
 
       class NullSchema < GraphQL::Schema
       end
 
+      extend Forwardable
+
       attr_reader :schema, :query, :warden, :dataloader
+      def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?, :to_h
 
       def initialize
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = NullSchema
-        @warden = NullWarden.new(
-          GraphQL::Filter.new,
-          context: self,
-          schema: @schema,
-        )
-      end
-
-      def [](key); end
-
-      def interpreter?
-        true
-      end
-
-      class << self
-        extend Forwardable
-
-        def [](key); end
-
-        def instance
-          @instance ||= self.new
-        end
-
-        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader
+        @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
+        @types = @warden.visibility_profile
+        freeze
       end
     end
   end