graphql_migrate_execution 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0f6058451a84d02d1fa53a18b8efcd287b31447eb9dade84f04d5ffc84d10d8e
+  data.tar.gz: dcf635144c19e61ac91bb1f0306db57be16bbbb5574e00f7eaa8463692f3ced0
+SHA512:
+  metadata.gz: edc61bb290ed152c015678797cf66a4f3356476e71c3c3a2a5be507f410dc02bd625f795b6dc91574d3815110e7da49214e062503d0f9e522c64aa3caf43827f
+  data.tar.gz: aa765c1ddb59287f57a71d2a06b4e73e819088d95f5849aa52d68c53212cc806e41bd3e097ac3e3bcebe058730380e2e737f2a469e7d7b82a3e2fb0fcd925292

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2026 Robert Mosolgo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/graphql_migrate_execution/action.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  class Action
+    def initialize(migration, path, 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
+    end
+
+    attr_reader :type_definitions
+
+    def run
+      parse_result = Prism.parse(@source, filepath: @path)
+      visitor = Visitor.new(@source, @type_definitions)
+      visitor.visit(parse_result.value)
+      @type_definitions.each do |name, type_defn|
+        type_defn.field_definitions.each do |f_name, f_defn|
+          @total_field_definitions += 1
+          f_defn.check_for_resolver_method
+          @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
+      end
+      new_source
+    end
+  end
+end

data/lib/graphql_migrate_execution/add_future.rb

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,30 @@
+# 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/dataloader_all.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  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_node = field_definition.resolver_method.node
+      call_node = def_node.body.body.first
+      case call_node.name
+      when :request, :load
+        load_arg_node = call_node.arguments.arguments.first
+        with_node = call_node.receiver
+        source_class_node, *source_args_nodes = with_node.arguments
+      when :dataload
+        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"
+        "objects"
+      when /object((\.|\[)[:a-zA-Z0-9_\.\"\'\[\]]+)/
+        call_chain = $1
+        if /^\.[a-z0-9_A-Z]+$/.match?(call_chain)
+          "objects.map(&:#{call_chain[1..-1]})"
+        else
+          "objects.map { |obj| obj#{call_chain} }"
+        end
+      else
+        raise ArgumentError, "Failed to transform Dataloader argument: #{old_load_arg_s.inspect}"
+      end
+      new_args = [
+        source_class_node.slice,
+        *source_args_nodes.map(&:slice),
+        new_load_arg_s
+      ].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
+      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)
+    end
+  end
+end

data/lib/graphql_migrate_execution/dataloader_batch.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  class DataloaderBatch < Strategy
+    DESCRIPTION = <<~DESC
+    These fields can be rewritten to dataload in a `resolve_batch:` method.
+    DESC
+  end
+end

data/lib/graphql_migrate_execution/dataloader_manual.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  class DataloaderShorthand < Strategy
+    DESCRIPTION = <<~DESC
+    These fields can use a `dataload: ...` configuration.
+    DESC
+    self.color = :GREEN
+
+    def add_future(field_definition, new_source)
+      rm = field_definition.resolver_method
+      if (da = rm.dataload_association)
+        dataload_config = "{ association: #{da.inspect} }"
+      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)
+    end
+
+    def remove_legacy(field_definition, new_source)
+      remove_resolver_method(new_source, field_definition)
+    end
+  end
+end

data/lib/graphql_migrate_execution/do_nothing.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  class FieldDefinition
+    def initialize(type_definition, name, node)
+      @type_definition = type_definition
+      @name = name.to_sym
+      @node = node
+
+      @resolve_mode = nil
+      @hash_key = nil
+      @resolver = nil
+      @type_instance_method = nil
+      @object_direct_method = nil
+      @dig = nil
+      @already_migrated = nil
+
+      @resolver_method = nil
+      @unknown_options = []
+    end
+
+    def migration_strategy
+      case resolve_mode
+      when nil, :implicit_resolve
+        Implicit
+      when :hash_key, :object_direct_method, :dig
+        DoNothing
+      when :already_migrated
+        case @already_migrated.keys.first
+        when :resolve_each
+          ResolveEach
+        when :resolve_static
+          ResolveStatic
+        when :resolve_batch
+          NotImplemented
+        else
+          raise ArgumentError, "Unexpected already_migrated: #{@already_migrated.inspect}"
+        end
+      when :type_instance_method
+        resolver_method.migration_strategy
+      when :resolver
+        DoNothing
+      else
+        raise "No migration strategy for resolve_mode #{@resolve_mode.inspect}"
+      end
+    end
+
+    attr_reader :name, :node, :unknown_options, :type_definition, :resolve_mode
+
+    def source
+      node.location.slice
+    end
+
+    def future_resolve_shorthand
+      method_name = resolver_method.name
+      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
+
+    def path
+      @path ||= "#{type_definition.name}.#{@name}"
+    end
+
+    def source_line
+      @node.location.start_line
+    end
+
+    def resolver_method
+      case @resolver_method
+      when nil
+        method_name = @type_instance_method || @name
+        @resolver_method = @type_definition.resolver_methods[method_name] || :NOT_FOUND
+        resolver_method
+      when :NOT_FOUND
+        nil
+      else
+        @resolver_method
+      end
+    end
+
+    def implicit_resolve
+      @name
+    end
+
+    def resolve_mode_key
+      resolve_mode && public_send(resolve_mode)
+    end
+
+    def check_for_resolver_method
+      if resolve_mode.nil? && (resolver_method)
+        @resolve_mode = :type_instance_method
+        @type_instance_method = @name
+      end
+      nil
+    end
+  end
+end

data/lib/graphql_migrate_execution/implicit.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  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
+  end
+end

data/lib/graphql_migrate_execution/not_implemented.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  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/remove_legacy.rb

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

data/lib/graphql_migrate_execution/resolve_each.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  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")
+    end
+
+    def remove_legacy(field_definition, new_source)
+      remove_field_keyword(new_source, field_definition, :resolver_method)
+      remove_resolver_method(new_source, field_definition)
+    end
+  end
+end

data/lib/graphql_migrate_execution/resolve_static.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  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")
+    end
+
+    def remove_legacy(field_definition, new_source)
+      remove_field_keyword(new_source, field_definition, :resolver_method)
+      remove_resolver_method(new_source, field_definition)
+    end
+  end
+end

data/lib/graphql_migrate_execution/resolver_method.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  class ResolverMethod
+    def initialize(name, node)
+      @name = name
+      @node = node
+      @parameter_names = if node.parameters
+        node.parameters.keywords.map(&:name)
+      else
+        []
+      end
+      @self_sends = Set.new
+      @calls_object = false
+      @calls_context = false
+      @calls_class = false
+      @calls_dataloader = false
+      @dataloader_call = false
+    end
+
+    attr_reader :name, :node, :parameter_names, :self_sends
+
+    attr_reader :source_class_node, :source_arg_nodes, :load_arg_node, :dataload_association
+
+    attr_accessor :calls_object, :calls_context, :calls_class, :calls_dataloader
+
+    attr_accessor :dataloader_call
+
+    def source
+      node.location.slice_lines
+    end
+
+    def migration_strategy
+      calls_to_self = self_sends.to_a
+      if @calls_context
+        calls_to_self.delete(:context)
+      end
+      if @calls_object
+        calls_to_self.delete(:object)
+      end
+
+      calls_to_self.delete(:dataloader)
+      calls_to_self.delete(:dataload_association)
+      calls_to_self.delete(:dataload_record)
+      calls_to_self.delete(:dataload)
+
+      # Global-ish methods:
+      calls_to_self.delete(:raise)
+
+      # Locals:
+      calls_to_self -= @parameter_names
+
+      if calls_to_self.empty?
+        if calls_dataloader
+          if !dataloader_call
+            return DataloaderManual
+          end
+
+          call_node = node.body.body.first
+          case call_node.name
+          when :dataload
+            @source_class_node = call_node.arguments.arguments.first
+            @source_arg_nodes = call_node.arguments.arguments[1...-1]
+            @load_arg_node = call_node.arguments.arguments.last
+          when :dataload_association
+            if (assoc_args = call_node.arguments.arguments).size == 1 &&
+                ((assoc_arg = assoc_args.first).is_a?(Prism::SymbolNode))
+              assoc_sym = assoc_arg.unescaped.to_sym
+              @dataload_association = assoc_sym == name ? true : assoc_sym
+            end
+          else
+            if (source_call = call_node.receiver) # eg dataloader.with(...).load(...)
+              @source_class_node = source_call.arguments.arguments.first
+              @source_arg_nodes = source_call.arguments.arguments[1..-1]
+              @load_arg_node = call_node.arguments.arguments.last
+            end
+          end
+
+          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
+            DataloaderShorthand
+          else
+            case call_node.name
+            when :load, :request, :dataload
+              DataloaderAll
+            when :load_all, :request_all, :dataload_record
+              DataloaderBatch
+            when :dataload_association
+              DataloaderShorthand
+            else
+              DataloaderManual
+            end
+          end
+        elsif calls_object
+          ResolveEach
+        else
+          ResolveStatic
+        end
+      else
+        NotImplemented
+      end
+    end
+  end
+end

data/lib/graphql_migrate_execution/strategy.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  class Strategy
+    def add_future(field_definition, new_source)
+    end
+
+    def remove_legacy(field_definition, new_source)
+    end
+
+    class << self
+      attr_accessor :color
+    end
+
+    private
+
+    def inject_resolve_keyword(new_source, field_definition, keyword)
+      value = field_definition.future_resolve_shorthand.inspect
+      inject_field_keyword(new_source, field_definition, keyword, value)
+    end
+
+    def inject_field_keyword(new_source, 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")
+      else
+        field_definition_source + ", #{keyword}: #{value}"
+      end
+      new_source.sub!(field_definition_source, new_definition_source)
+    end
+
+
+    def remove_field_keyword(new_source, 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)
+    end
+
+    def replace_resolver_method(new_source, field_definition, new_params)
+      resolver_method = field_definition.resolver_method
+      method_name = resolver_method.name
+      old_method = resolver_method.source
+      new_class_method = old_method
+        .sub("def ", 'def self.')
+
+      if resolver_method.parameter_names.empty?
+        new_class_method.sub!(method_name.to_s, "#{method_name}(#{new_params})")
+      else
+        new_class_method.sub!("def self.#{method_name}(", "def self.#{method_name}(#{new_params}, ")
+      end
+
+      old_lines = old_method.split("\n")
+      new_body = old_lines.first[/^ +/] + "  self.class.#{method_name}(#{new_params}#{resolver_method.parameter_names.map { |n| ", #{n}: #{n}"}.join})"
+      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)
+    end
+
+    def remove_resolver_method(new_source, field_definition)
+      src_pattern = /(\n*)(#{Regexp.quote(field_definition.resolver_method.source)})(\n*)/
+      new_source.sub!(src_pattern) do
+        # $2 includes a newline, too
+        "#{$1.length > 1 ? "\n" : ""}#{$3.length > 0 ? "\n" : ""}"
+      end
+    end
+  end
+end

data/lib/graphql_migrate_execution/type_definition.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  class TypeDefinition
+    def initialize(name)
+      @name = name
+      @field_definitions = {}
+      @resolver_methods = {}
+    end
+
+    attr_reader :resolver_methods, :name, :field_definitions
+
+    def field_definition(name, node)
+      @field_definitions[name] = FieldDefinition.new(self, name, node)
+    end
+
+    def resolver_method(name, node)
+      @resolver_methods[name] = ResolverMethod.new(name, node)
+    end
+  end
+end

data/lib/graphql_migrate_execution/version.rb

@@ -0,0 +1,3 @@
+module GraphqlMigrateExecution
+  VERSION = "0.0.1"
+end

data/lib/graphql_migrate_execution/visitor.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+module GraphqlMigrateExecution
+  class Visitor < Prism::Visitor
+    def initialize(source, type_definitions)
+      @source = source
+      @type_definitions = type_definitions
+      @type_definition_stack = []
+      @current_field_definition = nil
+      @current_resolver_method = nil
+    end
+
+    def visit_class_node(node)
+      if node.superclass
+        td = @type_definitions[node.name]
+        @type_definition_stack << td
+      end
+      super
+    ensure
+      if td
+        @type_definition_stack.pop
+      end
+    end
+
+    def visit_module_node(node)
+      td = @type_definitions[node.name]
+      @type_definition_stack << td
+      super
+    ensure
+      @type_definition_stack.pop
+    end
+
+    def visit_keyword_hash_node(node)
+      if @current_field_definition
+        node.elements.each do |assoc|
+          if assoc.key.is_a?(Prism::SymbolNode)
+            case assoc.key.unescaped
+            when "hash_key"
+              @current_field_definition.resolve_mode ||= :hash_key
+              @current_field_definition.hash_key = get_keyword_value(assoc.value)
+            when "resolver"
+              @current_field_definition.resolve_mode ||= :resolver
+              @current_field_definition.resolver = get_keyword_value(assoc.value)
+            when "method"
+              @current_field_definition.resolve_mode ||= :object_direct_method
+              @current_field_definition.object_direct_method = get_keyword_value(assoc.value)
+            when "resolver_method"
+              @current_field_definition.resolve_mode ||= :type_instance_method
+              @current_field_definition.type_instance_method = get_keyword_value(assoc.value)
+            when "dig"
+              @current_field_definition.resolve_mode ||= :dig
+              @current_field_definition.dig = get_keyword_value(assoc.value)
+            when "resolve_each", "resolve_static", "resolve_batch"
+              # These should override any other keywords that are discovered
+              @current_field_definition.resolve_mode = :already_migrated
+              @current_field_definition.already_migrated = { assoc.key.unescaped.to_sym => get_keyword_value(assoc.value) }
+            else
+              # fallback_value,  connection, extensions, extras, resolver, mutation, subscription
+              @current_field_definition.unknown_options << assoc.key.unescaped
+            end
+          end
+        end
+      end
+      super
+    end
+
+    def visit_call_node(node)
+      if node.receiver.nil? && node.name == :field
+        first_arg = node.arguments.arguments.first # rubocop:disable Development/ContextIsPassedCop
+        if first_arg.is_a?(Prism::SymbolNode)
+          field_name = first_arg.unescaped
+          td = @type_definition_stack.last
+          @current_field_definition = td.field_definition(field_name, node)
+        else
+          warn "GraphQL-Ruby warning: Skipping unrecognized field definition: #{node.inspect}"
+        end
+      elsif @current_resolver_method
+        if node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+          @current_resolver_method.self_sends.add(node.name)
+          case node.name
+          when :object
+            @current_resolver_method.calls_object = true
+          when :context
+            @current_resolver_method.calls_context = true
+          when :class
+            @current_resolver_method.calls_class = true
+          end
+        end
+
+        case node.name
+        when :dataloader, :dataload, :dataload_association, :dataload_record, :dataload_all
+          @current_resolver_method.calls_dataloader = true
+        end
+      end
+      super
+    ensure
+      if td
+        @current_field_definition = nil
+      end
+    end
+
+    def visit_def_node(node)
+      if node.receiver.nil?
+        td = @type_definition_stack.last
+        @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
+            @current_resolver_method.dataloader_call = true
+          end
+        when :dataload_record, :dataload_association, :dataload
+          @current_resolver_method.dataloader_call = true
+        else
+          # not a single dataloader call
+        end
+      end
+      super
+    ensure
+      @current_resolver_method = nil
+    end
+
+    private
+
+    def get_keyword_value(value_node)
+      case value_node
+      when Prism::SymbolNode
+        value_node.unescaped.to_sym
+      when Prism::StringNode
+        value_node.unescaped
+      when Prism::IntegerNode, Prism::FloatNode
+        value_node.value
+      when Prism::TrueNode
+        true
+      when Prism::FalseNode
+        false
+      when Prism::ConstantPathNode, Prism::ConstantReadNode
+        value_node.full_name
+      when Prism::CallNode
+        :DYNAMIC_CALL_NODE
+      when Prism::ArrayNode
+        value_node.elements.map { |n| get_keyword_value(n) }
+      when Prism::NilNode
+        "nil"
+      else
+        # nil, constants, `self` ...?
+        raise ArgumentError, "GraphQL-MigrateExecution can't parse this keyword argument yet, but it could. Please open an issue on GraphQL-Ruby with this error message (node class: #{value_node.class})\n\n#{value_node.inspect}"
+      end
+    end
+
+    def self.constant_node?(node)
+      case node
+      when Prism::ConstantPathNode,
+            Prism::ConstantReadNode,
+            Prism::StringNode,
+            Prism::SymbolNode,
+            Prism::IntegerNode,
+            Prism::FloatNode,
+            Prism::TrueNode,
+            Prism::FalseNode,
+            Prism::NilNode
+        true
+      when Prism::ArrayNode
+        node.elements.all? { |n| constant_node?(n) }
+      else
+        false
+      end
+    end
+
+    def self.source_for_constant_node(value_node)
+      case value_node
+      when Prism::SymbolNode
+        ":#{value_node.unescaped}"
+      when Prism::StringNode
+        value_node.unescaped.inspect
+      when Prism::IntegerNode, Prism::FloatNode
+        value_node.value.inspect
+      when Prism::TrueNode
+        "true"
+      when Prism::FalseNode
+        "false"
+      when Prism::ConstantPathNode, Prism::ConstantReadNode
+        value_node.full_name
+      when Prism::ArrayNode
+        value_node.elements.map { |n| get_keyword_value(n) }
+      when Prism::NilNode
+        "nil"
+      else
+        # nil, constants, `self` ...?
+        raise ArgumentError, "GraphQL-MigrateExecution can't parse this keyword argument yet, but it could. Please open an issue on GraphQL-Ruby with this error message (node class: #{value_node.class})\n\n#{value_node.inspect}"
+      end
+    end
+  end
+end

data/lib/graphql_migrate_execution.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+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/field_definition"
+require "graphql_migrate_execution/resolver_method"
+require "graphql_migrate_execution/type_definition"
+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_each"
+require "graphql_migrate_execution/resolve_static"
+require "graphql_migrate_execution/not_implemented"
+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/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

@@ -0,0 +1,39 @@
+# GraphqlMigrateExecution
+
+[![Test](https://github.com/rmosolgo/graphql_migrate_execution/actions/workflows/ci.yaml/badge.svg)](https://github.com/rmosolgo/graphql_migrate_execution/actions/workflows/ci.yaml) [![Gem Version](https://badge.fury.io/rb/graphql_migrate_execution.svg)](https://badge.fury.io/rb/graphql_migrate_execution)
+
+A command-line development tool to update your Ruby source code to support [GraphQL::Execution::Next](https://graphql-ruby.org/execution/next), then clean up unused legacy configs after you don't need them anymore.
+
+## Install
+
+```
+bundle add graphql_migrate_execution
+```
+
+## Use
+
+```
+Usage: graphql_migrate_execution glob [options]
+
+A development tool for adopting GraphQL-Ruby's new runtime module, GraphQL::Execution::Next
+
+Inspect the files matched by `glob` and ...
+
+- (default) print an analysis result for what can be updated
+- `--migrate`: update files with new configuration
+- `--cleanup`: remove legacy configuration and instance methods
+
+Options:
+
+        --migrate                    Update the files with future-compatibile 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/
+```
+
+## Develop
+
+```
+bundle exec rake test # TEST=test/...
+```

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: graphql_migrate_execution
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robert Mosolgo
+bindir: bin
+cert_chain: []
+date: 2026-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A development script for migrating to GraphQL-Ruby's new runtime engine
+email:
+- rdmosolgo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- 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/implicit.rb
+- lib/graphql_migrate_execution/not_implemented.rb
+- lib/graphql_migrate_execution/remove_legacy.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/version.rb
+- lib/graphql_migrate_execution/visitor.rb
+- readme.md
+homepage: https://github.com/rmosolgo/graphql_migrate_execution
+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
+  mailing_list_uri: https://buttondown.email/graphql-ruby
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A development script for migrating to GraphQL-Ruby's new runtime engine
+test_files: []