graphql_migrate_execution 0.0.2 → 1.0.1

data/readme.md

@@ -25,15 +25,169 @@ 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
+
+- [ ] Interfaces: use a `resolver_methods` block with instance methods
+- [ ] `@object` is not migrated, only `object` is
+- [ ] `**kwargs` is not correctly migrated into `resolve_static` methods
+- [ ] Does `--cleanup` work on my app? I haven't run it yet.
+- [ ] Doesn't support `def ... =`-style single-line methods

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.1
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-03-13 00:00:00.000000000 Z
+date: 2026-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -91,22 +91,25 @@ 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/fallback_value.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