graphql_migrate_execution 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fbd874076a766e4abf14571cc0d4d9a348f5868f89df74f9e0f2ad421e65fd4
-  data.tar.gz: 013e06b1123c06b80d9fd2e270ace5032890c8d35cb8bac8f91e78e8805755ac
+  metadata.gz: 2835acca245bcfe0c626420ae2ce5ac96ee916e0a4dbb35a8db5f1c97a786e1b
+  data.tar.gz: 4522d268937cf7a4fd925b4cf0a8fb492ec797006cf48e9972ae74847390eb21
 SHA512:
-  metadata.gz: 24a586f44159ceac3d674171cbc25d31c342c7238f6d025954f833e6000231a61893c04bdac741df32e5e90c9f30dd22976069eca8c7af66a8c0b1571fc4c6f9
-  data.tar.gz: fc25e0c9baf95aed3104802604bbd8aba57cd528dd136c912f5f459c973f08f1b510623b13b9a7abcae272ce98c834572ca64b4391841b184c6810e19d99ecc6
+  metadata.gz: ad8ba9248a12a116f6e6170fbae55029914bd43b71e2aefcab54c85b87af4347e19cc3aa6a0ba87a9df2a1d7caf7594f901ae974e88208c82e473adc61378e3e
+  data.tar.gz: 128a44c801b750c31ad661af93745568a529389afb9fd738534125aba4a708d7c9ab7293b0e02cde6453473486763a09561e16892ac75c93fc39e91659e67672

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,9 +48,9 @@ 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
       else
         raise ArgumentError, "Failed to transform Dataloader argument: #{old_load_arg_s.inspect}"
@@ -49,11 +69,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/field_definition.rb

@@ -19,9 +19,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 +45,7 @@ module GraphqlMigrateExecution
         when :resolve_static
           ResolveStatic
         when :resolve_batch
-          NotImplemented
+          ResolveBatch
         else
           raise ArgumentError, "Unexpected already_migrated: #{@already_migrated.inspect}"
         end
@@ -95,5 +109,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,41 @@
+# 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
+      Dir.glob(@glob).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,17 @@
 # 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_resolver_method(field_definition)
     end
   end
 end

data/lib/graphql_migrate_execution/resolver_method.rb

@@ -15,13 +15,19 @@ module GraphqlMigrateExecution
       @calls_class = false
       @calls_dataloader = false
       @dataloader_call = false
+      @uses_current_path = false
+      @dataload_association = nil
+      @dataload_record = nil
+      @dataload_record_using = nil
+      @dataload_record_find_by = nil
+      @return_expressions = nil
     end
 
     attr_reader :name, :node, :parameter_names, :self_sends
 
-    attr_reader :source_class_node, :source_arg_nodes, :load_arg_node, :dataload_association
+    attr_reader :source_class_node, :source_arg_nodes, :load_arg_node, :dataload_association, :dataload_record, :dataload_record_using, :dataload_record_find_by
 
-    attr_accessor :calls_object, :calls_context, :calls_class, :calls_dataloader
+    attr_accessor :calls_object, :calls_context, :calls_class, :calls_dataloader, :uses_current_path
 
     attr_accessor :dataloader_call
 
@@ -42,6 +48,7 @@ module GraphqlMigrateExecution
       calls_to_self.delete(:dataload_association)
       calls_to_self.delete(:dataload_record)
       calls_to_self.delete(:dataload)
+      calls_to_self.delete(:dataload_all)
 
       # Global-ish methods:
       calls_to_self.delete(:raise)
@@ -67,6 +74,22 @@ module GraphqlMigrateExecution
               assoc_sym = assoc_arg.unescaped.to_sym
               @dataload_association = assoc_sym == name ? true : assoc_sym
             end
+          when :dataload_record
+            if (record_args = call_node.arguments.arguments) &&
+                (record_arg = record_args.first) &&
+                (record_arg.is_a?(Prism::ConstantReadNode) || record_arg.is_a?(Prism::ConstantPathNode)) &&
+                (using_arg = record_args[1]) &&
+                # Must be `object.{something}`
+                (using_arg.is_a?(Prism::CallNode)) &&
+                (using_arg.receiver.is_a?(Prism::CallNode) && using_arg.receiver.name == :object)
+              @dataload_record = record_arg.full_name
+              @dataload_record_using = using_arg.name
+
+              if (kwargs = record_args.last).is_a?(Prism::KeywordHashNode) && (find_by_kwarg = kwargs.elements.find { |el| el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "find_by" })
+                find_by_node = find_by_kwarg.value
+                @dataload_record_find_by = find_by_node.unescaped.to_sym # Assumes a SymbolNode
+              end
+            end
           else
             if (source_call = call_node.receiver) # eg dataloader.with(...).load(...)
               @source_class_node = source_call.arguments.arguments.first
