ajdc 0.0.1 → 0.1.0

data/lib/active_job/durable/run.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Durable
+    # One row per run of a durable job: from the first enqueue to a terminal status,
+    # across every retry, interrupt and resume.
+    class Run < Record
+      LIVE_STATUSES = %w[enqueued running waiting awaiting].freeze
+      ATTENTION_STATUSES = %w[failed halted].freeze
+      TERMINAL_STATUSES = %w[completed discarded cancelled].freeze
+      STATUSES = (LIVE_STATUSES + ATTENTION_STATUSES + TERMINAL_STATUSES).freeze
+      CANCELLABLE_STATUSES = (LIVE_STATUSES + ATTENTION_STATUSES).freeze
+      WAKEABLE_STATUSES = %w[waiting awaiting].freeze
+
+      # The `state` column keeps the attribute values in Active Job argument form
+      # (the form `ActiveJob::Attributes` restores from), while `Run#state` reads as
+      # a plain hash: `{"verdict" => "unsure"}`. Writes accept either form.
+      class StateType < ActiveRecord::Type::Json
+        def deserialize(value)
+          decoded = super
+          decoded.present? ? ActiveJob::Arguments.deserialize([decoded]).first : {}
+        end
+
+        def serialize(value) = super(self.class.serialized(value))
+
+        # The argument form of `value`; an already-serialized hash (marked with
+        # `_aj_` keys) is returned as is.
+        def self.serialized(value)
+          value = value.to_h
+          if value.each_key.any? { |key| key.to_s.start_with?("_aj_") }
+            value
+          else
+            ActiveJob::Arguments.serialize([value]).first
+          end
+        end
+      end
+
+      self.table_name = "active_job_durable_runs"
+
+      has_many :steps, -> { order(:position, :attempt) }, class_name: "ActiveJob::Durable::Step", dependent: :delete_all
+
+      attribute :completed_steps, default: -> { [] }
+      attribute :state, StateType.new, default: -> { {} }
+      attribute :pending_signals, default: -> { {} }
+
+      scope :newest_first, -> { order(created_at: :desc, id: :desc) }
+      scope :live, -> { where(status: LIVE_STATUSES) }
+      scope :attention, -> { where(status: ATTENTION_STATUSES) }
+      scope :terminal, -> { where(status: TERMINAL_STATUSES) }
+      STATUSES.each { |status| scope status, -> { where(status:) } }
+
+      scope :at_step, ->(name) { where(current_step: name.to_s) }
+      # A parked run is stuck when its wake time passed and the clock did not wake it.
+      scope :stuck_for, ->(duration) {
+        since = duration.ago
+        where(status: "running").where(last_heartbeat_at: ...since)
+          .or(where(status: "enqueued").where(transitioned_at: ...since))
+          .or(where(status: WAKEABLE_STATUSES).where(wake_at: ...since))
+      }
+      scope :due, ->(now = Time.current) { where(status: WAKEABLE_STATUSES, wake_at: ..now) }
+      scope :for, ->(*args, **kwargs) {
+        next where(key: kwargs[:workflow_key]) if kwargs.key?(:workflow_key)
+
+        job_class = where_values_hash["job_class"] or raise ArgumentError, "for needs a job class; use MyJob.workflow_runs.for(...)"
+        where(key: job_class.constantize.durable_config.workflow_key(*args, **kwargs))
+      }
+
+      def self.wake_due(now = Time.current)
+        due(now).find_each.count { |run| run.reenqueue_parked_job!(from: WAKEABLE_STATUSES) }
+      end
+
+      # Deletes the terminal runs that ended before `ended_before`, with their
+      # steps, one batch per transaction; returns how many. A terminal row is
+      # never written again, so `transitioned_at` is when it ended (and is indexed).
+      def self.clear_terminal(ended_before:, batch_size: 1_000)
+        terminal.where(transitioned_at: ...ended_before).in_batches(of: batch_size).sum do |batch|
+          ids = batch.ids
+          transaction do
+            Step.where(run_id: ids).delete_all
+            where(id: ids).delete_all
+          end
+        end
+      end
+
+      def live? = LIVE_STATUSES.include?(status)
+
+      def attention? = ATTENTION_STATUSES.include?(status)
+
+      def terminal? = TERMINAL_STATUSES.include?(status)
+
+      # The attribute values in the form the job restores them from.
+      def serialized_state = StateType.serialized(state)
+
+      # Puts a `halted` or `failed` run back in the queue, in place: the step that
+      # stopped re-runs from its cursor as a new attempt, and the step rows keep
+      # the earlier attempts with their errors. Raises `NotResumable` for any
+      # other status, or when another caller resumed the run first.
+      def resume!
+        reenqueue_parked_job!(from: ATTENTION_STATUSES) ||
+          raise(NotResumable, "Run #{id} is #{reload.status}; only a halted or failed run can be resumed")
+        self
+      end
+
+      # Ends a run that is not terminal, in one status-guarded update, and returns
+      # it reloaded. Never touches the queue: a queued job for a cancelled run
+      # performs nothing, a running one stops at its next checkpoint. Raises
+      # `NotCancellable` for a terminal run, or when another caller ended it first.
+      def cancel!
+        now = Time.current
+        updated = self.class.where(id:, status: CANCELLABLE_STATUSES).update_all(
+          status: "cancelled", active_key: nil, parked_job: nil, finished_at: now, transitioned_at: now, updated_at: now
+        )
+        raise NotCancellable, "Run #{id} is #{reload.status}; a terminal run cannot be cancelled" if updated.zero?
+
+        reload
+      end
+
+      # Delivers a signal: `value` (any JSON value, raw) under `name`. A run
+      # parked at that name goes back to the queue and the step runs with the
+      # value; any other live run keeps it in `pending_signals` for the `await`
+      # to consume when the line is reached. A second signal for the same name
+      # overwrites the first. Without a name, the parked step is the one woken:
+      # a timer ends now, an `await` receives `nil`. Raises `NotLive` when the run
+      # is not live, `NotWaiting` for a nameless wake of a run that is not parked.
+      # The row lock makes a signal and the job's own park or consume atomic.
+      def wake_up(name = nil, value = nil)
+        transaction do
+          lock!
+          unless name
+            WAKEABLE_STATUSES.include?(status) or raise NotWaiting, "Run #{id} is #{status}; only a waiting or awaiting run can be woken up"
+            name = current_step
+          end
+          live? or raise NotLive, "Run #{id} is #{status}; a signal needs a live run"
+
+          signals = pending_signals.merge(name.to_s => value)
+          if WAKEABLE_STATUSES.include?(status) && current_step == name.to_s
+            reenqueue_parked_job!(from: status, pending_signals: signals)
+          else
+            self.class.where(id:, status:).update_all(pending_signals: signals, updated_at: Time.current)
+            reload
+          end
+        end
+        self
+      end
+
+      # One status-guarded transition to `enqueued`, then the parked job goes
+      # back to the queue once every open transaction has committed. False when
+      # the status was not in `from` any more (a concurrent resume, a cancel).
+      def reenqueue_parked_job!(from:, **changes) # :nodoc:
+        now = Time.current
+        updated = self.class.where(id:, status: from).update_all(
+          status: "enqueued", error_class: nil, error_message: nil, halt_reason: nil,
+          finished_at: nil, transitioned_at: now, updated_at: now, **changes
+        )
+        return false if updated.zero?
+
+        reload
+        job = ActiveJob::Base.deserialize(parked_job)
+        job.scheduled_at = nil # a retry's or a resume's delay does not carry over
+        ActiveRecord.after_all_transactions_commit { job.enqueue }
+        true
+      end
+    end
+  end
+end

