graphql_migrate_execution 0.0.2 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fbd874076a766e4abf14571cc0d4d9a348f5868f89df74f9e0f2ad421e65fd4
-  data.tar.gz: 013e06b1123c06b80d9fd2e270ace5032890c8d35cb8bac8f91e78e8805755ac
+  metadata.gz: 9c879a6e266b7520abe76bf69a63cbc7ff8a446fe6438ad0ca37c89368f4c153
+  data.tar.gz: cb33f65e293a55a01d3d2e440eb23f40e2f5c3fc28f1241720f40cacf76ca5d4
 SHA512:
-  metadata.gz: 24a586f44159ceac3d674171cbc25d31c342c7238f6d025954f833e6000231a61893c04bdac741df32e5e90c9f30dd22976069eca8c7af66a8c0b1571fc4c6f9
-  data.tar.gz: fc25e0c9baf95aed3104802604bbd8aba57cd528dd136c912f5f459c973f08f1b510623b13b9a7abcae272ce98c834572ca64b4391841b184c6810e19d99ecc6
+  metadata.gz: 99bdbfe4e36d7dce2a78ef1254d4bde1039d3c5189aa96df6c7dab18023ae1f3d58293e1dc98ae0f639f14ced08ebe4f930565d344ff2821fa765ae122c00d8f
+  data.tar.gz: 9e29f27f38e4603a2076071d91dd304c81239e39c59080dfdc533aa9a1f0dc11175bd354a4c924e13b9abd60ba18ba2a7ab79f5270ae6107015ee949cb1ec5ee

data/bin/graphql_migrate_execution

@@ -20,13 +20,10 @@ parser.banner = <<~TEXT
 
 TEXT
 
-parser.on("--migrate", "Update the files with future-compatibile configuration")
+parser.on("--migrate", "Update the files with future-compatible configuration")
 parser.on("--cleanup", "Remove resolver instance methods for GraphQL-Ruby's old runtime")
-parser.on("--concise", "Don't print migration strategy descriptions")
-
-# TODO:
-parser.on("--implicit MODE", "Handle implicit field resolution using MODE")
-parser.on("--only PATTERN", "Only analyze or update fields whose path (`Type.field`) matches /PATTERN/")
+parser.on("--dry-run", "Don't actually modify files")
+parser.on("--implicit [MODE]", String, "Handle implicit field resolution this way (ignore / hash_key / hash_key_string)")
 
 parser.parse!(into: options)
 
@@ -35,5 +32,7 @@ filename = ARGV.shift || begin
   exit 1
 end
 
+options[:dry_run] = options.delete(:"dry-run")
+
 migration = GraphqlMigrateExecution::Migration.new(filename, **options)
 migration.run

data/lib/graphql_migrate_execution/action.rb

@@ -1,42 +1,51 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
   class Action
-    def initialize(migration, path, source)
+    module Colorize
+      private
+      def colorize(str, color_or_colors)
+        IRB::Color.colorize(str, Array(color_or_colors), colorable: @migration.colorable)
+      end
+    end
+
+    include Colorize
+
+    def initialize(migration, filepath, ruby_source)
       @migration = migration
-      @path = path
-      @source = source
-      @type_definitions = Hash.new { |h, k| h[k] = TypeDefinition.new(k) }
-      @field_definitions_by_strategy = Hash.new { |h, k| h[k] = [] }
-      @total_field_definitions = 0
+      @filepath = filepath
+      @ruby_source = ruby_source
+      @message = "".dup
+      @result_source = @ruby_source.dup
+      @strategy_name_padding = nil
+      @field_name_padding = nil
     end
 
-    attr_reader :type_definitions
+    attr_reader :message, :result_source, :migration, :filepath, :strategy_name_padding, :field_name_padding
 
     def run
-      parse_result = Prism.parse(@source, filepath: @path)
-      visitor = Visitor.new(@source, @type_definitions)
+      parse_result = Prism.parse(@ruby_source, filepath: @filepath)
+      type_definitions = Hash.new { |h, k| h[k] = TypeDefinition.new(k, @migration) }
+      visitor = Visitor.new(@ruby_source, type_definitions)
       visitor.visit(parse_result.value)
-      @type_definitions.each do |name, type_defn|
+      total_field_definitions = 0
+      field_definitions_by_strategy = Hash.new { |h, k| h[k] = [] }
+      type_definitions.each do |name, type_defn|
         type_defn.field_definitions.each do |f_name, f_defn|
