graphql 1.8.7 → 1.9.0

data/lib/graphql/schema/field/connection_extension.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Field
+      class ConnectionExtension < GraphQL::Schema::FieldExtension
+        def apply
+          field.argument :after, "String", "Returns the elements in the list that come after the specified cursor.", required: false
+          field.argument :before, "String", "Returns the elements in the list that come before the specified cursor.", required: false
+          field.argument :first, "Int", "Returns the first _n_ elements from the list.", required: false
+          field.argument :last, "Int", "Returns the last _n_ elements from the list.", required: false
+        end
+
+        # Remove pagination args before passing it to a user method
+        def resolve(object:, arguments:, context:)
+          next_args = arguments.dup
+          next_args.delete(:first)
+          next_args.delete(:last)
+          next_args.delete(:before)
+          next_args.delete(:after)
+          yield(object, next_args)
+        end
+
+        def after_resolve(value:, object:, arguments:, context:, memo:)
+          if value.is_a? GraphQL::ExecutionError
+            # This isn't even going to work because context doesn't have ast_node anymore
+            context.add_error(value)
+            nil
+          elsif value.nil?
+            nil
+          else
+            if object.is_a?(GraphQL::Schema::Object)
+              object = object.object
+            end
+            connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(value)
+            connection_class.new(
+              value,
+              arguments,
+              field: field,
+              max_page_size: field.max_page_size,
+              parent: object,
+              context: context,
+            )
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/graphql/schema/field/scope_extension.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Field
+      class ScopeExtension < GraphQL::Schema::FieldExtension
+        def after_resolve(value:, context:, **rest)
+          ret_type = @field.type.unwrap
+          if ret_type.respond_to?(:scope_items)
+            ret_type.scope_items(value, context)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/field.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 # test_via: ../object.rb
+require "graphql/schema/field/connection_extension"
+require "graphql/schema/field/scope_extension"
+
 module GraphQL
   class Schema
     class Field
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasArguments
+      include GraphQL::Schema::Member::HasPath
 
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -16,15 +20,20 @@ module GraphQL
       # @return [String, nil] If present, the field is marked as deprecated with this documentation
       attr_accessor :deprecation_reason
 
-      # @return [Symbol] Method or hash key to look up
+      # @return [Symbol] Method or hash key on the underlying object to look up
       attr_reader :method_sym
 
-      # @return [String] Method or hash key to look up
+      # @return [String] Method or hash key on the underlying object to look up
       attr_reader :method_str
 
+      # @return [Symbol] The method on the type to look up
+      attr_reader :resolver_method
+
       # @return [Class] The type that this field belongs to
       attr_reader :owner
 
+      # @return [Symobol] the original name of the field, passed in by the user
+      attr_reader :original_name
 
       # @return [Class, nil] The {Schema::Resolver} this field was derived from, if there is one
       def resolver
@@ -33,6 +42,15 @@ module GraphQL
 
       alias :mutation :resolver
 
+      # @return [Array<Symbol>]
+      attr_reader :extras
+
+      # @return [Boolean] Apply tracing to this field? (Default: skip scalars, this is the override value)
+      attr_reader :trace
+
+      # @return [String, nil]
+      attr_reader :subscription_scope
+
       # Create a field instance from a list of arguments, keyword arguments, and a block.
       #
       # This method implements prioritization between the `resolver` or `mutation` defaults
@@ -41,10 +59,21 @@ module GraphQL
       # It also normalizes positional arguments into keywords for {Schema::Field#initialize}.
       # @param resolver [Class] A {GraphQL::Schema::Resolver} class to use for field configuration
       # @param mutation [Class] A {GraphQL::Schema::Mutation} class to use for field configuration
+      # @param subscription [Class] A {GraphQL::Schema::Subscription} class to use for field configuration
       # @return [GraphQL::Schema:Field] an instance of `self
       # @see {.initialize} for other options
