Rename execution_next_mode -> execution_mode

Author: rmosolgo

lib/graphql/execution/next/field_resolve_step.rb

@@ -718,31 +718,31 @@ def build_graphql_result(graphql_result, key, field_result, return_type, is_nn,
 
         def resolve_batch(objects, context, args_hash)
           method_receiver = @field_definition.dynamic_introspection ? @field_definition.owner : @parent_type
-          case @field_definition.execution_next_mode
+          case @field_definition.execution_mode
           when :resolve_batch
             begin
-              method_receiver.public_send(@field_definition.execution_next_mode_key, objects, context, **args_hash)
+              method_receiver.public_send(@field_definition.execution_mode_key, objects, context, **args_hash)
             rescue GraphQL::ExecutionError => exec_err
               Array.new(objects.size, exec_err)
             end
           when :resolve_static
             result = begin
-              method_receiver.public_send(@field_definition.execution_next_mode_key, context, **args_hash)
+              method_receiver.public_send(@field_definition.execution_mode_key, context, **args_hash)
             rescue GraphQL::ExecutionError => err
               err
             end
             Array.new(objects.size, result)
           when :resolve_each
             objects.map do |o|
-              method_receiver.public_send(@field_definition.execution_next_mode_key, o, context, **args_hash)
+              method_receiver.public_send(@field_definition.execution_mode_key, o, context, **args_hash)
             rescue GraphQL::ExecutionError => err
               err
             end
           when :hash_key
-            k = @field_definition.execution_next_mode_key
+            k = @field_definition.execution_mode_key
             objects.map { |o| o[k] }
           when :direct_send
-            m = @field_definition.execution_next_mode_key
+            m = @field_definition.execution_mode_key
             objects.map do |o|
               o.public_send(m, **args_hash)
             rescue GraphQL::ExecutionError => err
@@ -755,9 +755,9 @@ def resolve_batch(objects, context, args_hash)
               end
             end
           when :dig
-            objects.map { |o| o.dig(*@field_definition.execution_next_mode_key) }
+            objects.map { |o| o.dig(*@field_definition.execution_mode_key) }
           when :dataload
-            if (k = @field_definition.execution_next_mode_key).is_a?(Class)
+            if (k = @field_definition.execution_mode_key).is_a?(Class)
               context.dataload_all(k, objects)
             elsif (source_class = k[:with])
               if (batch_args = k[:by])
@@ -796,12 +796,12 @@ def resolve_batch(objects, context, args_hash)
               if @field_definition.dynamic_introspection
                 obj_inst = @owner.wrap(obj_inst, context)
               end
-              obj_inst.public_send(@field_definition.execution_next_mode_key, **args_hash)
+              obj_inst.public_send(@field_definition.execution_mode_key, **args_hash)
             rescue GraphQL::ExecutionError => exec_err
               exec_err
             end
           else
-            raise "Batching execution for #{path} not implemented (execution_next_mode: #{@execution_next_mode.inspect}); provide `resolve_static:`, `resolve_batch:`, `hash_key:`, `method:`, or use a compatibility plug-in"
+            raise "Batching execution for #{path} not implemented (execution_mode: #{@execution_mode.inspect}); provide `resolve_static:`, `resolve_batch:`, `hash_key:`, `method:`, or use a compatibility plug-in"
           end
         end
       end

lib/graphql/schema/field.rb

@@ -270,32 +270,32 @@ def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CON
         @resolver_method = (resolver_method || name_s).to_sym
 
         if resolve_static
-          @execution_next_mode = :resolve_static
-          @execution_next_mode_key = resolve_static == true ? @method_sym : resolve_static
+          @execution_mode = :resolve_static
+          @execution_mode_key = resolve_static == true ? @method_sym : resolve_static
         elsif resolve_batch
-          @execution_next_mode = :resolve_batch
-          @execution_next_mode_key = resolve_batch == true ? @method_sym : resolve_batch
+          @execution_mode = :resolve_batch
+          @execution_mode_key = resolve_batch == true ? @method_sym : resolve_batch
         elsif resolve_each
-          @execution_next_mode = :resolve_each
-          @execution_next_mode_key = resolve_each == true ? @method_sym : resolve_each
+          @execution_mode = :resolve_each
+          @execution_mode_key = resolve_each == true ? @method_sym : resolve_each
         elsif hash_key
-          @execution_next_mode = :hash_key
-          @execution_next_mode_key = hash_key
+          @execution_mode = :hash_key
+          @execution_mode_key = hash_key
         elsif dig
-          @execution_next_mode = :dig
-          @execution_next_mode_key = dig
+          @execution_mode = :dig
+          @execution_mode_key = dig
         elsif resolver_class
-          @execution_next_mode = :resolver_class
-          @execution_next_mode_key = resolver_class
+          @execution_mode = :resolver_class
+          @execution_mode_key = resolver_class
         elsif resolve_legacy_instance_method
-          @execution_next_mode = :resolve_legacy_instance_method
-          @execution_next_mode_key = resolve_legacy_instance_method == true ? @method_sym : resolve_legacy_instance_method
+          @execution_mode = :resolve_legacy_instance_method
+          @execution_mode_key = resolve_legacy_instance_method == true ? @method_sym : resolve_legacy_instance_method
         elsif dataload
-          @execution_next_mode = :dataload
-          @execution_next_mode_key = dataload
+          @execution_mode = :dataload
+          @execution_mode_key = dataload
         else
-          @execution_next_mode = :direct_send
-          @execution_next_mode_key = @method_sym
+          @execution_mode = :direct_send
+          @execution_mode_key = @method_sym
         end
 
         @complexity = complexity
@@ -369,7 +369,7 @@ def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CON
       end
 
       # @api private
-      attr_reader :execution_next_mode_key, :execution_next_mode
+      attr_reader :execution_mode_key, :execution_mode
 
       # Calls the definition block, if one was given.
       # This is deferred so that references to the return type

lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -18,7 +18,7 @@ def resolve(context:, object:, arguments:)
       end
 
       def resolve_next(context:, objects:, arguments:)
-        has_override_implementation = @field.execution_next_mode != :direct_send
+        has_override_implementation = @field.execution_mode != :direct_send
 
         if !has_override_implementation
           if context.query.subscription_update?