data/lib/active_job/durable/step.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Durable
+    # One row per step attempt. A step that is interrupted or fails and then re-enters
+    # gets a new row with the next `attempt`; `cursor` is the last committed cursor of
+    # that attempt, in Active Job argument serialization form.
+    class Step < Record
+      self.table_name = "active_job_durable_steps"
+
+      belongs_to :run, class_name: "ActiveJob::Durable::Run"
+    end
+  end
+end

data/lib/active_job/durable/wake_job.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Durable
+    # The clock for `wait:`, `wait_until:` and `await` deadlines: one scheduled call to
+    # `ActiveJob::Durable.wake_up_due`. Add it to your schedule, e.g., Solid Queue:
+    #
+    #   # config/recurring.yml
+    #   durable_wake:
+    #     class: ActiveJob::Durable::WakeJob
+    #     schedule: every minute
+    class WakeJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
+      def perform = Durable.wake_up_due
+    end
+  end
+end

data/lib/active_job/durable.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "digest/sha2"
+require "active_job"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/numeric/time"
+require "active_job/continuable/callbacks"
+
+module ActiveJob
+  # = Active Job Durable
+  #
+  # A Continuable job whose run is also a record. Include it instead of
+  # `ActiveJob::Continuable`:
+  #
+  #   class ProcessImportJob < ApplicationJob
+  #     include ActiveJob::Durable
+  #
+  #     def perform(import)
+  #       step :validate
+  #       step :process, isolated: true
+  #     end
+  #   end
+  #
+  # Steps, cursors and attributes behave exactly as in `ActiveJob::Continuable`,
+  # but the run row is the single source of truth: the payload carries
+  # `"durable_run_id"` instead of `"continuation"`, `"attributes"` and
+  # `"resumptions"`, and every execution rebuilds the continuation, the attribute
+  # values and the resumption count from `active_job_durable_runs` and the
+  # current attempt in `active_job_durable_steps`. The rows are written before
+  # the job is re-enqueued, in every path.
+  module Durable
+    extend ActiveSupport::Concern
+    include ActiveJob::Continuable::Callbacks
+
+    autoload :ArgsMapper, "active_job/durable/args_mapper"
+    autoload :Config, "active_job/durable/config"
+    autoload :Continuation, "active_job/durable/continuation"
+    autoload :Execution, "active_job/durable/execution"
+    autoload :HousekeepingJob, "active_job/durable/housekeeping_job"
+    autoload :Record, "active_job/durable/record"
+    autoload :Run, "active_job/durable/run"
+    autoload :Step, "active_job/durable/step"
+    autoload :WakeJob, "active_job/durable/wake_job"
+
+    mattr_accessor :connects_to, instance_accessor: false
+
+    # How long `clean_up` keeps a `completed`, `discarded` or `cancelled` run
+    # (and its steps) after it ended; `nil` keeps them forever.
+    mattr_accessor :keep_terminal_runs_for, instance_accessor: false, default: 14.days
+
+    # Wakes every `waiting` or `awaiting` run whose `wake_at` has passed, once each, and
+    # returns how many. `WakeJob` calls it on schedule; tests call it inside `travel_to`.
+    def self.wake_up_due = Run.wake_due
+
+    # Deletes the terminal runs older than `keep_terminal_runs_for`, with their
+    # steps, and returns how many. `HousekeepingJob` calls it on schedule.
+    def self.clean_up
+      return 0 unless keep_terminal_runs_for
+
+      Run.clear_terminal(ended_before: keep_terminal_runs_for.ago)
+    end
+
+    # Raised inside `perform_now` when the payload references a run row that does
+    # not exist (or belongs to another job), so `retry_on`, `discard_on` and
+    # `rescue_from` handlers can see it.
+    class RunNotFoundError < StandardError; end
+
+    # Raised by `Run#resume!` when the run is not `halted` or `failed`, or when
+    # another caller resumed it first.
+    class NotResumable < StandardError; end
+
+    # Raised by `Run#cancel!` when the run is terminal, or when another caller
+    # ended it first.
+    class NotCancellable < StandardError; end
+
+    # Raised by `Run#wake_up` when the run is not `waiting`, or when the clock
+    # or another caller woke it first.
+    class NotWaiting < StandardError; end
+
+    # Raised by `Run#wake_up(name, value)` when the run is not live: a signal
+    # for a run that ended, or that needs attention first, has no one to consume it.
+    class NotLive < StandardError; end
+
+    # Raised by `unique_by ..., on_conflict: :reject` when a run with the same
+    # `active_key` is live or needs attention; `run` is that run.
+    class RunAlreadyExists < StandardError
+      attr_reader :run
+
+      def initialize(run)
+        @run = run
+        super("Run #{run.id} for #{run.job_class} (#{run.active_key}) is #{run.status}")
+      end
+    end
+
+    # Raised by `halt!`
+    class Halt < Exception # rubocop:disable Lint/InheritException
+      attr_reader :reason
+
+      def initialize(reason = nil)
+        @reason = reason
+        super(reason ? "Halted (#{reason})" : "Halted")
+      end
+    end
+
+    # Raised at a checkpoint or a step boundary when `Run#cancel!` ended the run
+    # meanwhile: the job stops, the open step row is `cancelled` and the job
+    # handles the error itself, so nothing reaches the backend.
+    class Cancelled < Exception # rubocop:disable Lint/InheritException
+    end
+
+    included do
+      self.continuation_class = Continuation
+
+      # Ensure run checkpoints are written before any other callback
+      around_step(prepend: true) { |_job, block| durable_job.step(&block) }
+
+      # Add our hook before Continuable's `around_perform :continue`,
+      # so we can wrap it
+      around_perform(prepend: true) { |_job, block| durable_job.perform(&block) }
+
+      after_discard { |_job, error| durable_job.record_discard(error) }
+      rescue_from(Halt) { |error| durable_job.halted!(error) }
+    end
+
+    module ClassMethods
+      # Names the components of a run's `key`: `perform` parameters (positional by
+      # name, keywords by key), or a block called with the `perform` arguments
+      # whose return value is the key (rendered like any component, or joined
+      # with ":" when it is an array):
+      #
+      #   identified_by :card                 # key "cards/42", whatever the other arguments
+      #   identified_by :card, :style         # key "cards/42:plain" for perform(card, style: "plain")
+      #   identified_by { |card, **| [card.account, :export] }
+      #
+      # A name that is not a `perform` parameter raises `ArgumentError`.
+      #
+      # Without a declaration every argument is a component: positional in order,
+      # then keywords sorted by name as `name=value`.
+      def identified_by(...) = durable_config.identified_by(...)
+
+      # Specicy the run uniqueness components in the same forms as `identified_by`.
+      # Uniqueness is only enforced for runs that hasn't been terminated:  either _live_ runs
+      # (with "enqueued", "running", "waiting", "awaiting" status) or _paused_ runs ("failed" or "halted").
+      # The `on_conflict:` option defines what to do if the mathing run exists:
+      #
+      #   unique_by :import                         # :skip — enqueue nothing, `perform_later` returns false
+      #   unique_by :payout, on_conflict: :reject   # raise `RunAlreadyExists`
+      #   unique_by :license, on_conflict: :replace # cancel that run and start this one
+      #
+      def unique_by(*names, on_conflict: :skip, &block) = durable_config.unique_by(*names, on_conflict:, &block)
+
+      # Errors that could be resolved by a human (or alike), so the run
+      # could be restarted from the current step/cursor.
+      def halt_on(*errors)
+        durable_config.halt_on(*errors)
+        rescue_from(*errors) { |error| durable_job.halted!(error) }
+      end
+
+      # This class's runs, newest first. `for(*args, **kwargs)` on the relation
+      # finds the runs `perform_later(*args, **kwargs)` would have created;
+      # `for(workflow_key: "...")` matches a key verbatim.
+      def workflow_runs = Run.where(job_class: name).newest_first
+
+      # Macros write to this class's own copy of its parent's configuration.
+      def durable_config # :nodoc:
+        @durable_config ||= superclass.respond_to?(:durable_config) ? superclass.durable_config.inherit(self) : Config.new(self)
+      end
+    end
+
+    # Creates the run before the job is handed to the adapter, so that the row is
+    # part of the caller's transaction when enqueuing is deferred to after commit.
+    # A retry or resume (same `job_id`) finds the row and only updates its status.
+    def enqueue(options = {})
+      durable_job.workflow_key = options[:workflow_key]&.to_s
+      return false unless durable_job.enqueued! # `on_conflict: :skip`: nothing to enqueue
+
+      super
+    end
+
+    # Supports `set(workflow_key: "...")`to provide an explicit workflow (not run) identifier.
+    def set(options = {}) # :nodoc:
+      durable_job.workflow_key = options[:workflow_key]&.to_s
+      super
+    end
+
+    # Continuable's `step`, plus a timer (`wait:` or
+    # `wait_until:`):
+    #
+    #   step :remind, wait_until: license.expires_at - 2.weeks
+    #   step :revoke, wait: 2.weeks
+    #
+    def step(step_name, wait: nil, wait_until: nil, **, &block)
+      raise ArgumentError, "Step '#{step_name}' takes wait: or wait_until:, not both" if wait && wait_until
+
+      super
+    end
+
+    # A step that waits for a signal from outside (`Run#wake_up(name, value)`):
+    #
+    #   await :confirmation, wait: 10.minutes
+    #
+    #   def confirmation(signal) = self.confirmed = signal.presence
+    #
+    # Reaching the line parks the run as `awaiting` until the signal arrives or
+    # the deadline (`wait:` or `wait_until:`, none by default) passes; the method
+    # named after the signal, or the block, then runs as the step's body with the
+    # value, `nil` at the deadline. A signal sent before the line is reached is
+    # consumed on the spot. The step row's cursor keeps the value, so a crash in
+    # the handler replays it; a `halt!` in the handler awaits again on resume.
+    def await(name, wait: nil, wait_until: nil, &block)
+      handler = block || step_method_block(name)
+      step(name, wait:, wait_until:, await: true) { handler.call(durable_job.await_value) }
+    end
+
+    # Stops the run from inside a step: status `halted` with `halt_reason`, the
+    # step row keeps its cursor, and the job's serialized form is parked on the run.
+    def halt!(reason = nil)
+      raise ArgumentError, "halt! must be called inside a step" unless current_step
+
+      raise Halt.new(reason)
+    end
+
+    def checkpoint! # :nodoc:
+      durable_job.checkpoint!
+      super
+    end
+
+    def serialize = durable_job.serialize(super) # :nodoc:
+
+    def deserialize(job_data) # :nodoc:
+      super
+      durable_job.deserialize(job_data)
+    end
+
+    def perform_now = durable_job.perform_now { super } # :nodoc:
+
+    private
+
+    def durable_job = @durable_job ||= Execution.new(self)
+
+    def deserialize_arguments_if_needed
+      super
+      durable_job.restore!
+    end
+
+    def resume_job(exception) # :nodoc:
+      error = exception.is_a?(Hash) ? exception[:exception] : exception
+      super if durable_job.resume!(error)
+    end
+  end
+end