-      def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, **kwargs, &block)
-        if (parent_config = resolver || mutation)
+      def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
+        if kwargs[:field]
+          if kwargs[:field] == GraphQL::Relay::Node.field
+            warn("Legacy-style `GraphQL::Relay::Node.field` is being added to a class-based type. See `GraphQL::Types::Relay::NodeField` for a replacement.")
+            return GraphQL::Types::Relay::NodeField
+          elsif kwargs[:field] == GraphQL::Relay::Node.plural_field
+            warn("Legacy-style `GraphQL::Relay::Node.plural_field` is being added to a class-based type. See `GraphQL::Types::Relay::NodesField` for a replacement.")
+            return GraphQL::Types::Relay::NodesField
+          end
+        end
+
+        if (parent_config = resolver || mutation || subscription)
           # Get the parent config, merge in local overrides
           kwargs = parent_config.field_options.merge(kwargs)
           # Add a reference to that parent class
@@ -86,7 +115,8 @@ module GraphQL
           elsif @return_type_expr
             Member::BuildType.to_type_name(@return_type_expr)
           else
-            raise "No connection info possible"
+            # As a last ditch, try to force loading the return type:
+            type.unwrap.name
           end
           @connection = return_type_name.end_with?("Connection")
         else
@@ -100,19 +130,19 @@ module GraphQL
           # The default was overridden
           @scope
         else
-          @return_type_expr && type.unwrap.respond_to?(:scope_items) && (connection? || type.list?)
+          @return_type_expr.is_a?(Array) || (@return_type_expr.is_a?(String) && @return_type_expr.include?("[")) || connection?
         end
       end
 
       # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
-      # @param return_type_expr [Class, GraphQL::BaseType, Array] The return type of this field
-      # @param desc [String] Field description
+      # @param type [Class, GraphQL::BaseType, Array] The return type of this field
       # @param owner [Class] The type that this field belongs to
       # @param null [Boolean] `true` if this field may return `null`, `false` if it is never `null`
       # @param description [String] Field description
       # @param deprecation_reason [String] If present, the field is marked "deprecated" with this message
-      # @param method [Symbol] The method to call to resolve this field (defaults to `name`)
-      # @param hash_key [Object] The hash key to lookup to resolve this field (defaults to `name` or `name.to_s`)
+      # @param method [Symbol] The method to call on the underlying object to resolve this field (defaults to `name`)
+      # @param hash_key [String, Symbol] The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
+      # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param max_page_size [Integer] For connections, the maximum number of items to return from this field
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
@@ -125,8 +155,9 @@ module GraphQL
       # @param complexity [Numeric] When provided, set the complexity for this field
       # @param scope [Boolean] If true, the return type's `.scope_items` method will be called on the return value
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, scope: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], resolver_class: nil, subscription_scope: nil, arguments: {}, &definition_block)
-
+      # @param extensions [Array<Class>] Named extensions to apply to this field (see also {#extension})
+      # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, extras: [], extensions: [], resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, arguments: {}, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -141,25 +172,40 @@ module GraphQL
         if (field || function || resolve) && extras.any?
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
         end
+        @original_name = name
+        @underscored_name = Member::BuildType.underscore(name.to_s)
         @name = camelize ? Member::BuildType.camelize(name.to_s) : name.to_s
         @description = description
         if field.is_a?(GraphQL::Schema::Field)
-          @field_instance = field
+          raise ArgumentError, "Instead of passing a field as `field:`, use `add_field(field)` to add an already-defined field."
         else
           @field = field
         end
         @function = function
         @resolve = resolve
         @deprecation_reason = deprecation_reason
+
         if method && hash_key
           raise ArgumentError, "Provide `method:` _or_ `hash_key:`, not both. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}`)"
         end
 
