data_shifter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e4e5f5aa36cfac3275fcb493a2555e6f093873c310395e92d4c7c64c42bb63b
+  data.tar.gz: d7c3e9a682d237887960a0bb3946e73a19bd913709ffb7c069a17a89e45f876a
+SHA512:
+  metadata.gz: 74d1ab829e7d3a695d934f6d624fa6bdad25b7bf13ee11d680ecd90ab9ccfbfa8df33eadf9f3239193a246a183db4604691747db7ae5ea12c4548afed547645a
+  data.tar.gz: c70d3e6be2982dc83501349aeee74ae2e3dd476fd2315f46a76b4e2b52e77cfa6f7c1042a7c4f613460880d07382731b2dd24db41d9e85991b54075d6cf76fa0

data/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx lint-staged

data/.lintstagedrc

@@ -0,0 +1,3 @@
+{
+  "*.rb": ["bundle exec rubocop -A -c .rubocop.yml --force-exclusion"]
+}

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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/README.md

@@ -0,0 +1,256 @@
+# DataShifter
+
+Rake-backed data migrations (“shifts”) for Rails apps, with **dry run by default**, progress output, and a consistent summary. Define shift classes in `lib/data_shifts/*.rb`; run them as `rake data:shift:<task_name>`.
+
+## Installation
+
+```ruby
+# Gemfile
+gem "data_shifter"
+```
+
+```bash
+bundle install
+```
+
+No extra setup in a Rails app: the railtie registers the generator and defines rake tasks by scanning `lib/data_shifts/*.rb`.
+
+## Quickstart
+
+Generate a shift (optionally scoped to a model):
+
+```bash
+bin/rails generate data_shift backfill_foo
+bin/rails generate data_shift backfill_users --model=User
+```
+
+Add  your logic to the generated file in `lib/data_shifts/`.
+
+Run it:
+
+```bash
+rake data:shift:backfill_foo
+COMMIT=1 rake data:shift:backfill_foo
+```
+
+## How shift files map to rake tasks
+
+DataShifter defines one rake task per file in `lib/data_shifts/*.rb`.
+
+- **Task name**: derived from the filename with any leading digits removed.
+  - `20260201120000_backfill_foo.rb` → `data:shift:backfill_foo` (leading `<digits>_` prefix is stripped)
+  - `backfill_foo.rb` → `data:shift:backfill_foo`
+- **Class name**: task name camelized, inside the `DataShifts` module.
+  - `backfill_foo` → `DataShifts::BackfillFoo`
+
+Shift files are **required only when the task runs** (tasks are defined up front; classes load lazily).
+The `description "..."` line is extracted from the file and used for `rake -T` output without loading the shift class.
+
+## Defining a shift
+
+Typical shifts implement:
+
+- **`collection`**: an `ActiveRecord::Relation` (uses `find_each`) or an `Array`/Enumerable
+- **`process_record(record)`**: applies the change for one record
+
+```ruby
+module DataShifts
+  class BackfillCanceledById < DataShifter::Shift
+    description "Backfill canceled_by_id"
+
+    def collection
+      Bar.where(canceled_by_id: nil).where.not(canceled_at: nil)
+    end
+
+    def process_record(bar)
+      bar.update!(canceled_by_id: bar.company.primary_contact_id)
+    end
+  end
+end
+```
+
+## Dry run vs commit
+
+Shifts run in **dry run** mode by default. In the automatic transaction modes (`transaction :single` / `true`, and `transaction :per_record`), DB changes are rolled back automatically.
+
+- **Dry run (default)**: `rake data:shift:backfill_foo`
+- **Commit**: `COMMIT=1 rake data:shift:backfill_foo`
+  - (`COMMIT=true` or `DRY_RUN=false` also commit)
+
+Non-DB side effects (API calls, emails, enqueued jobs, etc.) obviously cannot be automatically rolled back, so guard them with e.g. `return if dry_run?`.
+
+## Transaction modes
+
+Set the transaction mode at the class level:
+
+- **`transaction :single` / `transaction true` (default)**: one DB transaction for the entire run; dry run rolls back at the end; a record error aborts the run.
+- **`transaction :per_record`**: in commit mode, each record runs in its own transaction (errors are collected and the run continues); in dry run, the run is wrapped in a single rollback transaction.
+- **`transaction false` / `transaction :none`**: CAUTION: NOT RECOMMENDED. No automatic transactions and no automatic rollback; ⚠️ **you must manually guard DB writes AND side effects with `dry_run?`.**
+
+```ruby
+module DataShifts
+  class BackfillLegacyId < DataShifter::Shift
+    description "Per-record so one failure doesn't roll back all"
+    transaction :per_record
+
+    def collection = Item.where(legacy_id: nil)
+    def process_record(item)
+      item.update!(legacy_id: LegacyIdService.fetch(item))
+    end
+  end
+end
+```
+
+```ruby
+module DataShifts
+  class SyncToExternal < DataShifter::Shift
+    description "Side effects outside DB"
+    transaction false
+
+    def process_record(record)
+      return if dry_run?
+
+      record.update!(synced_at: Time.current)
+      ExternalAPI.notify(record)
+    end
+  end
+end
+```
+
+## Progress, status, and output
+
+- **Progress bar**: enabled by default (requires `ruby-progressbar`), and only shown for collections with at least 5 records.
+- **Header**: prints mode (DRY RUN vs LIVE), record count, transaction mode, and available status triggers.
+- **Live status (without aborting)**:
+  - `STATUS_INTERVAL=60` prints a status block periodically (checked between records)
+  - **macOS/BSD**: `Ctrl+T` (SIGINFO)
+  - **Any OS**: `kill -USR1 <pid>` (SIGUSR1)
+
+## Resuming a partial run (`CONTINUE_FROM`)
+
+If your `collection` is an `ActiveRecord::Relation`, you can resume by filtering the primary key:
+
+```bash
+CONTINUE_FROM=123 COMMIT=1 rake data:shift:backfill_foo
+```
+
+Notes:
+
+- Only supported for `ActiveRecord::Relation` collections (Array-based collections—like those from `find_exactly!`—cannot be resumed).
+- The filter is `primary_key > CONTINUE_FROM`, so it’s only useful with monotonically increasing primary keys (e.g. `find_each`'s default behavior).
+
+## Operational tips
+
+### Safety checklist (recommended)
+
+- **Start with a dry run**: run the task once with no environment variables set, confirm logs and summary look right, then re-run with `COMMIT=1`.
+- **Make shifts idempotent**: structure `process_record` so re-running is safe (for example, update only when the target column is `NULL`, or compute the same derived value deterministically).
+- **Guard side effects explicitly**: even in dry run, API calls / emails / enqueues are not rolled back. Use `dry_run?` helper to skip side-effectful code.
+
+### Choosing a transaction mode (behavior + guidance)
+
+- **`transaction :single` (default)**:
+  - **Behavior**: the first raised error aborts the run (all-or-nothing).
+  - **Use when**: partial success is worse than failure, or you want a clean rollback on any unexpected error.
+- **`transaction :per_record`**:
+  - **Behavior**: in commit mode, records are committed one-by-one; errors are collected and the run continues; the overall run fails at the end if any record failed.
+  - **Use when**: you want maximum progress and are OK investigating/fixing a subset of failures.
+- **`transaction false` / `:none`**:
+  - **Behavior**: no automatic transaction wrapper (even in dry run) and no automatic rollback.
+  - **Use when**: you have intentional external side effects, or you’re doing your own transaction/locking strategy—**but always guard writes/side effects with `dry_run?`.**
+
+### Performance and operability (recommended)
+
+- **Prefer returning an `ActiveRecord::Relation` from `collection`** for large datasets (DataShifter iterates relations with `find_each`).
+- **Be aware `count` happens up front for relations** to print the header and size the progress bar. On very large/expensive relations, that extra query may be non-trivial.
+- **Use status output for long runs**: set `STATUS_INTERVAL` in environments where signals are awkward (for example, some process managers).
+
+## Utilities for building shifts
+
+### `find_exactly!` (fail fast for ID lists)
+
+Use `find_exactly!(Model, ids)` to fetch a fixed list and raise if any are missing:
+
+```ruby
+def collection
+  ids = ENV.fetch("BUYBACK_IDS").split(",").map(&:strip)
+  find_exactly!(Buyback, ids)
+end
+
+def process_record(buyback)
+  buyback.recompute!
+end
+```
+
+### `skip!` (count but don’t update)
+
+Mark a record as skipped (it will increment “Skipped” in the summary):
+
+```ruby
+def process_record(record)
+  skip!("already done") if record.foo.present?
+  record.update!(foo: value)
+end
+```
+
+### Throttling and disabling the progress bar
+
+```ruby
+class SomeShift < DataShifter::Shift
+  throttle 0.1       # sleep seconds between records
+  progress false    # disable progress bar rendering
+end
+```
+
+## Generator
+
+| Command | Generates |
+|--------|----------|
+| `bin/rails generate data_shift backfill_foo` | `lib/data_shifts/<timestamp>_backfill_foo.rb` with a `DataShifts::BackfillFoo` class |
+| `bin/rails generate data_shift backfill_users --model=User` | Same, with `User.all` in `collection` and `process_record(user)` |
+| `bin/rails generate data_shift backfill_users --spec` | Also generates `spec/lib/data_shifts/backfill_users_spec.rb` when RSpec is enabled |
+
+The generator refuses to create a second shift if it would produce a duplicate rake task name.
+
+## Testing shifts (RSpec)
+
+This gem ships a small helper module for running shifts in tests:
+
+```ruby
+require "data_shifter/spec_helper"
+
+RSpec.describe DataShifts::BackfillFoo do
+  include DataShifter::SpecHelper
+
+  before { allow($stdout).to receive(:puts) } # silence shift output
+
+  it "does not persist changes in dry run" do
+    result = run_data_shift(described_class, dry_run: true)
+    expect(result).to be_ok
+    # TODO: add some check confirming data is unchanged
+  end
+
+  it "persists changes when committed" do
+    result = run_data_shift(described_class, commit: true)
+    expect(result).to be_ok
+    # TODO: add some check confirming data is changed
+  end
+end
+```
+
+## Optional RuboCop cop
+
+If you use `transaction false` / `transaction :none`, you should guard writes and side effects with `dry_run?`. You can help avoid mistakes by linting that the helper is at least called once via the bundled cop:
+
+```yaml
+# .rubocop.yml
+require:
+  - data_shifter/rubocop
+```
+
+## Requirements
+
+- Ruby ≥ 3.2.1
+- Rails (ActiveRecord, ActiveSupport, Railties) ≥ 6.1
+- `axn` (Shift classes include `Axn`)
+- `ruby-progressbar` (for progress bars)

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+task :spec do
+  Dir.chdir("spec/dummy_app") do
+    sh "BUNDLE_GEMFILE=Gemfile bundle exec rspec spec/"
+  end
+end
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+# Ensure specs and rubocop pass before release (must run first; enhance appends)
+release_task = Rake::Task["release"]
+release_task.prerequisites.unshift(:default)

data/lib/data_shifter/internal/env.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DataShifter
+  module Internal
+    # Environment variable parsing utilities.
+    # All methods are stateless module functions.
+    module Env
+      module_function
+
+      # Determine dry_run mode from environment variables.
+      # COMMIT=1 or COMMIT=true means dry_run=false
+      # DRY_RUN=false means dry_run=false; default is true
+      def dry_run?
+        if ENV["COMMIT"].present?
+          !%w[1 true].include?(ENV["COMMIT"].to_s.downcase)
+        else
+          ENV.fetch("DRY_RUN", "true") == "true"
+        end
+      end
+
+      # Parse STATUS_INTERVAL environment variable.
+      # Returns nil if not set or invalid.
+      def status_interval_seconds
+        return nil unless ENV["STATUS_INTERVAL"].present?
+
+        Integer(ENV.fetch("STATUS_INTERVAL", nil), 10)
+      rescue ArgumentError
+        nil
+      end
+
+      # Get CONTINUE_FROM environment variable value.
+      # Returns nil if not set or empty.
+      def continue_from_id
+        ENV.fetch("CONTINUE_FROM", nil).presence
+      end
+    end
+  end
+end

data/lib/data_shifter/internal/output.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module DataShifter
+  module Internal
+    # Output formatting utilities for data shift runs.
+    # All methods are stateless module functions that accept IO and context parameters.
+    module Output
+      TRANSACTION_MODE_LABELS = {
+        single: "single (all-or-nothing)",
+        per_record: "per-record",
+        none: "none",
+      }.freeze
+
+      module_function
+
+      def print_header(io:, shift_class:, total:, label:, dry_run:, transaction_mode:, status_interval:)
+        io.puts ""
+        io.puts "=" * 60
+        io.puts shift_class.name || "DataShifter::Shift (anonymous)"
+        io.puts "\"#{shift_class.description}\"" if shift_class.description.present?
+        io.puts "-" * 60
+        io.puts "Mode:        #{dry_run ? "DRY RUN (no changes will be persisted)" : "LIVE"}"
+        io.puts "Records:     #{total} #{label}"
+        io.puts "Transaction: #{TRANSACTION_MODE_LABELS[transaction_mode]}"
+
+        status_line = build_status_line(status_interval)
+        io.puts "Status:      #{status_line} for live progress (no abort)" if status_line
+
+        io.puts "=" * 60
+        io.puts ""
+      end
+
+      def print_summary(io:, stats:, errors:, start_time:, dry_run:, transaction_mode:, interrupted:, task_name:, last_successful_id:)
+        return unless start_time
+
+        elapsed = (Time.current - start_time).round(1)
+        io.puts ""
+        io.puts "=" * 60
+        io.puts summary_title(dry_run:, interrupted:)
+        io.puts "-" * 60
+        io.puts "Duration:    #{elapsed}s"
+        io.puts "Processed:   #{stats[:processed]}"
+        io.puts "Succeeded:   #{stats[:succeeded]}"
+        io.puts "Failed:      #{stats[:failed]}"
+        io.puts "Skipped:     #{stats[:skipped]}"
+
+        print_errors(io:, errors:) if errors.any?
+        print_interrupt_warning(io:, transaction_mode:, dry_run:) if interrupted
+        print_dry_run_instructions(io:, task_name:) if dry_run && !interrupted
+        print_continue_from_hint(io:, task_name:, last_successful_id:, dry_run:, transaction_mode:, errors:)
+
+        io.puts "=" * 60
+      end
+
+      def print_progress(io:, stats:, errors:, start_time:, status_interval:)
+        return unless start_time
+
+        elapsed = (Time.current - start_time).round(1)
+        io.puts ""
+        io.puts "=" * 60
+
+        trigger = if status_interval
+                    "every #{status_interval}s (STATUS_INTERVAL)"
+                  elsif Signal.list.key?("INFO")
+                    "Ctrl+T"
+                  else
+                    "SIGUSR1"
+                  end
+
+        io.puts "STATUS (still running) — triggered by #{trigger}"
+        io.puts "-" * 60
+        io.puts "Duration:    #{elapsed}s"
+        io.puts "Processed:   #{stats[:processed]}"
+        io.puts "Succeeded:   #{stats[:succeeded]}"
+        io.puts "Failed:      #{stats[:failed]}"
+        io.puts "Skipped:     #{stats[:skipped]}"
+
+        print_errors(io:, errors:) if errors.any?
+
+        io.puts "=" * 60
+        io.puts ""
+      end
+
+      def print_errors(io:, errors:)
+        io.puts ""
+        io.puts "ERRORS:"
+        errors.each do |err|
+          io.puts "  #{err[:record]}: #{err[:error]}"
+          err[:backtrace]&.each { |line| io.puts "    #{line}" }
+        end
+      end
+
+      def summary_title(dry_run:, interrupted:)
+        base = dry_run ? "SUMMARY (DRY RUN)" : "SUMMARY"
+        interrupted ? "#{base} - INTERRUPTED" : base
+      end
+
+      def print_interrupt_warning(io:, transaction_mode:, dry_run:)
+        io.puts ""
+        if transaction_mode == :none
+          io.puts "[!] INTERRUPTED: `transaction false` mode was active."
+          io.puts "    Some DB changes may have been applied before interruption."
+          io.puts "    Non-DB side effects (API calls, emails, etc.) are not rolled back."
+          io.puts "    Review the database state before re-running."
+        elsif dry_run
+          io.puts "[!] INTERRUPTED: All DB changes have been rolled back (dry run)."
+          io.puts "    Non-DB side effects (API calls, emails, etc.) are not rolled back."
+        else
+          io.puts "[!] INTERRUPTED: DB transaction has been rolled back."
+          io.puts "    No DB changes were persisted."
+          io.puts "    Non-DB side effects (API calls, emails, etc.) are not rolled back."
+        end
+      end
+
+      def print_dry_run_instructions(io:, task_name:)
+        io.puts ""
+        io.puts "[!] No changes were saved."
+        return unless task_name.present?
+
+        io.puts "To apply these changes, run:"
+        io.puts "    COMMIT=1 rake data:shift:#{task_name}"
+      end
+
+      def print_continue_from_hint(io:, task_name:, last_successful_id:, dry_run:, transaction_mode:, errors:)
+        return if dry_run
+        return unless transaction_mode == :none
+        return if errors.empty?
+        return unless last_successful_id
+        return unless task_name.present?
+
+        io.puts ""
+        io.puts "To resume from the last successful record:"
+        io.puts "    CONTINUE_FROM=#{last_successful_id} COMMIT=1 rake data:shift:#{task_name}"
+      end
+
+      def build_status_line(status_interval)
+        status_tips = []
+        status_tips << "Ctrl+T" if Signal.list.key?("INFO")
+        status_tips << "kill -USR1 #{Process.pid}" if Signal.list.key?("USR1")
+
+        if status_interval
+          interval_msg = "STATUS_INTERVAL is set to #{status_interval}s."
+          status_tips.any? ? "#{interval_msg} Or: #{status_tips.join(", ")}" : interval_msg
+        elsif status_tips.any?
+          status_tips.join(" or ")
+        end
+      end
+    end
+  end
+end

data/lib/data_shifter/internal/progress_bar.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DataShifter
+  module Internal
+    # Progress bar creation utility.
+    # All methods are stateless module functions.
+    module ProgressBar
+      module_function
+
+      # Create a progress bar for iteration.
+      # Returns nil if progress is disabled or total is too small.
+      #
+      # @param total [Integer] total number of items
+      # @param dry_run [Boolean] whether running in dry run mode
+      # @param enabled [Boolean] whether progress bar is enabled
+      # @return [ProgressBar::Base, nil] the progress bar or nil
+      def create(total:, dry_run:, enabled:)
+        return unless enabled && total >= 5
+
+        require "ruby-progressbar"
+        ::ProgressBar.create(
+          total:,
+          format: "%t: |%B| %c/%C (%P%%) %e",
+          title: dry_run ? "Dry run" : "Processing",
+        )
+      end
+    end
+  end
+end

data/lib/data_shifter/internal/record_utils.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DataShifter
+  module Internal
+    # Record-related utility functions.
+    # All methods are stateless module functions.
+    module RecordUtils
+      module_function
+
+      # Generate a human-readable identifier for a record.
+      #
+      # @param record [Object] the record to identify
+      # @return [String] identifier string
+      def identifier(record)
+        return "#{record.class.name}##{record.id}" if record.respond_to?(:id)
+
+        record.inspect.truncate(80)
+      end
+
+      # Derive a default label from an array of items.
+      #
+      # @param items [Array] collection of items
+      # @return [String] pluralized model name or "records"
+      def default_label(items)
+        sample = items.first
+        sample.respond_to?(:model_name) ? sample.model_name.human.pluralize : "records"
+      end
+
+      # Derive a default label from an ActiveRecord::Relation.
+      #
+      # @param relation [ActiveRecord::Relation] the relation
+      # @return [String] pluralized model name or "records"
+      def default_label_for_relation(relation)
+        relation.respond_to?(:model) ? relation.model.model_name.human.pluralize : "records"
+      end
+    end
+  end
+end

data/lib/data_shifter/internal/signal_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DataShifter
+  module Internal
+    # Signal trap management for status reporting during data shift runs.
+    # All methods are stateless module functions.
+    module SignalHandler
+      module_function
+
+      # Install signal traps for status reporting (SIGUSR1, SIGINFO).
+      # Returns a hash of previous handlers to restore later.
+      #
+      # @param status_proc [Proc] the proc to call when signal is received
+      # @return [Hash] previous signal handlers keyed by signal name
+      def install_status_traps(status_proc)
+        handlers = {}
+
+        %w[USR1 INFO].each do |sig|
+          next unless Signal.list.key?(sig)
+
+          handlers[sig] = Signal.trap(sig, status_proc)
+        end
+
+        handlers
+      end
+
+      # Restore previous signal handlers.
+      #
+      # @param handlers [Hash] previous handlers from install_status_traps
+      def restore_status_traps(handlers)
+        handlers.each do |sig, prev|
+          Signal.trap(sig, prev) if prev && Signal.list.key?(sig)
+        end
+      end
+    end
+  end
+end

data/lib/data_shifter/railtie.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module DataShifter
+  class Railtie < Rails::Railtie
+    # Extract description DSL from shift file without loading it.
+    # Supports: description "text", description 'text', description %(text), description <<~HEREDOC
+    def self.extract_description(file_path)
+      content = File.read(file_path)
+
+      # Single/double quoted strings: description "text" or description 'text'
+      if (match = content.match(/^\s*description\s+["'](.+?)["']/))
+        return match[1]
+      end
+
+      # Percent strings: description %(text) or description %Q(text)
+      if (match = content.match(/^\s*description\s+%Q?\((.+?)\)/m))
+        return match[1].gsub(/\s+/, " ").strip
+      end
+
+      # Heredoc: description <<~HEREDOC or <<-HEREDOC or <<HEREDOC
+      if (match = content.match(/^\s*description\s+<<[~-]?(\w+)\s*\n(.*?)\n\s*\1/m))
+        return match[2].gsub(/\s+/, " ").strip
+      end
+
+      nil
+    end
+
+    generators do
+      require "generators/data_shift_generator"
+    end
+
+    # Zeitwerk infers constants from filenames. Timestamped shift files
+    # (e.g. 20260211_backfill_users.rb) would map to an invalid constant
+    # starting with a digit. Tell Zeitwerk to ignore the shifts directory
+    # so we can load them manually with require.
+    initializer "data_shifter.ignore_shifts_dir" do
+      shifts_dir = Rails.root.join("lib/data_shifts")
+      Rails.autoloaders.main.ignore(shifts_dir) if shifts_dir.exist?
+    end
+
+    rake_tasks do
+      namespace :data do
+        namespace :shift do
+          shifts_dir = Rails.root.join("lib/data_shifts")
+          next unless shifts_dir.exist?
+
+          Dir.glob(shifts_dir.join("*.rb")).each do |file_path|
+            # Infer task name from filename: "20260211_backfill_users.rb" -> "backfill_users"
+            filename = File.basename(file_path, ".rb")
+            task_name = filename.sub(/\A\d+_/, "")
+            class_name = task_name.camelize
+
+            # Extract description from file without loading it (for rake -T)
+            task_desc = Railtie.extract_description(file_path) || "Run data shift: #{class_name}"
+
+            # Define the rake task lazily (only loads class when task runs)
+            desc task_desc
+            task task_name => :environment do
+              require file_path
+
+              # Resolve the constant inside the DataShifts namespace
+              klass = "DataShifts::#{class_name}".constantize
+              klass.task_name(task_name)
+              klass.run!
+            rescue Interrupt
+              exit(130)
+            rescue StandardError
+              exit(1)
+            end
+          end
+        end
+      end
+    end
+  end
+end