-          @total_field_definitions += 1
+          total_field_definitions += 1
           f_defn.check_for_resolver_method
-          @field_definitions_by_strategy[f_defn.migration_strategy] << f_defn
+          field_definitions_by_strategy[f_defn.migration_strategy] << f_defn
         end
       end
-      nil
-    end
-
-    private
 
-    def call_method_on_strategy(method_name)
-      new_source = @source.dup
-      @field_definitions_by_strategy.each do |strategy_class, field_definitions|
-        strategy = strategy_class.new
-        field_definitions.each do |field_defn|
-          strategy.public_send(method_name, field_defn, new_source)
-        end
+      @message << "#{colorize(@filepath, :BOLD)}: "
+      @message << "Found #{total_field_definitions} field definition#{total_field_definitions == 1 ? "" : "s"}:\n"
+      @strategy_name_padding = field_definitions_by_strategy.each_key.map { |sc| sc.strategy_name.size }.max
+      @field_name_padding = field_definitions_by_strategy.each_value.flat_map { |fds| fds.map { |fd| fd.path.size } }.max
+      field_definitions_by_strategy.each do |strategy_class, field_definitions|
+        strategy = strategy_class.new(self, field_definitions)
+        strategy.run
       end
-      new_source
+      @message << "\n"
     end
   end
 end

data/lib/graphql_migrate_execution/dataloader_all.rb

@@ -1,21 +1,41 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
+  # This field calls dataloader with some property of `object`. It can be migrated to use `dataload_all(...)` and `objects.map { |object| ... }`.
+  #
+  # ```ruby
+  # # Previous:
+  # def my_field
+  #   dataload(Sources::GetThing, object.some_attribute)
+  # end
+  #
+  # # New:
+  # def self.my_field(objects, context)
+  #   context.dataload_all(Sources::GetThing, objects.map { |object| object.some_attribute })
+  # end
+  # ```
   class DataloaderAll < Strategy
-    DESCRIPTION = <<~DESC
-    These fields can be migrated to a `.load_all` call.
-    DESC
     self.color = :GREEN
 
-    def add_future(field_definition, new_source)
-      inject_resolve_keyword(new_source, field_definition, :resolve_batch)
+    def migrate(field_definition)
+      inject_resolve_keyword(field_definition, :resolve_batch)
+      inject_batch_dataloader_method(field_definition, [:request, :load], :dataload, "map")
+    end
+
+    def cleanup(field_definition)
+      remove_resolver_method(field_definition)
+    end
+
+    private
+
+    def inject_batch_dataloader_method(field_definition, longhand_methods, shorthand_method, map_method)
       def_node = field_definition.resolver_method.node
       call_node = def_node.body.body.first
       case call_node.name
-      when :request, :load
+      when *longhand_methods
         load_arg_node = call_node.arguments.arguments.first
         with_node = call_node.receiver
         source_class_node, *source_args_nodes = with_node.arguments
-      when :dataload
+      when shorthand_method
         source_class_node, *source_args_nodes, load_arg_node = call_node.arguments.arguments
       else
         raise ArgumentError, "Unexpected DataloadAll method name: #{def_node.name.inspect}"