+        if resolver_method
+          if method
+            raise ArgumentError, "Provide `method:` _or_ `resolver_method:`, not both. (called with: `method: #{method.inspect}, resolver_method: #{resolver_method.inspect}`)"
+          end
+
+          if hash_key
+            raise ArgumentError, "Provide `hash_key:` _or_ `resolver_method:`, not both. (called with: `hash_key: #{hash_key.inspect}, resolver_method: #{resolver_method.inspect}`)"
+          end
+        end
+
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
-        method_name = method || hash_key || Member::BuildType.underscore(name.to_s)
+        method_name = method || hash_key || @underscored_name
+        resolver_method ||= @underscored_name
 
         @method_str = method_name.to_s
         @method_sym = method_name.to_sym
+        @resolver_method = resolver_method
         @complexity = complexity
         @return_type_expr = type
         @return_type_null = null
@@ -169,6 +215,9 @@ module GraphQL
         @extras = extras
         @resolver_class = resolver_class
         @scope = scope
+        @trace = trace
+        @relay_node_field = relay_node_field
+        @relay_nodes_field = relay_nodes_field
 
         # Override the default from HasArguments
         @own_arguments = {}
@@ -183,9 +232,25 @@ module GraphQL
         @owner = owner
         @subscription_scope = subscription_scope
 
+        # Do this last so we have as much context as possible when initializing them:
+        @extensions = []
+        if extensions.any?
+          self.extensions(extensions)
+        end
+        # This should run before connection extension,
+        # but should it run after the definition block?
+        if scoped?
+          self.extension(ScopeExtension)
+        end
+        # The problem with putting this after the definition_block
+        # is that it would override arguments
+        if connection?
+          self.extension(ConnectionExtension)
+        end
+
         if definition_block
           if definition_block.arity == 1
-            instance_exec(self, &definition_block)
+            yield self
           else
             instance_eval(&definition_block)
           end
@@ -202,6 +267,49 @@ module GraphQL
         end
       end
 
+      # Read extension instances from this field,
+      # or add new classes/options to be initialized on this field.
+      #
+      # @param extensions [Array<Class>, Hash<Class => Object>] Add extensions to this field
+      # @return [Array<GraphQL::Schema::FieldExtension>] extensions to apply to this field
+      def extensions(new_extensions = nil)
+        if new_extensions.nil?
+          # Read the value
+          @extensions
+        else
+          if @resolve || @function
+            raise ArgumentError, <<-MSG
+Extensions are not supported with resolve procs or functions,
+but #{owner.name}.#{name} has: #{@resolve || @function}
+So, it can't have extensions: #{extensions}.
+Use a method or a Schema::Resolver instead.
+MSG
+          end
+
+          # Normalize to a Hash of {name => options}
+          extensions_with_options = if new_extensions.last.is_a?(Hash)
+            new_extensions.pop
+          else
+            {}
+          end
+          new_extensions.each do |f|
+            extensions_with_options[f] = nil
+          end
+
+          # Initialize each class and stash the instance
+          extensions_with_options.each do |extension_class, options|
+            @extensions << extension_class.new(field: self, options: options)
+          end
+        end
+      end
+
+      # Add `extension` to this field, initialized with `options` if provided.
+      # @param extension [Class] subclass of {Schema::Fieldextension}
+      # @param options [Object] if provided, given as `options:` when initializing `extension`.
+      def extension(extension, options = nil)
+        extensions([{extension => options}])
+      end
+
       def complexity(new_complexity)
         case new_complexity
         when Proc
@@ -218,17 +326,13 @@ module GraphQL
         else
           raise("Invalid complexity: #{new_complexity.inspect} on #{@name}")
         end
-
       end
 
+      # @return [Integer, nil] Applied to connections if present
+      attr_reader :max_page_size
+
       # @return [GraphQL::Field]
       def to_graphql
-        # this field was previously defined and passed here, so delegate to it
-        if @field_instance
-          return @field_instance.to_graphql
-        end
-
-
         field_defn = if @field
           @field.dup
         elsif @function
@@ -257,24 +361,25 @@ module GraphQL
           field_defn.metadata[:resolver] = @resolver_class
         end
 