@@ -78,15 +101,16 @@ module GraphqlMigrateExecution
           input_is_object = @load_arg_node.is_a?(Prism::CallNode) && @load_arg_node.name == :object
           # Guess whether these args are free of runtime context:
           shortcutable_source_args = @source_arg_nodes && (@source_arg_nodes.empty? || (@source_arg_nodes.all? { |a| Visitor.constant_node?(a) }))
-          if @source_class_node.is_a?(Prism::ConstantPathNode) && shortcutable_source_args && input_is_object
+          source_ref_is_constant = @source_class_node.is_a?(Prism::ConstantPathNode) || @source_class_node.is_a?(Prism::ConstantReadNode)
+          if source_ref_is_constant && shortcutable_source_args && input_is_object
             DataloaderShorthand
           else
             case call_node.name
             when :load, :request, :dataload
               DataloaderAll
-            when :load_all, :request_all, :dataload_record
+            when :load_all, :request_all, :dataload_all
               DataloaderBatch
-            when :dataload_association
+            when :dataload_association, :dataload_record
               DataloaderShorthand
             else
               DataloaderManual
@@ -101,5 +125,56 @@ module GraphqlMigrateExecution
         NotImplemented
       end
     end
+
+    def returns_hash?
+      return_expressions.all? { |exp_node| exp_node.is_a?(Prism::HashNode) || (exp_node.is_a?(Prism::CallNode) && exp_node.name == :new && exp_node.receiver.is_a?(Prism::ConstantReadNode) && exp_node.receiver.name == :Hash) }
+    end
+
+    def return_expressions
+      if @return_expressions.nil?
+        @return_expressions = []
+        find_return_expressions(@node)
+      end
+      @return_expressions
+    end
+
+    def returns_string_hash?
+      return_expressions.any? { |exp_node| exp_node.is_a?(Prism::HashNode) && exp_node.elements.all? { |el| el.key.is_a?(Prism::StringNode) } }
+    end
+
+    private
+
+    def find_return_expressions(node)
+      case node
+      when Prism::DefNode
+        find_return_expressions(node.body)
+      when Prism::StatementsNode
+        find_return_expressions(node.body.last)
+      when Prism::IfNode # TODO else, `?`, case
+        find_return_expressions(node.statements)
+        find_return_expressions(node.subsequent)
+      when Prism::ElseNode, Prism::WhenNode
+        find_return_expressions(node.statements)
+      when Prism::UnlessNode
+        find_return_expressions(node.statements)
+        find_return_expressions(node.else_clause)
+      when Prism::CaseNode
+        node.conditions.each do |cond_node|
+          find_return_expressions(cond_node)
+        end
+      when Prism::ReturnNode
+        find_return_expressions(node.arguments.first)
+      when Prism::LocalVariableReadNode
+        if (lv_write_node = @node.body.body.find { |n| n.is_a?(Prism::LocalVariableWriteNode) && n.name == node.name })
+          find_return_expressions(lv_write_node.value)
+        else
+          # Couldn't find assignment :'(
+          @return_expressions << node
+        end
+      else
+        # This is an expression that produces a return value
+        @return_expressions << node
+      end
+    end
   end
 end

data/lib/graphql_migrate_execution/strategy.rb

@@ -1,10 +1,51 @@
 # frozen_string_literal: true
+require_relative "./action"
+
 module GraphqlMigrateExecution
   class Strategy