@@ -28,10 +48,19 @@ module GraphqlMigrateExecution
       when /object((\.|\[)[:a-zA-Z0-9_\.\"\'\[\]]+)/
         call_chain = $1
         if /^\.[a-z0-9_A-Z]+$/.match?(call_chain)
-          "objects.map(&:#{call_chain[1..-1]})"
+          "objects.#{map_method}(&:#{call_chain[1..-1]})"
         else
-          "objects.map { |obj| obj#{call_chain} }"
+          "objects.#{map_method} { |obj| obj#{call_chain} }"
         end
+      when /([A-Z][a-zA-Z_0-9]*(\.|\[)[:a-zA-Z0-9_\.\"\'\[\]]+)/
+        # Constant call
+        "objects.#{map_method} { |_obj| #{$1} }"
+      when /^("[a-zA-Z0-9 :_\.]+"|:[a-zA-Z0-9_]+)$/
+        # Constant literal
+        "Array.new(objects.size, #{$1})"
+      when /^([a-z_0-9.]+)$/
+        # Local variable or receiverless method, possibly followed by a method chain
+        "Array.new(objects.size, #{$1})"
       else
         raise ArgumentError, "Failed to transform Dataloader argument: #{old_load_arg_s.inspect}"
       end
@@ -49,11 +78,7 @@ module GraphqlMigrateExecution
       new_method_source.sub!(call_node.slice, "context.dataload_all(#{new_args})")
 
       combined_new_source = new_method_source + "\n" + old_method_source
-      new_source.sub!(old_method_source, combined_new_source)
-    end
-
-    def remove_legacy(field_definition, new_source)
-      remove_resolver_method(new_source, field_definition)
+      @result_source.sub!(old_method_source, combined_new_source)
     end
   end
 end

data/lib/graphql_migrate_execution/dataloader_batch.rb

@@ -1,8 +1,70 @@
 # frozen_string_literal: true
+require_relative "./dataloader_all"
+
 module GraphqlMigrateExecution
-  class DataloaderBatch < Strategy
-    DESCRIPTION = <<~DESC
-    These fields can be rewritten to dataload in a `resolve_batch:` method.
-    DESC
+  # These fields return an array of values using Dataloader, based on a method or attribute of `object`. They can be migrated to `dataloader_all` calls, using `object.flat_map`.
+  #
+  # **TODO**: This is not quite right yet. It returns a single array instead of an array of arrays.
+  #
+  # Instead, this should create an Array of arrays using `dataloader.request_all`.
+  class DataloaderBatch < DataloaderAll
+    self.color = :GREEN
+
+    def migrate(field_definition)
+      inject_resolve_keyword(field_definition, :resolve_batch)
+      # inject_batch_dataloader_method(field_definition, [:request_all, :load_all], :dataload_all, "flat_map")
+
+      def_node = field_definition.resolver_method.node
+      call_node = def_node.body.body.first
+      case call_node.name
+      when :request_all, :load_all
+        load_arg_node = call_node.arguments.arguments.first
+        with_node = call_node.receiver
+        source_class_node, *source_args_nodes = with_node.arguments
+      when :dataload_all
+        source_class_node, *source_args_nodes, load_arg_node = call_node.arguments.arguments
+      else
+        raise ArgumentError, "Unexpected DataloadAll method name: #{def_node.name.inspect}"
+      end
+
+      old_load_arg_s = load_arg_node.slice
+      new_load_arg_s = case old_load_arg_s
+      when "object"
+        "object"
+      when /object((\.|\[)[:a-zA-Z0-9_\.\"\'\[\]]+)/
+        call_chain = $1
+        "object#{call_chain}"
+      else
+        raise ArgumentError, "Failed to transform Dataloader argument: #{old_load_arg_s.inspect}"
+      end
+      new_source_args = [
+        source_class_node.slice,
+        *source_args_nodes.map(&:slice)
+      ].join(", ")
+
+      old_method_source = def_node.slice_lines
+      new_method_source = old_method_source.sub(/def ([a-z_A-Z0-9]+)(\(|$| )/) do
+        is_adding_args = $2.size == 0
+        "def self.#{$1}#{is_adding_args ? "(" : $2}objects, context#{is_adding_args ? ")" : ", "}"
+      end
+
+      old_source_lines = call_node.slice_lines
+      leading_whitespace = old_source_lines[/^\s+/]
+
+      new_method_body = <<~RUBY
+        #{leading_whitespace}requests = objects.map { |object| context.dataloader.with(#{new_source_args}).request_all(#{new_load_arg_s}) }
+        #{leading_whitespace}requests.map! { |reqs| reqs.map!(&:load) } # replace dataloader requests with loaded data
+        #{leading_whitespace}requests
+      RUBY
+
+      new_method_source.sub!(old_source_lines, new_method_body)
+
+      combined_new_source = new_method_source + "\n" + old_method_source
+      @result_source.sub!(old_method_source, combined_new_source)
+    end
+
+    def cleanup(field_definition)
+      remove_resolver_method(field_definition)
+    end
   end
 end

data/lib/graphql_migrate_execution/dataloader_manual.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
+  # These fields use Dataloader in a way that can't be automatically migrated. You'll have to migrate them manually.
+  # If you have a lot of these, consider opening up an issue on GraphQL-Ruby -- maybe we can find a way to programmatically support them.
   class DataloaderManual < Strategy
-    DESCRIPTION = <<~DESC
-    These fields use Dataloader in a way that can't be automatically migrated. You'll have to migrate them manually.
-    If you have a lot of these, consider opening up an issue on GraphQL-Ruby -- maybe we can find a way to programmatically support them.
-    DESC
-
     self.color = :RED
   end
 end

data/lib/graphql_migrate_execution/dataloader_shorthand.rb

@@ -1,25 +1,38 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
+  # These fields can use a `dataload: ...` configuration. They use a single, simple dataloader call:
+  #
+  # - `dataload_assocation(...)`
+  # - `dataload_record(...)`
+  # - `dataload(...)` or `dataloader.with(...).load(...)`
+  #
+  # and they don't make calls on `self` inside those expressions (except for `object` and `context`).
   class DataloaderShorthand < Strategy
-    DESCRIPTION = <<~DESC
-    These fields can use a `dataload: ...` configuration.
-    DESC
     self.color = :GREEN
 
-    def add_future(field_definition, new_source)
+    def migrate(field_definition)
       rm = field_definition.resolver_method
       if (da = rm.dataload_association)
         dataload_config = "{ association: #{da.inspect} }"
+      elsif (dr = rm.dataload_record)
+        dataload_config = "{ model: #{dr}".dup
+        if (dr_using = rm.dataload_record_using)
+          dataload_config << ", using: #{dr_using.inspect}"
+        end
+        if (fb = rm.dataload_record_find_by)
+          dataload_config << ", find_by: #{fb.inspect}"
+        end
+        dataload_config << " }"
       elsif rm.source_arg_nodes.empty?
         dataload_config = rm.source_class_node.full_name
       else
         dataload_config = "{ with: #{rm.source_class_node.full_name}, by: [#{rm.source_arg_nodes.map { |n| Visitor.source_for_constant_node(n) }.join(", ")}] }"
       end
-      inject_field_keyword(new_source, field_definition, :dataload, dataload_config)
+      inject_field_keyword(field_definition, :dataload, dataload_config)
     end
 
-    def remove_legacy(field_definition, new_source)
-      remove_resolver_method(new_source, field_definition)
+    def cleanup(field_definition)
+      remove_resolver_method(field_definition)
     end
   end
 end

data/lib/graphql_migrate_execution/do_nothing.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
+  # These field definitions are already future-compatible. No migration is required.
   class DoNothing < Strategy
-    DESCRIPTION = "These field definitions are already future-compatible. No migration is required."
     self.color = :GREEN
   end
 end

data/lib/graphql_migrate_execution/fallback_value.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  # Turns `fallback_value: ...` into `resolve_static: true`
+  class FallbackValue < Strategy
+    self.color = :GREEN
+
+    def migrate(field_definition)
+      indent = field_definition.node.location.slice_lines[/^ +/]
+      method_name = self.class.prefix_if_necessary(field_definition.name)
+      is_interface = field_definition.type_definition.is_interface
+      new_body = "\n".dup
+
+      if is_interface
+        method_prefix = "def #{method_name}"
+        new_body << "#{indent}resolver_methods do\n"
+        method_indent = indent + "  "
+      else
+        method_prefix = "def self.#{method_name}"
+        method_indent = indent
+      end
+
+      new_body << "#{method_indent}#{method_prefix}(_context)\n"
+      new_body << method_indent + "  #{field_definition.fallback_value}\n"
+      new_body << method_indent + "end"
+
+      if is_interface
+        new_body << "\n#{indent}end"
+      end
+
+      @result_source.sub!(field_definition.source, field_definition.source + "\n" + new_body)
+      keyword_v = method_name == field_definition.name.to_s ? true : method_name.to_sym.inspect
+      inject_field_keyword(field_definition, :resolve_static, keyword_v)
+    end
+
+    def cleanup(field_definition)
+      remove_field_keyword(field_definition, :fallback_value)
+    end
+  end
+end

data/lib/graphql_migrate_execution/field_definition.rb

@@ -12,6 +12,7 @@ module GraphqlMigrateExecution
       @type_instance_method = nil
       @object_direct_method = nil
       @dig = nil
+      @fallback_value = nil
       @already_migrated = nil
 
       @resolver_method = nil
@@ -19,9 +20,23 @@ module GraphqlMigrateExecution
     end
 
     def migration_strategy
+      if unsupported_extras?
+        return UnsupportedExtra
+      elsif resolver_method&.uses_current_path
+        return UnsupportedCurrentPath
+      end
+
+      if @type_definition.is_resolver && @type_definition.returns_hash?
+        return HashKey
+      end
+
       case resolve_mode
       when nil, :implicit_resolve
-        Implicit
+        if @type_definition.migration.implicit == "ignore"
+          DoNothing
+        else
+          Implicit
+        end
       when :hash_key, :object_direct_method, :dig
         DoNothing
       when :already_migrated
@@ -31,7 +46,9 @@ module GraphqlMigrateExecution
         when :resolve_static
           ResolveStatic
         when :resolve_batch
-          NotImplemented
+          ResolveBatch
+        when :resolve_legacy_instance_method
+          DoNothing
         else
           raise ArgumentError, "Unexpected already_migrated: #{@already_migrated.inspect}"
         end
@@ -39,6 +56,8 @@ module GraphqlMigrateExecution
         resolver_method.migration_strategy
       when :resolver
         DoNothing
+      when :fallback_value
+        FallbackValue
       else
         raise "No migration strategy for resolve_mode #{@resolve_mode.inspect}"
       end
@@ -51,13 +70,13 @@ module GraphqlMigrateExecution
     end
 
     def future_resolve_shorthand
-      method_name = resolver_method.name
+      method_name = Strategy.prefix_if_necessary(resolver_method.name).to_sym
       name == method_name ? true : method_name
     end
 
     attr_writer :resolve_mode
 
-    attr_accessor :hash_key, :object_direct_method, :type_instance_method, :resolver, :dig, :already_migrated
+    attr_accessor :hash_key, :object_direct_method, :type_instance_method, :resolver, :dig, :already_migrated, :fallback_value
 
     def path
       @path ||= "#{type_definition.name}.#{@name}"
@@ -95,5 +114,14 @@ module GraphqlMigrateExecution
       end
       nil
     end
+
+    private
+
+    def unsupported_extras?
+      (kwargs = @node.arguments.arguments.last).is_a?(Prism::KeywordHashNode) &&
+        (extras_el = kwargs.elements.find { |el| el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "extras" }) &&
+        ((extras_val = extras_el.value).is_a?(Prism::ArrayNode)) &&
+        (extras_val.elements.any? { |el| (!el.is_a?(Prism::SymbolNode)) || (el.unescaped != "ast_node" && el.unescaped != "lookahead")})
+    end
   end
 end

data/lib/graphql_migrate_execution/hash_key.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  # These can be future-proofed with `hash_key: ...` configurations.
+  class HashKey < Strategy
+    self.color = :GREEN
+
+    def migrate(field_definition)
+      key = field_definition.type_definition.returns_string_hash? ? field_definition.name.to_s.inspect : field_definition.name.inspect
+      inject_field_keyword(field_definition, :hash_key, key)
+    end
+  end
+end

data/lib/graphql_migrate_execution/implicit.rb

@@ -1,13 +1,29 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
+  # These fields use GraphQL-Ruby's default, implicit resolution behavior. It's changing in the future:
+  #  - __Currently__, it tries a combination of method calls and hash key lookups
+  #  - __In the future__, it will only try a method call: `object.public_send(field_name, **field_args)`
+  #
+  # If your field _sometimes_ uses a method call, and other times uses a hash key, you'll have to implement that logic in the field itself
+  #
+  #. If your field always uses a method call, use `--implicit=ignore` to disable the warning from this refactor. (Your field will be supported as-is).
+  #
+  # If your field always uses a hash key, use `--implicit=hash_key` (to add a Symbol-based `hash_key: ...` configuration) or `--implicit=hash_key_string` (to add a String-based one).
   class Implicit < Strategy
-    DESCRIPTION = <<~DESC
-    These fields use GraphQL-Ruby's default, implicit resolution behavior. It's changing in the future, please audit these fields and choose a migration strategy:
-
-      - `--preserve-implicit`: Don't add any new configuration; use GraphQL-Ruby's future direct method send behavior (ie `object.public_send(field_name, **arguments)`)
-      - `--shim-implicit`: Add a method to preserve GraphQL-Ruby's previous dynamic implicit behavior (ie, checking for `respond_to?` and `key?`)
-    DESC
 
     self.color = :YELLOW
+
+    def migrate(field_definition)
+      case @migration.implicit
+      when "ignore", nil
+        # do nothing
+      when "hash_key"
+        inject_field_keyword(field_definition, :hash_key, field_definition.name.inspect)
+      when "hash_key_string"
+        inject_field_keyword(field_definition, :hash_key, field_definition.name.to_s.inspect)
+      else
+        raise ArgumentError, "Unexpected `--implicit` argument: #{@migration.implicit.inspect}"
+      end
+    end
   end
 end

data/lib/graphql_migrate_execution/migration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  # A run of this tool, called by `bin/graphql_migrate_execution`.
+  class Migration
+    def initialize(glob, dry_run: false, migrate: false, cleanup: false, implicit: nil, colorable: IRB::Color.colorable?)
+      @glob = glob
+      if /\/[^.]*$/.match?(@glob)
+        if !@glob.end_with?("/")
+          @glob += "/"
+        end
+        @glob += "*.rb"
+      end
+      @dry_run = dry_run || (migrate == false && cleanup == false)
+      @colorable = colorable
+      @implicit = implicit
+      @action_method = if migrate
+        :migrate
+      elsif cleanup
+        :cleanup
+      else
+        :analyze
+      end
+    end
+
+    attr_reader :colorable, :action_method, :implicit
+
+    def run
+      files = Dir.glob(@glob)
+      if files.size.zero?
+        warn "No files found for #{@glob.inspect}"
+      end
+      files.each do |filepath|
+        source = File.read(filepath)
+        action = Action.new(self, filepath, source)
+        action.run
+
+        if !@dry_run
+          File.write(filepath, action.result_source)
+        end
+
+        puts action.message
+      end
+    end
+  end
+end

data/lib/graphql_migrate_execution/not_implemented.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
+  # GraphQL-Ruby doesn't have a migration strategy for these fields. Automated migration may be possible -- please open an issue on GitHub with the source for these fields to investigate.
   class NotImplemented < Strategy
-    DESCRIPTION = "GraphQL-Ruby doesn't have a migration strategy for these fields. Automated migration may be possible -- please open an issue on GitHub with the source for these fields to investigate."
     self.color = :RED
   end
 end

data/lib/graphql_migrate_execution/resolve_batch.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  # This is just used for cleaning up code.
+  class ResolveBatch < Strategy
+    self.color = :GREEN
+
+    def migrate(field_definition)
+      raise "Not implemented yet -- this doesn't actually migrate code, just cleans up old code."
+    end
+
+    def cleanup(field_definition)
+      remove_field_keyword(field_definition, :resolver_method)
+      remove_resolver_method(field_definition)
+    end
+  end
+end

data/lib/graphql_migrate_execution/resolve_each.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
+  # These can be converted with `resolve_each:`. Dataloader was not detected in these resolver methods.
   class ResolveEach < Strategy
-    DESCRIPTION = "These can be converted with `resolve_each:`. Dataloader was not detected in these resolver methods."
     self.color = :GREEN
 
-    def add_future(field_definition, new_source)
-      inject_resolve_keyword(new_source, field_definition, :resolve_each)
-      replace_resolver_method(new_source, field_definition, "object, context")
+    def migrate(field_definition)
+      inject_resolve_keyword(field_definition, :resolve_each)
+      replace_resolver_method(field_definition, "object, context")
     end
 
-    def remove_legacy(field_definition, new_source)
-      remove_field_keyword(new_source, field_definition, :resolver_method)
-      remove_resolver_method(new_source, field_definition)
+    def cleanup(field_definition)
+      remove_field_keyword(field_definition, :resolver_method)
+      remove_resolver_method(field_definition)
     end
   end
 end

data/lib/graphql_migrate_execution/resolve_static.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
+  # These can be converted with `resolve_static:`. Dataloader was not detected in these resolver methods.
   class ResolveStatic < Strategy
-    DESCRIPTION = "These can be converted with `resolve_static:`. Dataloader was not detected in these resolver methods."
     self.color = :GREEN
 
-    def add_future(field_definition, new_source)
-      inject_resolve_keyword(new_source, field_definition, :resolve_static)
-      replace_resolver_method(new_source, field_definition, "context")
+    def migrate(field_definition)
+      inject_resolve_keyword(field_definition, :resolve_static)
+      replace_resolver_method(field_definition, "context")
     end
 
-    def remove_legacy(field_definition, new_source)
-      remove_field_keyword(new_source, field_definition, :resolver_method)
-      remove_resolver_method(new_source, field_definition)
+    def cleanup(field_definition)
+      remove_field_keyword(field_definition, :resolver_method)
+      remove_field_keyword(field_definition, :fallback_value)
+      remove_resolver_method(field_definition)
     end
   end
 end