+        if !@trace.nil?
+          field_defn.trace = @trace
+        end
+
+        if @relay_node_field
+          field_defn.relay_node_field = @relay_node_field
+        end
+
+        if @relay_nodes_field
+          field_defn.relay_nodes_field = @relay_nodes_field
+        end
+
         field_defn.resolve = self.method(:resolve_field)
         field_defn.connection = connection?
-        field_defn.connection_max_page_size = @max_page_size
+        field_defn.connection_max_page_size = max_page_size
         field_defn.introspection = @introspection
         field_defn.complexity = @complexity
         field_defn.subscription_scope = @subscription_scope
 
-        # apply this first, so it can be overriden below
-        if connection?
-          # TODO: this could be a bit weird, because these fields won't be present
-          # after initialization, only in the `to_graphql` response.
-          # This calculation _could_ be moved up if need be.
-          argument :after, "String", "Returns the elements in the list that come after the specified cursor.", required: false
-          argument :before, "String", "Returns the elements in the list that come before the specified cursor.", required: false
-          argument :first, "Int", "Returns the first _n_ elements from the list.", required: false
-          argument :last, "Int", "Returns the last _n_ elements from the list.", required: false
-        end
-
         arguments.each do |name, defn|
           arg_graphql = defn.to_graphql
           field_defn.arguments[arg_graphql.name] = arg_graphql
@@ -318,39 +423,99 @@ module GraphQL
       end
 
       def authorized?(object, context)
-        if @resolver_class
+        self_auth = if @resolver_class
           @resolver_class.authorized?(object, context)
         else
           true
         end
+
+        if self_auth
+          # Faster than `.any?`
+          arguments.each_value do |arg|
+            if !arg.authorized?(object, context)
+              return false
+            end
+          end
+          true
+        else
+          false
+        end
       end
 
       # Implement {GraphQL::Field}'s resolve API.
       #
       # Eventually, we might hook up field instances to execution in another way. TBD.
+      # @see #resolve for how the interpreter hooks up to it
       def resolve_field(obj, args, ctx)
         ctx.schema.after_lazy(obj) do |after_obj|
           # First, apply auth ...
           query_ctx = ctx.query.context
+          # Some legacy fields can have `nil` here, not exactly sure why.
+          # @see https://github.com/rmosolgo/graphql-ruby/issues/1990 before removing
           inner_obj = after_obj && after_obj.object
-          if authorized?(inner_obj, query_ctx) && arguments.each_value.all? { |a| a.authorized?(inner_obj, query_ctx) }
+          if authorized?(inner_obj, query_ctx)
             # Then if it passed, resolve the field
-            v = if @resolve_proc
+            if @resolve_proc
               # Might be nil, still want to call the func in that case
               @resolve_proc.call(inner_obj, args, ctx)
-            elsif @resolver_class
-              singleton_inst = @resolver_class.new(object: inner_obj, context: query_ctx)
-              public_send_field(singleton_inst, args, ctx)
             else
               public_send_field(after_obj, args, ctx)
             end
-            apply_scope(v, ctx)
           else
-            nil
+            err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
+            query_ctx.schema.unauthorized_field(err)
           end
         end
       end
 
