Merge field extension methods

Author: rmosolgo

lib/graphql/execution/field_resolve_step.rb

@@ -491,7 +491,7 @@ def finish_extensions
             end
           else
             memo = memos[@finish_extension_idx]
-            @field_results = ext.after_resolve_next(objects: @extended.object, arguments: @extended.arguments, context: ctx, values: @field_results, memo: memo) # rubocop:disable Development/ContextIsPassedCop
+            @field_results = ext.after_resolve(objects: @extended.object, arguments: @extended.arguments, context: ctx, values: @field_results, memo: memo) # rubocop:disable Development/ContextIsPassedCop
           end
           @finish_extension_idx += 1
           if any_lazy_results?

lib/graphql/schema/field.rb

@@ -929,7 +929,7 @@ def with_extensions(obj, args, ctx)
       def run_next_extensions_before_resolve(objs, args, ctx, extended, idx: 0, &block)
         extension = @extensions[idx]
         if extension
-          extension.resolve_next(objects: objs, arguments: args, context: ctx) do |extended_objs, extended_args, memo|
+          extension.resolve(objects: objs, arguments: args, context: ctx) do |extended_objs, extended_args, memo|
             if memo
               memos = extended.memos ||= {}
               memos[idx] = memo

lib/graphql/schema/field/connection_extension.rb

@@ -12,22 +12,13 @@ def apply
         end
 
         # Remove pagination args before passing it to a user method
-        def resolve(object:, arguments:, context:)
+        def resolve(object: nil, objects: nil, 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, arguments)
-        end
-
-        def resolve_next(objects:, arguments:, context:)
-          next_args = arguments.dup
-          next_args.delete(:first)
-          next_args.delete(:last)
-          next_args.delete(:before)
-          next_args.delete(:after)
-          yield(objects, next_args, arguments)
+          yield(object || objects, next_args, arguments)
         end
 
         def after_resolve(value:, object:, arguments:, context:, memo:)
@@ -36,10 +27,6 @@ def after_resolve(value:, object:, arguments:, context:, memo:)
             context.schema.connections.populate_connection(field, object.object, resolved_value, original_arguments, context)
           end
         end
-
-        def after_resolve_next(**kwargs)
-          raise "This should never be called -- it's hardcoded in execution instead."
-        end
       end
     end
   end

lib/graphql/schema/field/scope_extension.rb

@@ -28,10 +28,6 @@ def after_resolve(object:, arguments:, context:, value:, memo:)
             value
           end
         end
-
-        def after_resolve_next(**kwargs)
-          raise "This should never be called -- it's hardcoded in execution instead."
-        end
       end
     end
   end

lib/graphql/schema/field_extension.rb

@@ -123,63 +123,33 @@ def after_define_apply
       #
       # Whatever this method returns will be used for execution.
       #
-      # @param object [Object] The object the field is being resolved on
+      # @param object [Object] The object the field is being resolved on (not passed by new execution)
+      # @param objects [Array<Object>] The objects the field is being resolved on (passed by new execution)
       # @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 object_or_objects [Object, Array<Object>] The object or objects (new execution) 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 before batch-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 objects [Array<Object>] The objects 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 objects [Array<Object>] The objects to continue resolving the field on. Length must be the same as passed-in `objects:`
-      # @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 [Array<Object>] The return value for this field, length matching passed-in `objects:`.
-      def resolve_next(objects:, arguments:, context:)
-        yield(objects, arguments, nil)
+      def resolve(object: nil, objects: nil, arguments:, context:)
+        yield(object || objects, 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 object [Object] The object the field is being resolved on (not passed by new execution)
+      # @param objects [Array<Object>] The object the field is being resolved on (passed by new execution)
       # @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 value [Object] Whatever the field previously returned (not passed by new execution)
+      # @param values [Array<Object>] Whatever the field previously returned (passed by new execution)
       # @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
-
-      # Called after {#field} was batch-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 objects [Array<Object>] The objects 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 values [Array<Object>] Whatever the field returned, one for each of `objects`
-      # @param memo [Object] The third value yielded by {#resolve}, or `nil` if there wasn't one
-      # @return [Array<Object>] The return values for this field, length matching `objects:`.
-      def after_resolve_next(objects:, arguments:, context:, values:, memo:)
-        values
+      def after_resolve(object: nil, objects: nil, arguments:, context:, values: nil, value: nil, memo:)
+        value || values
       end
     end
   end

lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -2,41 +2,41 @@
 module GraphQL
   class Subscriptions
     class DefaultSubscriptionResolveExtension < GraphQL::Schema::FieldExtension
-      def resolve(context:, object:, arguments:)
-        has_override_implementation = @field.resolver ||
-          object.respond_to?(@field.resolver_method)
+      def resolve(context:, object: nil, objects: nil,  arguments:)
+        if objects
+          has_override_implementation = @field.execution_mode != :direct_send
 
-        if !has_override_implementation
-          if context.query.subscription_update?
-            object.object
+          if !has_override_implementation
+            if context.query.subscription_update?
+              objects
+            else
+              objects.map { |o| context.skip }
+            end
           else
-            context.skip
+            yield(objects, arguments)
           end
         else
-          yield(object, arguments)
-        end
-      end
+          has_override_implementation = @field.resolver ||
+            object.respond_to?(@field.resolver_method)
 
-      def resolve_next(context:, objects:, arguments:)
-        has_override_implementation = @field.execution_mode != :direct_send
-
-        if !has_override_implementation
-          if context.query.subscription_update?
-            objects
+          if !has_override_implementation
+            if context.query.subscription_update?
+              object.object
+            else
+              context.skip
+            end
           else
-            objects.map { |o| context.skip }
+            yield(object, arguments)
           end
-        else
-          yield(objects, arguments)
         end
       end
 
-      def after_resolve(value:, context:, object:, arguments:, **rest)
-        self.class.write_subscription(@field, value, arguments, context)
-      end
-
-      def after_resolve_next(values:, context:, objects:, arguments:, **rest)
-        values.map do |value|
+      def after_resolve(values: nil, value: nil, context:, object:, arguments:, **rest)
+        if values
+          values.map do |value|
+            self.class.write_subscription(@field, value, arguments, context)
+          end
+        else
           self.class.write_subscription(@field, value, arguments, context)
         end
       end