-    def add_future(field_definition, new_source)
+    include Action::Colorize
+    def initialize(action, field_definitions)
+      @action = action
+      @migration = action.migration
+      @filepath = action.filepath
+      @action_method = @migration.action_method
+      @message = action.message
+      @result_source = action.result_source
+      @field_definitions = field_definitions
+    end
+
+    def migrate(field_definition)
+    end
+
+    def cleanup(field_definition)
+    end
+
+    def run
+      case @action_method
+      when :analyze
+        @message << "\n#{colorize("#{colorize(self.class.strategy_name, self.class.color)} (#{@field_definitions.size})", :BOLD)}:\n"
+        max_path = @field_definitions.map { |f| f.path.size }.max + 2
+        @field_definitions.each do |field_defn|
+          name = field_defn.path.ljust(max_path)
+          @message << "\n  - #{name} (#{field_defn.resolve_mode.inspect} -> #{field_defn.resolve_mode_key.inspect}) @ #{@filepath}:#{field_defn.source_line}"
+        end
+        @message << "\n"
+      when :migrate,  :cleanup
+        indent_size = @action.strategy_name_padding + 1
+        indent = " " * indent_size
+        indent2_size = @action.field_name_padding
+        @message << "\n#{colorize(self.class.strategy_name.ljust(indent_size), self.class.color)}"
+        first = true
+        @field_definitions.each do |field_defn|
+          @message << "#{first ? "" : "#{indent}"}#{field_defn.path.ljust(indent2_size)}  @ #{@filepath}:#{field_defn.source_line}\n"
+          first = false
+          public_send(@action_method, field_defn)
+        end
+      end
     end
 
-    def remove_legacy(field_definition, new_source)
+    def self.strategy_name
+      name.split("::").last
     end
 
     class << self
@@ -13,29 +54,36 @@ module GraphqlMigrateExecution
 
     private
 
-    def inject_resolve_keyword(new_source, field_definition, keyword)
+    def inject_resolve_keyword(field_definition, keyword)
       value = field_definition.future_resolve_shorthand.inspect
-      inject_field_keyword(new_source, field_definition, keyword, value)
+      inject_field_keyword(field_definition, keyword, value)
     end
 
-    def inject_field_keyword(new_source, field_definition, keyword, value)
+    def inject_field_keyword(field_definition, keyword, value)
       field_definition_source = field_definition.source