+      # This method is called by the interpreter for each field.
+      # You can extend it in your base field classes.
+      # @param object [GraphQL::Schema::Object] An instance of some type class, wrapping an application object
+      # @param args [Hash] A symbol-keyed hash of Ruby keyword arguments. (Empty if no args)
+      # @param ctx [GraphQL::Query::Context]
+      def resolve(object, args, ctx)
+        if @resolve_proc
+          raise "Can't run resolve proc for #{path} when using GraphQL::Execution::Interpreter"
+        end
+        begin
+          # Unwrap the GraphQL object to get the application object.
+          application_object = object.object
+          if self.authorized?(application_object, ctx)
+            # Apply field extensions
+            with_extensions(object, args, ctx) do |extended_obj, extended_args|
+              field_receiver = if @resolver_class
+                resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
+                  extended_obj.object
+                else
+                  extended_obj
+                end
+                @resolver_class.new(object: resolver_obj, context: ctx)
+              else
+                extended_obj
+              end
+
+              if field_receiver.respond_to?(@resolver_method)
+                # Call the method with kwargs, if there are any
+                if extended_args.any?
+                  field_receiver.public_send(@resolver_method, **extended_args)
+                else
+                  field_receiver.public_send(@resolver_method)
+                end
+              else
+                resolve_field_method(field_receiver, extended_args, ctx)
+              end
+            end
+          else
+            err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+            ctx.schema.unauthorized_field(err)
+          end
+        rescue GraphQL::UnauthorizedError => err
+          ctx.schema.unauthorized_object(err)
+        end
+      rescue GraphQL::ExecutionError => err
+        err
+      end
+
       # Find a way to resolve this field, checking:
       #
       # - Hash keys, if the wrapped object is a hash;
@@ -379,7 +544,7 @@ module GraphQL
           raise <<-ERR
         Failed to implement #{@owner.graphql_name}.#{@name}, tried:
 
-        - `#{obj.class}##{@method_sym}`, which did not exist
+        - `#{obj.class}##{@resolver_method}`, which did not exist
         - `#{obj.object.class}##{@method_sym}`, which did not exist
         - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
 
@@ -388,18 +553,19 @@ module GraphQL
         end
       end
 
-      private
-
-      def apply_scope(value, ctx)
-        if scoped?
-          ctx.schema.after_lazy(value) do |inner_value|
-            @type.unwrap.scope_items(inner_value, ctx)
-          end
+      # @param ctx [GraphQL::Query::Context::FieldResolutionContext]
+      def fetch_extra(extra_name, ctx)
+        if extra_name != :path && respond_to?(extra_name)
+          self.public_send(extra_name)
+        elsif ctx.respond_to?(extra_name)
+          ctx.public_send(extra_name)
         else
-          value
+          raise NotImplementedError, "Unknown field extra for #{self.path}: #{extra_name.inspect}"
         end
       end
 
+      private
+
       NO_ARGS = {}.freeze
 
       def public_send_field(obj, graphql_args, field_ctx)
@@ -414,27 +580,70 @@ module GraphQL
             end
           end
 
-          if connection?
-            # Remove pagination args before passing it to a user method
-            ruby_kwargs.delete(:first)
-            ruby_kwargs.delete(:last)
-            ruby_kwargs.delete(:before)
-            ruby_kwargs.delete(:after)
-          end
-
           @extras.each do |extra_arg|
-            # TODO: provide proper tests for `:ast_node`, `:irep_node`, `:parent`, others?
-            ruby_kwargs[extra_arg] = field_ctx.public_send(extra_arg)
+            ruby_kwargs[extra_arg] = fetch_extra(extra_arg, field_ctx)
           end
         else
           ruby_kwargs = NO_ARGS
         end
 
+        query_ctx = field_ctx.query.context
+        with_extensions(obj, ruby_kwargs, query_ctx) do |extended_obj, extended_args|
+          if @resolver_class
+            if extended_obj.is_a?(GraphQL::Schema::Object)
+              extended_obj = extended_obj.object
+            end
+            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx)
+          end
+
+          if extended_obj.respond_to?(@resolver_method)
+            if extended_args.any?
+              extended_obj.public_send(@resolver_method, **extended_args)
+            else
+              extended_obj.public_send(@resolver_method)
+            end
+          else
+            resolve_field_method(extended_obj, extended_args, query_ctx)
+          end
+        end
+      end
+
+      # Wrap execution with hooks.
+      # Written iteratively to avoid big stack traces.
+      # @return [Object] Whatever the
+      def with_extensions(obj, args, ctx)
+        if @extensions.empty?
+          yield(obj, args)
+        else
+          # Save these so that the originals can be re-given to `after_resolve` handlers.
+          original_args = args
+          original_obj = obj
+
+          memos = []
+          value = run_extensions_before_resolve(memos, obj, args, ctx) do |extended_obj, extended_args|
+            yield(extended_obj, extended_args)
+          end
 