data/lib/ajdc/railtie.rb

@@ -1,6 +1,24 @@
 # frozen_string_literal: true
 
+require "active_job/continuation/rescue_handlers_first"
+
 module Ajdc # :nodoc:
   class Railtie < ::Rails::Railtie # :nodoc:
+    # Every option is an `ActiveJob::Durable` setting:
+    #
+    #   config.active_job_durable.connects_to = { database: { writing: :durable } }
+    #   config.active_job_durable.keep_terminal_runs_for = 30.days
+    config.active_job_durable = ActiveSupport::OrderedOptions.new
+
+    # After the config initializers, so that an initializer can set them too.
+    initializer "ajdc.config", after: :load_config_initializers do |app|
+      app.config.active_job_durable.each { |name, value| ActiveJob::Durable.public_send(:"#{name}=", value) }
+    end
+
+    initializer "ajdc.rescue_handlers_first" do
+      ActiveSupport.on_load(:active_job_continuable) do
+        prepend ActiveJob::Continuation::RescueHandlersFirst
+      end
+    end
   end
 end

data/lib/ajdc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ajdc # :nodoc:
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/ajdc.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
 require "ajdc/version"
+require "active_job/durable"
 require "ajdc/railtie" if defined?(Rails::Railtie)

data/lib/generators/ajdc/install/USAGE