-      new_definition_source = if field_definition_source[/ [a-z_]+:/] # Does it already have keywords?
-        field_definition_source.sub(/(field.+?)((?: do)|(?: {)|$)/, "\\1, #{keyword}: #{value}\\2")
+      pair = "#{keyword}: #{value}"
+      if field_definition_source.include?(pair)
+        # Pass, don't re-add it
+      elsif field_definition_source.include?("#{keyword}:")
+        raise "Can't re-inject #{keyword} because it's already present in the definition:\n\n#{field_definition_source}"
       else
-        field_definition_source + ", #{keyword}: #{value}"
+        new_definition_source = if field_definition_source[/ [a-z_]+:/] # Does it already have keywords?
+          field_definition_source.sub(/(field.+?)((?: do)|(?: {)|$)/, "\\1, #{pair}\\2")
+        else
+          field_definition_source + ", #{pair}"
+        end
+        @result_source.sub!(field_definition_source, new_definition_source)
       end
-      new_source.sub!(field_definition_source, new_definition_source)
     end
 
 
-    def remove_field_keyword(new_source, field_definition, keyword)
+    def remove_field_keyword(field_definition, keyword)
       field_definition_source = field_definition.source
       new_definition_source = field_definition_source.sub(/, #{keyword}: \S+(,|$)/, "\\1")
-      new_source.sub!(field_definition_source, new_definition_source)
+      @result_source.sub!(field_definition_source, new_definition_source)
     end
 
-    def replace_resolver_method(new_source, field_definition, new_params)
+    def replace_resolver_method(field_definition, new_params)
       resolver_method = field_definition.resolver_method
       method_name = resolver_method.name
       old_method = resolver_method.source
@@ -53,12 +101,12 @@ module GraphqlMigrateExecution
       new_inst_method = [old_lines.first, new_body, old_lines.last].join("\n")
 
       new_double_definition = new_class_method + "\n" + new_inst_method + "\n"
-      new_source.sub!(old_method, new_double_definition)
+      @result_source.sub!(old_method, new_double_definition)
     end
 
-    def remove_resolver_method(new_source, field_definition)
+    def remove_resolver_method(field_definition)
       src_pattern = /(\n*)(#{Regexp.quote(field_definition.resolver_method.source)})(\n*)/
-      new_source.sub!(src_pattern) do
+      @result_source.sub!(src_pattern) do
         # $2 includes a newline, too
         "#{$1.length > 1 ? "\n" : ""}#{$3.length > 0 ? "\n" : ""}"
       end

data/lib/graphql_migrate_execution/type_definition.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
   class TypeDefinition
-    def initialize(name)
+    def initialize(name, migration)
       @name = name
+      @migration = migration
       @field_definitions = {}
       @resolver_methods = {}
+      @is_resolver = false
     end
 
+    attr_accessor :is_resolver, :migration
+
     attr_reader :resolver_methods, :name, :field_definitions
 
     def field_definition(name, node)
@@ -16,5 +20,13 @@ module GraphqlMigrateExecution
     def resolver_method(name, node)
       @resolver_methods[name] = ResolverMethod.new(name, node)
     end
+
+    def returns_hash?
+      @resolver_methods.each_value.first.returns_hash?
+    end
+
+    def returns_string_hash?
+      @resolver_methods.each_value.first.returns_string_hash?
+    end
   end
 end

data/lib/graphql_migrate_execution/unsupported_current_path.rb

@@ -0,0 +1,8 @@
+module GraphqlMigrateExecution
+  # These use `context[:current_path]` or `context.current_path` which isn't supported. Refactor these fields then try migrating again.
+  #
+  # Open an issue on GraphQL-Ruby's GitHub repo to discuss further.
+  class UnsupportedCurrentPath < Strategy
+    self.color = :RED
+  end
+end

data/lib/graphql_migrate_execution/unsupported_extra.rb

@@ -0,0 +1,8 @@
+module GraphqlMigrateExecution
+  # These use a field `extra` which isn't supported. Remove this configuration and refactor the field, then try migrating again.
+  #
+  # (Currently, only `:ast_node` and `:lookahead` are currently supported. Please open an issue on GraphQL-Ruby if this is a problem for you.)
+  class UnsupportedExtra < Strategy
+    self.color = :RED
+  end
+end

data/lib/graphql_migrate_execution/version.rb

@@ -1,3 +1,3 @@
 module GraphqlMigrateExecution
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/lib/graphql_migrate_execution/visitor.rb

@@ -7,6 +7,7 @@ module GraphqlMigrateExecution
       @type_definition_stack = []
       @current_field_definition = nil
       @current_resolver_method = nil
+      @is_public = true
     end
 
     def visit_class_node(node)
@@ -73,6 +74,10 @@ module GraphqlMigrateExecution
         else
           warn "GraphQL-Ruby warning: Skipping unrecognized field definition: #{node.inspect}"
         end
+      elsif node.receiver.nil? && ((node.name == :private) || (node.name == :protected))
+        @is_public = false
+      elsif node.receiver.nil? && node.name == :public
+        @is_public = true
       elsif @current_resolver_method
         if node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
           @current_resolver_method.self_sends.add(node.name)
@@ -89,6 +94,15 @@ module GraphqlMigrateExecution
         case node.name
         when :dataloader, :dataload, :dataload_association, :dataload_record, :dataload_all
           @current_resolver_method.calls_dataloader = true
+        when :current_path
+          if node.receiver.is_a?(Prism::CallNode) && node.receiver.name == :context
+            @current_resolver_method.uses_current_path = true
+          end
+        when :[]
+          if node.receiver.is_a?(Prism::CallNode) && node.receiver.name == :context &&
+              (arg = node.arguments.arguments.first).is_a?(Prism::SymbolNode) && (arg.unescaped == "current_path")
+            @current_resolver_method.uses_current_path = true
+          end
         end
       end
       super
@@ -99,22 +113,30 @@ module GraphqlMigrateExecution
     end
 
     def visit_def_node(node)
-      if node.receiver.nil?
+      if @is_public
         td = @type_definition_stack.last
-        @current_resolver_method = td.resolver_method(node.name, node)
-      end
+        if node.receiver.nil?
+          @current_resolver_method = td.resolver_method(node.name, node)
+        end
 
-      body = node.body.body
-      if body.length == 1 && (call_node = body.first).is_a?(Prism::CallNode)
-        case call_node.name
-        when :load, :request, :load_all, :request_all
-          if (call_node2 = call_node.receiver).is_a?(Prism::CallNode) && call_node2.name == :with
+        if node.name == :resolve && td.resolver_methods.size == 1
+          td.is_resolver = true
+        elsif td.is_resolver && td.remove_resolver_methods.size > 1
+          td.is_resolver = false
+        end
+
+        body = node.body.body
+        if @current_resolver_method && body.length == 1 && (call_node = body.first).is_a?(Prism::CallNode)
+          case call_node.name
+          when :load, :request, :load_all, :request_all
+            if (call_node2 = call_node.receiver).is_a?(Prism::CallNode) && call_node2.name == :with
+              @current_resolver_method.dataloader_call = true
+            end
+          when :dataload_record, :dataload_association, :dataload, :dataload_all
             @current_resolver_method.dataloader_call = true
+          else
+            # not a single dataloader call
           end
-        when :dataload_record, :dataload_association, :dataload
-          @current_resolver_method.dataloader_call = true
-        else
-          # not a single dataloader call
         end
       end
       super

data/lib/graphql_migrate_execution.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
+require "prism"
 require "graphql_migrate_execution/action"
-require "graphql_migrate_execution/add_future"
-require "graphql_migrate_execution/remove_legacy"
-require "graphql_migrate_execution/analyze"
+require "graphql_migrate_execution/migration"
 require "graphql_migrate_execution/field_definition"
 require "graphql_migrate_execution/resolver_method"
 require "graphql_migrate_execution/type_definition"
@@ -10,6 +9,7 @@ require "graphql_migrate_execution/visitor"
 require "graphql_migrate_execution/strategy"
 require "graphql_migrate_execution/implicit"
 require "graphql_migrate_execution/do_nothing"
+require "graphql_migrate_execution/resolve_batch"
 require "graphql_migrate_execution/resolve_each"
 require "graphql_migrate_execution/resolve_static"
 require "graphql_migrate_execution/not_implemented"
@@ -17,35 +17,11 @@ require "graphql_migrate_execution/dataloader_all"
 require "graphql_migrate_execution/dataloader_batch"
 require "graphql_migrate_execution/dataloader_manual"
 require "graphql_migrate_execution/dataloader_shorthand"
+require "graphql_migrate_execution/hash_key"
+require "graphql_migrate_execution/unsupported_extra"
+require "graphql_migrate_execution/unsupported_current_path"
 require "graphql_migrate_execution/not_implemented"
 require "irb"
 
 module GraphqlMigrateExecution
-  class Migration
-    def initialize(glob, concise: false, migrate: false, cleanup: false, only: nil, implicit: nil, colorable: IRB::Color.colorable?)
-      @glob = glob
-      @skip_description = concise
-      @colorable = colorable
-      @only = only
-      @implicit = implicit
-      @action_class = if migrate
-        AddFuture
-      elsif cleanup
-        RemoveLegacy
-      else
-        Analyze
-      end
-    end
-
-    attr_reader :skip_description, :colorable
-
-
-    def run
-      Dir.glob(@glob).each do |filepath|
-        source = File.read(filepath)
-        file_migrate = @action_class.new(self, filepath, source)
-        puts file_migrate.run
-      end
-    end
-  end
 end

data/readme.md

@@ -25,15 +25,165 @@ Inspect the files matched by `glob` and ...
 
 Options:
 
-        --migrate                    Update the files with future-compatibile configuration
+        --migrate                    Update the files with future-compatible configuration
         --cleanup                    Remove resolver instance methods for GraphQL-Ruby's old runtime
-        --concise                    Don't print migration strategy descriptions
-        --implicit MODE              Handle implicit field resolution using MODE
-        --only PATTERN               Only analyze or update fields whose path (`Type.field`) matches /PATTERN/
+        --dry-run                    Don't actually modify files
+        --implicit [MODE]            Handle implicit field resolution this way (ignore / hash_key / hash_key_string)
 ```
 
+## Supported Field Resolution Patterns
+
+Check out the docs for refactors implemented by this tool:
+
+- Dataloader-based fields:
+  - [`DataloaderShorthand`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/DataloaderShorthand.html): use the new `dataload: ...` field configuration shorthand
+  - [`DataloaderAll`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/DataloaderAll.html): use a `dataload_all(...)` call to fetch data for a batch of objects
+  - [`DataloaderBatch`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/DataloaderBatch.html): Fetch a list of results _for each object_ (2-layer list)
+  - [`DataloaderManual`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/DataloaderManual.html): 💔 Identifies dataloader usage which can't be migrated
+- Migrate method:
+  - These identify Ruby code in the method which only uses `context` and `object` and migrates it to a suitable class method. Then, it updates the instance method to call the new class method and adds the suitable future-compatible config.
+  - [`ResolveBatch`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/ResolveBatch.html)
+  - [`ResolveEach`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/ResolveEach.html)
+  - [`ResolveStatic`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/ResolveStatic.html)
+- 💔 Not migratable:
+  - [`NotImplemented`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/NotImplemented.html): This field couldn't be matched to a refactor
+  - [`UnsupportedCurrentPath`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/UnsupportedCurrentPath.html): uses `context[:current_path]` which isn't supported anymore - [`UnsupportedExtra`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/UnsupportedExtra.html): as at least one `extras: ...` configuration which isn't supported anymore
+- Configuration:
+  - [`DoNothing`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/DoNothing.html): Already includes future-compatible configuration
+  - [`HashKey`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/HashKey.html): Can be migrated using `hash_key:` (especially useful for Resolvers and Mutations)
+  - [`Implicit`](https://rmosolgo.github.io/graphql_migrate_execution/GraphqlMigrateExecution/Implicit.html): ⚠️ GraphQL-Ruby's default field resolution is changing, see the doc
+
+## Unsupported Field Resolution Patterns
+
+Here are a few fields in my app that this tool didn't handle automatically, along with my manual migrations:
+
+- __Working with a dataloaded value__:
+
+  This resolver called arbitrary code _after_ using Dataloader:
+
+  ```ruby
+  field :is_locked_to_viewer, Boolean, null: false
+
+  def is_locked_to_viewer
+    status = dataload(Sources::GrowthTaskStatusForUserSource, context[:current_user], object)
+    status == :LOCKED
+  end
+  ```
+
+  I _could_ have handled this by refactoring the dataload call to return `true|false`. Then it could have been auto-migrated. Instead, I migrated it like this:
+
+  ```ruby
+  field :is_locked_to_viewer, Boolean, null: false, resolve_batch: true
+
+  def self.is_locked_to_viewer(objects, context)
+    statuses = context.dataload_all(Sources::GrowthTaskStatusForUserSource, context[:current_user], objects)
+    statuses.map { |s| s == :LOCKED }
+  end
+
+  def is_locked_to_viewer
+    self.class.is_locked_to_viewer([ object ], context).first
+  end
+  ```
+
+- __Conditional dataloader call__:
+
+  This field only called dataloader in some cases:
+
+  ```ruby
+  field :viewer_growth_task_submission, GrowthTaskSubmissionType
+
+  def viewer_growth_task_submission
+    if object.frequency.present?
+      # TODO should not include a recurring submission whose duration has passed
+      nil
+    else
+      context.dataloader.with(Sources::GrowthTaskForViewerSource, context[:current_user]).request(object.id)
+    end
+  end
+  ```
+
+  It _could_ have been auto-migrated if I made two refactors:
+
+  - Update the Source to receive `object` instead of `object.id`
+  - Update the Source's `#fetch` to return `nil` based on `object.frequency.present?`
+
+  But I didn't do that. Instead, I migrated it manually:
+
+  ```ruby
+  field :viewer_growth_task_submission, GrowthTaskSubmissionType, resolve_batch: true
+
+  def self.viewer_growth_task_submission(objects, context)
+    requests = objects.map do |object|
+      if object.frequency.present?
+        # TODO should not include a recurring submission whose duration has passed
+        nil
+      else
+        context.dataloader.with(Sources::GrowthTaskForViewerSource, context[:current_user]).request(object.id)
+      end
+    end
+    requests.map { |l| l&.load }
+  end
+
+  def viewer_growth_task_submission
+    self.class.viewer_growth_task_submission([ object ], context).first
+  end
+  ```
+
+- __Resolver that calls another resolver:__
+
+  The tool just gives up when it sees calls on `self`. It didn't handle this:
+
+  ```ruby
+  field :current_user, Types::UserType
+
+  def current_user
+    context[:current_user]
+  end
+
+  field :unread_notification_count, Integer, null: false
+
+  def unread_notification_count
+    # vvvvvvvvv Calls the resolver method above
+    current_user ? current_user.notification_events.unread.count : 0
+  end
+  ```
+
+  I migrated it manually:
+
+  ```ruby
+  field :unread_notification_count, Integer, null: false, resolve_static: true
+
+  def self.unread_notification_count(context)
+    if (cu = current_user(context))
+      cu.notification_events.unread.count
+    else
+      0
+    end
+  end
+
+  def unread_notification_count
+    self.class.unread_notification_count(context)
+  end
+  ```
+
+- __Single-line method definition__:
+
+  The tool's heavy-handed Ruby source generation botched this:
+
+  ```ruby
+  field :growth_levels, Types::GrowthLevelType.connection_type, null: false, resolve_each: true
+  def growth_levels; object.growth_levels.by_sequence; end;
+  ```
+
+  This tool could be improved to properly handle single-line methods -- open an issue if you need this.
+
 ## Develop
 
 ```
 bundle exec rake test # TEST=test/...
 ```
+
+
+## TODO
+
+- [ ] Does `--cleanup` work on my app? I haven't run it yet.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql_migrate_execution
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-03-13 00:00:00.000000000 Z
+date: 2026-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -91,22 +91,24 @@ files:
 - bin/graphql_migrate_execution
 - lib/graphql_migrate_execution.rb
 - lib/graphql_migrate_execution/action.rb
-- lib/graphql_migrate_execution/add_future.rb
-- lib/graphql_migrate_execution/analyze.rb
 - lib/graphql_migrate_execution/dataloader_all.rb
 - lib/graphql_migrate_execution/dataloader_batch.rb
 - lib/graphql_migrate_execution/dataloader_manual.rb
 - lib/graphql_migrate_execution/dataloader_shorthand.rb
 - lib/graphql_migrate_execution/do_nothing.rb
 - lib/graphql_migrate_execution/field_definition.rb
+- lib/graphql_migrate_execution/hash_key.rb
 - lib/graphql_migrate_execution/implicit.rb
+- lib/graphql_migrate_execution/migration.rb
 - lib/graphql_migrate_execution/not_implemented.rb
-- lib/graphql_migrate_execution/remove_legacy.rb
+- lib/graphql_migrate_execution/resolve_batch.rb
 - lib/graphql_migrate_execution/resolve_each.rb
 - lib/graphql_migrate_execution/resolve_static.rb
 - lib/graphql_migrate_execution/resolver_method.rb
 - lib/graphql_migrate_execution/strategy.rb
 - lib/graphql_migrate_execution/type_definition.rb
+- lib/graphql_migrate_execution/unsupported_current_path.rb
+- lib/graphql_migrate_execution/unsupported_extra.rb
 - lib/graphql_migrate_execution/version.rb
 - lib/graphql_migrate_execution/visitor.rb
 - readme.md

data/lib/graphql_migrate_execution/add_future.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module GraphqlMigrateExecution
-  class AddFuture < Action
-    def run
-      super
-      call_method_on_strategy(:add_future)
-    end
-  end
-end

data/lib/graphql_migrate_execution/analyze.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-require "irb"
-module GraphqlMigrateExecution
-  class Analyze < Action
-    def run
-      super
-      message = "Found #{@total_field_definitions} field definitions:".dup
-
-      @field_definitions_by_strategy.each do |strategy_class, definitions|
-        message << "\n\n#{color("#{color(strategy_class.name.split("::").last, strategy_class.color)} (#{definitions.size})", :BOLD)}:\n"
-        if !@migration.skip_description
-          message << "\n#{strategy_class::DESCRIPTION.split("\n").map { |l| l.length > 0 ? "  #{l}" : l }.join("\n")}\n"
-        end
-        max_path = definitions.map { |f| f.path.size }.max + 2
-        definitions.each do |field_defn|
-          name = field_defn.path.ljust(max_path)
-          message << "\n  - #{name} (#{field_defn.resolve_mode.inspect} -> #{field_defn.resolve_mode_key.inspect}) @ #{@path}:#{field_defn.source_line}"
-        end
-      end
-
-      message
-    end
-
-    private
-
-    def color(str, color_or_colors)
-      IRB::Color.colorize(str, Array(color_or_colors), colorable: @migration.colorable)
-    end
-  end
-end

data/lib/graphql_migrate_execution/remove_legacy.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module GraphqlMigrateExecution
-  class RemoveLegacy < Action
-    def run
-      super
-      call_method_on_strategy(:remove_legacy)
-    end
-  end
-end