-        if ruby_kwargs.any?
-          obj.public_send(@method_sym, **ruby_kwargs)
+          ctx.schema.after_lazy(value) do |resolved_value|
+            @extensions.each_with_index do |ext, idx|
+              memo = memos[idx]
+              # TODO after_lazy?
+              resolved_value = ext.after_resolve(object: original_obj, arguments: original_args, context: ctx, value: resolved_value, memo: memo)
+            end
+            resolved_value
+          end
+        end
+      end
+
+      def run_extensions_before_resolve(memos, obj, args, ctx, idx: 0)
+        extension = @extensions[idx]
+        if extension
+          extension.resolve(object: obj, arguments: args, context: ctx) do |extended_obj, extended_args, memo|
+            memos << memo
+            run_extensions_before_resolve(memos, extended_obj, extended_args, ctx, idx: idx + 1) { |o, a| yield(o, a) }
+          end
         else
-          obj.public_send(@method_sym)
+          yield(obj, args)
         end
       end
     end

data/lib/graphql/schema/field_extension.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # Extend this class to make field-level customizations to resolve behavior.
+    #
+    # When a extension is added to a field with `extension(MyExtension)`, a `MyExtension` instance
+    # is created, and its hooks are applied whenever that field is called.
+    #
+    # The instance is frozen so that instance variables aren't modified during query execution,
+    # which could cause all kinds of issues due to race conditions.
+    class FieldExtension
+      # @return [GraphQL::Schema::Field]
+      attr_reader :field
+
+      # @return [Object]
+      attr_reader :options
+
+      # Called when the extension is mounted with `extension(name, options)`.
+      # The instance is frozen to avoid improper use of state during execution.
+      # @param field [GraphQL::Schema::Field] The field where this extension was mounted
+      # @param options [Object] The second argument to `extension`, or `nil` if nothing was passed.
+      def initialize(field:, options:)
+        @field = field
+        @options = options
+        apply
+        freeze
+      end
+
+      # Called when this extension is attached to a field.
+      # The field definition may be extended during this method.
+      # @return [void]
+      def apply
+      end
+
+      # Called before resolving {#field}. It should either:
+      #
+      # - `yield` values to continue execution; OR
+      # - return something else to shortcut field execution.
+      #
+      # Whatever this method returns will be used for execution.
+      #
+      # @param object [Object] The object the field is being resolved on
+      # @param arguments [Hash] Ruby keyword arguments for resolving this field
+      # @param context [Query::Context] the context for this query
+      # @yieldparam object [Object] The object to continue resolving the field on
+      # @yieldparam arguments [Hash] The keyword arguments to continue resolving with
+      # @yieldparam memo [Object] Any extension-specific value which will be passed to {#after_resolve} later
+      # @return [Object] The return value for this field.
+      def resolve(object:, arguments:, context:)
+        yield(object, arguments, nil)
+      end
+
+      # Called after {#field} was resolved, and after any lazy values (like `Promise`s) were synced,
+      # but before the value was added to the GraphQL response.
+      #
+      # Whatever this hook returns will be used as the return value.
+      #
+      # @param object [Object] The object the field is being resolved on
+      # @param arguments [Hash] Ruby keyword arguments for resolving this field
+      # @param context [Query::Context] the context for this query
+      # @param value [Object] Whatever the field previously returned
+      # @param memo [Object] The third value yielded by {#resolve}, or `nil` if there wasn't one
+      # @return [Object] The return value for this field.
+      def after_resolve(object:, arguments:, context:, value:, memo:)
+        value
+      end
+    end
+  end
+end