@@ -0,0 +1,19 @@
+Description:
+    Creates the migration for the two tables ActiveJob::Durable writes to
+    (active_job_durable_runs and active_job_durable_steps).
+
+    Without options the migration goes to db/migrate: the tables live next to
+    the application's tables, and a run is created in the same transaction as
+    the record that starts it.
+
+    With --database=NAME the migration goes to that database's migrations_paths
+    (from config/database.yml) and an initializer points ActiveJob::Durable at
+    it. Declare the database first, or follow the printed instructions.
+
+Example:
+    bin/rails generate ajdc:install
+        db/migrate/TIMESTAMP_create_active_job_durable_tables.rb
+
+    bin/rails generate ajdc:install --database=durable
+        db/durable_migrate/TIMESTAMP_create_active_job_durable_tables.rb
+        config/initializers/active_job_durable.rb

data/lib/generators/ajdc/install/install_generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Ajdc
+  # Creates the migration for the tables ActiveJob::Durable writes to:
+  #
+  #   bin/rails generate ajdc:install                      # the primary database
+  #   bin/rails generate ajdc:install --database=durable   # a separate database, plus the initializer
+  #
+  # With `--database`, the migration lands in that database's `migrations_paths`
+  # (as `rails generate migration --database` does) and an initializer points
+  # `ActiveJob::Durable` at it. The database itself is declared in
+  # config/database.yml by the app.
+  class InstallGenerator < Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :database, type: :string, aliases: %i[--db],
+      desc: "The database for the tables. By default, the current environment's primary database is used."
+
+    def create_migration_file
+      migration_template "create_active_job_durable_tables.rb.tt", File.join(db_migrate_path, "create_active_job_durable_tables.rb")
+    end
+
+    def create_initializer
+      return unless options[:database]
+
+      template "initializer.rb.tt", "config/initializers/active_job_durable.rb"
+    end
+
+    def show_database_instructions
+      return unless options[:database]
+      return if database_configured?
+
+      say <<~TEXT
+
+        Add the database to config/database.yml, then run bin/rails db:prepare:
+
+          #{options[:database]}:
+            <<: *default
+            database: storage/#{options[:database]}.sqlite3   # or your adapter's settings
+            migrations_paths: db/#{options[:database]}_migrate
+
+      TEXT
+    end
+
+    private
+
+    # Rails resolves `--database` through config/database.yml; a database that is
+    # not declared yet gets the conventional path, which the instructions name.
+    def db_migrate_path
+      return super if options[:database].nil? || database_configured?
+
+      "db/#{options[:database]}_migrate"
+    end
+
+    def database_configured?
+      ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: options[:database]).present?
+    rescue
+      false
+    end
+  end
+end

