graphql_migrate_execution 0.0.1 → 1.0.0

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.1"
+  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.1
+  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
@@ -82,29 +82,33 @@ dependencies:
 description: A development script for migrating to GraphQL-Ruby's new runtime engine
 email:
 - rdmosolgo@gmail.com
-executables: []
+executables:
+- graphql_migrate_execution
 extensions: []
 extra_rdoc_files: []
 files:
 - MIT-LICENSE
+- 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
@@ -113,9 +117,9 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://graphql-ruby.org
-  changelog_uri: https://github.com/rmosolgo/graphql-ruby/blob/master/CHANGELOG.md
-  source_code_uri: https://github.com/rmosolgo/graphql-ruby
-  bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
+  changelog_uri: https://github.com/rmosolgo/graphql_migrate_execution
+  source_code_uri: https://github.com/rmosolgo/graphql_migrate_execution
+  bug_tracker_uri: https://github.com/rmosolgo/graphql_migrate_execution/issues
   mailing_list_uri: https://buttondown.email/graphql-ruby
   rubygems_mfa_required: 'true'
 rdoc_options: []