data/lib/generators/ajdc/install/templates/create_active_job_durable_tables.rb.tt

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Tables for ActiveJob::Durable: one row per run, one row per step attempt.
+# The gem's own test suite loads the same definition from db/durable_schema.rb.
+class CreateActiveJobDurableTables < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :active_job_durable_runs, if_not_exists: true do |t|
+      t.string :job_class, null: false
+      t.string :key, null: false
+      t.string :active_key
+      t.string :active_job_id, null: false
+      t.json :arguments, null: false
+      t.string :status, null: false
+      t.string :current_step
+      t.json :completed_steps, null: false
+      t.json :state, null: false
+      t.datetime :wake_at
+      t.json :pending_signals, null: false
+      t.json :parked_job
+      t.integer :resumptions, default: 0, null: false
+      t.datetime :last_heartbeat_at
+      t.string :error_class
+      t.text :error_message
+      t.string :halt_reason
+      t.datetime :started_at
+      t.datetime :finished_at
+      t.datetime :transitioned_at
+      t.timestamps
+
+      t.index [:job_class, :active_key], name: "index_active_job_durable_runs_on_active_key", unique: true
+      t.index [:job_class, :key], name: "index_active_job_durable_runs_on_key"
+      t.index [:active_job_id], name: "index_active_job_durable_runs_on_active_job_id", unique: true
+      t.index [:status], name: "index_active_job_durable_runs_on_status"
+      t.index [:status, :wake_at], name: "index_active_job_durable_runs_on_status_and_wake_at"
+      t.index [:status, :transitioned_at], name: "index_active_job_durable_runs_on_status_and_transitioned_at"
+    end
+
+    create_table :active_job_durable_steps, if_not_exists: true do |t|
+      t.references :run, null: false, index: false,
+        foreign_key: { to_table: :active_job_durable_runs, on_delete: :cascade }
+      t.string :name, null: false
+      t.integer :position, null: false
+      t.integer :attempt, default: 1, null: false
+      t.string :status, null: false
+      t.json :cursor
+      t.boolean :isolated, default: false, null: false
+      t.string :error_class
+      t.text :error_message
+      t.datetime :started_at
+      t.datetime :finished_at
+
+      t.index [:run_id, :name, :attempt], name: "index_active_job_durable_steps_on_attempt", unique: true
+      t.index [:run_id, :position], name: "index_active_job_durable_steps_on_position"
+    end
+  end
+end

data/lib/generators/ajdc/install/templates/initializer.rb.tt

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# ActiveJob::Durable keeps its runs and steps in the "<%= options[:database] %>" database.
+Rails.application.config.active_job_durable.connects_to = { database: { writing: :<%= options[:database] %> } }