geneva_drive 0.8.0 → 0.9.0

data/lib/geneva_drive/job_options.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Validation helper for Active Job option hashes passed through the workflow DSL
+# Validation helper for step job option hashes passed through the workflow DSL
 # (`set_step_job_options`, `step(job_options: ...)`, and `workflow.step_job_options=`).
 #
 # Active Job itself silently ignores unknown keys in `set` — a typo like
@@ -8,7 +8,9 @@
 # priority. This helper enforces the known key set so misconfigurations surface
 # at definition time, or at assignment time for per-instance overrides.
 #
-# The allowed keys mirror what `ActiveJob::Core#set` actually consumes.
+# The allowed keys mirror what `ActiveJob::Core#set` actually consumes. The
+# configured dispatcher then gets a say: the Sidekiq one rejects `priority`,
+# which Sidekiq has no notion of.
 #
 # @api private
 module GenevaDrive::JobOptions
@@ -25,7 +27,8 @@ module GenevaDrive::JobOptions
   #   (e.g. "Step 'foo'" or "MyWorkflow.step_job_options")
   # @return [Hash{Symbol=>Object}] symbolized copy safe to pass to `.set`
   # @raise [GenevaDrive::StepConfigurationError] if options can't be coerced to
-  #   a Hash, contains unknown keys, or has values of the wrong type
+  #   a Hash, contains unknown keys, has values of the wrong type, or uses a
+  #   key the configured dispatcher cannot honour
   def self.validate!(options, context:)
     hash = begin
       options.to_h
@@ -44,6 +47,7 @@ module GenevaDrive::JobOptions
     end
 
     symbolized.each { |k, v| validate_value!(k, v, context) }
+    GenevaDrive.dispatcher.validate_job_options!(symbolized, context: context)
     symbolized
   end
 

data/lib/geneva_drive/jobs/perform_step_job.rb

@@ -13,6 +13,8 @@
 #   PerformStepJob.perform_now(step_execution.id)
 #
 class GenevaDrive::PerformStepJob < ActiveJob::Base
+  include GenevaDrive::StepExecutionLookup
+
   # == CRITICAL: Prevent double-deferral of job enqueueing ==
   #
   # GenevaDrive already defers job enqueueing using `ActiveRecord.after_all_transactions_commit`
@@ -83,39 +85,4 @@ class GenevaDrive::PerformStepJob < ActiveJob::Base
     logger.debug("PerformStepJob starting execution for step #{step_execution_id}")
     GenevaDrive::Executor.execute!(step_execution, logger: logger)
   end
-
-  private
-
-  # Retries the step execution lookup briefly to handle the (unlikely) case where
-  # the job is picked up before the step execution's transaction is visible to this
-  # database connection.
-  #
-  # This is a defense-in-depth measure. The primary protection against visibility
-  # issues is the combination of:
-  #   1. `after_all_transactions_commit` in Workflow#create_step_execution, which ensures
-  #      `perform_later` is only called after the step execution row is committed
-  #   2. `enqueue_after_transaction_commit = :never` (above), which ensures the queue
-  #      adapter INSERT happens synchronously, not deferred into a dead callback
-  #
-  # However, this retry handles additional edge cases:
-  #   - Database replication lag (read replica hasn't caught up with the writer)
-  #   - Future code paths that might call perform_later inside a transaction
-  #   - Any other visibility delay between the commit and the job worker's read
-  #
-  # The 500ms total window (5 x 100ms) is generous enough to handle typical
-  # replication lag while being short enough to fail fast if the record truly
-  # doesn't exist (e.g. it was already deleted by cleanup).
-  #
-  # @param id [Integer, String] the step execution ID to look up
-  # @param attempts [Integer] maximum number of lookup attempts
-  # @param delay [Float] seconds to sleep between attempts
-  # @return [GenevaDrive::StepExecution, nil] the step execution or nil if not found
-  def find_step_execution(id, attempts: 5, delay: 0.1)
-    attempts.times do |i|
-      record = GenevaDrive::StepExecution.find_by(id: id)
-      return record if record
-      sleep(delay) if i < attempts - 1
-    end
-    nil
-  end
 end

data/lib/geneva_drive/jobs/sidekiq_housekeeping_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+# Sidekiq job that runs GenevaDrive's housekeeping, for apps that schedule
+# periodic work with Sidekiq Enterprise or sidekiq-cron rather than an
+# Active Job backend. It runs the same code as HousekeepingJob, in-process.
+#
+# @example Sidekiq Enterprise periodic jobs
+#   Sidekiq.configure_server do |config|
+#     config.periodic do |mgr|
+#       mgr.register("*/15 * * * *", "GenevaDrive::SidekiqHousekeepingJob")
+#     end
+#   end
+#
+# @example sidekiq-cron
+#   Sidekiq::Cron::Job.create(
+#     name: "GenevaDrive housekeeping",
+#     cron: "*/15 * * * *",
+#     class: "GenevaDrive::SidekiqHousekeepingJob"
+#   )
+class GenevaDrive::SidekiqHousekeepingJob
+  include ::Sidekiq::Job
+
+  # The next scheduled run is the retry.
+  sidekiq_options queue: "default", retry: false, tags: ["geneva_drive"]
+
+  # @return [Hash] summary of actions taken, as returned by HousekeepingJob
+  def perform
+    GenevaDrive::HousekeepingJob.perform_now
+  end
+end

data/lib/geneva_drive/jobs/sidekiq_perform_step_job.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+# Sidekiq job that executes a scheduled step execution - the native
+# counterpart of PerformStepJob, pushed by GenevaDrive::SidekiqDispatcher.
+#
+# Retries are off because exception policies decide reattempts, each as a new
+# step execution. The step's exception is still raised, so error handlers report it.
+class GenevaDrive::SidekiqPerformStepJob
+  include ::Sidekiq::Job
+  include GenevaDrive::StepExecutionLookup
+
+  sidekiq_options queue: "default", retry: false, tags: ["geneva_drive"]
+
+  # @param step_execution_id [Integer, String] the ID of the step execution
+  # @return [void]
+  def perform(step_execution_id)
+    step_execution = find_step_execution(step_execution_id)
+
+    unless step_execution
+      logger.warn("StepExecution #{step_execution_id} not found, skipping")
+      return
+    end
+
+    # So that Sidekiq's own log lines for this job carry the workflow and step
+    ::Sidekiq::Context.with(
+      geneva_drive_workflow_id: step_execution.workflow_id,
+      geneva_drive_step: step_execution.step_name,
+      geneva_drive_step_execution_id: step_execution.id
+    ) do
+      GenevaDrive::Executor.execute!(step_execution)
+    end
+  end
+end

data/lib/geneva_drive/jobs/step_execution_lookup.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Finds the step execution a job was enqueued for, retrying briefly when it is
+# not visible yet. Shared by PerformStepJob and SidekiqPerformStepJob.
+#
+# @api private
+module GenevaDrive::StepExecutionLookup
+  private
+
+  # Retries the step execution lookup briefly to handle the (unlikely) case where
+  # the job is picked up before the step execution's transaction is visible to this
+  # database connection.
+  #
+  # This is a defense-in-depth measure. The primary protection against visibility
+  # issues is the combination of:
+  #   1. `after_all_transactions_commit` in Workflow#create_step_execution, which ensures
+  #      the dispatcher is only called after the step execution row is committed
+  #   2. Both dispatchers pushing synchronously from that callback, rather than
+  #      deferring a second time into a callback that may never fire
+  #
+  # However, this retry handles additional edge cases:
+  #   - Database replication lag (read replica hasn't caught up with the writer)
+  #   - Future code paths that might enqueue inside a transaction
+  #   - Any other visibility delay between the commit and the job worker's read
+  #
+  # The 500ms total window (5 x 100ms) is generous enough to handle typical
+  # replication lag while being short enough to fail fast if the record truly
+  # doesn't exist (e.g. it was already deleted by cleanup).
+  #
+  # @param id [Integer, String] the step execution ID to look up
+  # @param attempts [Integer] maximum number of lookup attempts
+  # @param delay [Float] seconds to sleep between attempts
+  # @return [GenevaDrive::StepExecution, nil] the step execution or nil if not found
+  def find_step_execution(id, attempts: 5, delay: 0.1)
+    attempts.times do |i|
+      record = GenevaDrive::StepExecution.find_by(id: id)
+      return record if record
+      sleep(delay) if i < attempts - 1
+    end
+    nil
+  end
+end

data/lib/geneva_drive/migration_helpers.rb

@@ -9,13 +9,17 @@
 #
 #     def change
 #       create_table :geneva_drive_workflows, **geneva_drive_table_options do |t|
-#         t.references :hero, polymorphic: true, type: geneva_drive_key_type
+#         t.references :hero, polymorphic: true, type: geneva_drive_hero_key_type
 #         # ...
 #       end
 #     end
 #   end
 #
 module GenevaDrive::MigrationHelpers
+  UUID_SQL_TYPE = /uuid|char\(36\)|varchar\(36\)/
+  # SQLite reports `id: :string` as a bare "varchar", without a length
+  STRING_SQL_TYPE = /char|text|clob/
+
   # Detects the appropriate key type for GenevaDrive tables.
   # Returns :uuid if the schema predominantly uses UUIDs, otherwise :bigint.
   #
@@ -25,13 +29,39 @@ module GenevaDrive::MigrationHelpers
       id_columns = _geneva_drive_app_id_columns
       return :bigint if id_columns.empty?
 
-      uuid_count = id_columns.count { |col| col.sql_type.downcase.match?(/uuid|char\(36\)|varchar\(36\)/) }
+      uuid_count = id_columns.count { |col| col.sql_type.downcase.match?(UUID_SQL_TYPE) }
       other_count = id_columns.size - uuid_count
 
       (uuid_count > other_count) ? :uuid : :bigint
     end
   end
 
+  # Detects the column type for `hero_id` on the workflows table. Unlike
+  # {#geneva_drive_key_type}, this also recognizes string primary keys of any
+  # length (`varchar`, `char(n)`, `text`), so that heroes with string ids do not
+  # get a `hero_id` that casts their ids to integers.
+  #
+  # Returns :uuid if the schema predominantly uses UUIDs, :string if it predominantly
+  # uses UUIDs and string ids taken together, otherwise :bigint.
+  #
+  # @return [Symbol] :uuid, :string or :bigint
+  def geneva_drive_hero_key_type
+    @_geneva_drive_hero_key_type ||= begin
+      sql_types = _geneva_drive_app_id_columns.map { |col| col.sql_type.downcase }
+      uuid_count = sql_types.count { |t| t.match?(UUID_SQL_TYPE) }
+      string_count = sql_types.count { |t| !t.match?(UUID_SQL_TYPE) && t.match?(STRING_SQL_TYPE) }
+      integer_count = sql_types.size - uuid_count - string_count
+
+      if uuid_count > string_count + integer_count
+        :uuid
+      elsif uuid_count + string_count > integer_count
+        :string # a string column holds UUIDs just as well
+      else
+        :bigint
+      end
+    end
+  end
+
   # Returns options hash for create_table based on detected primary key type.
   # When UUIDs are detected, includes the most common default function from
   # existing tables so that new tables match the application's convention
@@ -96,7 +126,7 @@ module GenevaDrive::MigrationHelpers
   def _geneva_drive_dominant_uuid_default
     id_columns = _geneva_drive_app_id_columns
     uuid_defaults = id_columns.filter_map do |col|
-      next unless col.sql_type.downcase.match?(/uuid|char\(36\)|varchar\(36\)/)
+      next unless col.sql_type.downcase.match?(UUID_SQL_TYPE)
       col.default_function
     end
 

data/lib/geneva_drive/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GenevaDrive
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/geneva_drive/workflow.rb

@@ -312,8 +312,8 @@ class GenevaDrive::Workflow < ActiveRecord::Base
       _cancel_conditions << block if block_given?
     end
 
-    # Sets job options for step execution jobs.
-    # Options are passed to ActiveJob's set method.
+    # Sets job options for step execution jobs. See GenevaDrive::JobOptions
+    # for the keys allowed, and the dispatcher for how they are applied.
     #
     # @param options [Hash] job options (queue, priority, etc.)
     # @return [void]
@@ -1104,7 +1104,7 @@ class GenevaDrive::Workflow < ActiveRecord::Base
     signal
   end
 
-  # Enqueues the PerformStepJob for an execution that dispatch just flipped
+  # Enqueues the step job for an execution that dispatch just flipped
   # from waiting to scheduled. Uses the same enqueue discipline (merged job
   # options, after-commit deferral, job_id writeback) as create_step_execution.
   #
@@ -1117,15 +1117,7 @@ class GenevaDrive::Workflow < ActiveRecord::Base
     workflow_logger = logger
 
     run_after_commit do
-      job = GenevaDrive::PerformStepJob
-        .set(**job_options)
-        .perform_later(execution_id)
-
-      workflow_logger.debug("Enqueued PerformStepJob with job_id=#{job.job_id} for woken step execution #{execution_id}")
-
-      GenevaDrive::StepExecution
-        .where(id: execution_id)
-        .update_all(job_id: job.job_id)
+      dispatch_step_job(execution_id, job_options, logger: workflow_logger)
     end
   end
 
@@ -1190,12 +1182,9 @@ class GenevaDrive::Workflow < ActiveRecord::Base
     # PerformStepJob sets `enqueue_after_transaction_commit = :never` -- without it,
     # ActiveJob/SolidQueue would see the transaction as "open" and defer the queue
     # INSERT to a second "after commit" that never fires (the double-deferral bug).
+    # SidekiqDispatcher bypasses Sidekiq's transactional push for the same reason.
     run_after_commit do
-      job = GenevaDrive::PerformStepJob
-        .set(**job_options)
-        .perform_later(execution_id)
-
-      workflow_logger.debug("Enqueued job #{job.job_id} for step execution #{execution_id}")
+      dispatch_step_job(execution_id, job_options, logger: workflow_logger)
     end
 
     step_execution
@@ -1245,15 +1234,7 @@ class GenevaDrive::Workflow < ActiveRecord::Base
       workflow_logger = logger
 
       run_after_commit do
-        job = GenevaDrive::PerformStepJob
-          .set(**job_options)
-          .perform_later(successor_id)
-
-        workflow_logger.debug("Enqueued PerformStepJob with job_id=#{job.job_id} for successor execution ##{successor_id}")
-
-        GenevaDrive::StepExecution
-          .where(id: successor_id)
-          .update_all(job_id: job.job_id)
+        dispatch_step_job(successor_id, job_options, logger: workflow_logger)
       end
 
       successor
@@ -1301,17 +1282,9 @@ class GenevaDrive::Workflow < ActiveRecord::Base
       # without it, ActiveJob/SolidQueue would see the transaction as "open" and defer
       # the queue INSERT to a second "after commit" that never fires (the double-deferral
       # bug). See the extensive comment in PerformStepJob for the full explanation.
+      # SidekiqDispatcher bypasses Sidekiq's transactional push for the same reason.
       run_after_commit do
-        job = GenevaDrive::PerformStepJob
-          .set(**job_options)
-          .perform_later(execution_id)
-
-        workflow_logger.debug("Enqueued PerformStepJob with job_id=#{job.job_id} for step execution #{execution_id}")
-
-        # Update job_id for debugging purposes (this is a separate transaction)
-        GenevaDrive::StepExecution
-          .where(id: execution_id)
-          .update_all(job_id: job.job_id)
+        dispatch_step_job(execution_id, job_options, logger: workflow_logger)
       end
 
       step_execution
@@ -1347,6 +1320,26 @@ class GenevaDrive::Workflow < ActiveRecord::Base
     nil
   end
 
+  # Hands a step execution to the configured dispatcher (GenevaDrive.dispatcher)
+  # and writes the returned job id onto the execution, so that the job can be
+  # found from the row. Always called from inside run_after_commit.
+  #
+  # @param execution_id [Integer, String] the step execution to perform
+  # @param job_options [Hash] merged, validated job options
+  # @param logger [Logger] the workflow logger captured before the commit
+  # @return [void]
+  def dispatch_step_job(execution_id, job_options, logger:)
+    job_id = GenevaDrive.dispatcher.enqueue_step(execution_id, job_options, workflow_class_name: self.class.name)
+
+    logger.debug("Enqueued step job with job_id=#{job_id} for step execution #{execution_id}")
+
+    # A separate statement, outside any transaction - the job may already be running.
+    # resume! re-enqueues an existing execution, so this overwrites the old job's id.
+    GenevaDrive::StepExecution
+      .where(id: execution_id)
+      .update_all(job_id: job_id)
+  end
+
   # Runs a block either after all transactions commit or immediately.
   #
   # The behavior depends on GenevaDrive.enqueues_deferred?, which checks:
@@ -1360,7 +1353,7 @@ class GenevaDrive::Workflow < ActiveRecord::Base
   # In tests (enqueue_after_commit = false), or inside a
   # without_deferred_enqueues block, the block runs immediately.
   #
-  # @yield the block to run (typically contains perform_later call)
+  # @yield the block to run (typically hands a step to the dispatcher)
   # @return [void]
   def run_after_commit(&block)
     if GenevaDrive.enqueues_deferred?

data/lib/geneva_drive.rb

@@ -54,9 +54,16 @@ module GenevaDrive
   autoload :MigrationHelpers, "geneva_drive/migration_helpers"
   autoload :TestHelpers, "geneva_drive/test_helpers"
 
+  # Dispatchers
+  autoload :ActiveJobDispatcher, "geneva_drive/dispatchers/active_job_dispatcher"
+  autoload :SidekiqDispatcher, "geneva_drive/dispatchers/sidekiq_dispatcher"
+
   # Jobs
+  autoload :StepExecutionLookup, "geneva_drive/jobs/step_execution_lookup"
   autoload :PerformStepJob, "geneva_drive/jobs/perform_step_job"
   autoload :HousekeepingJob, "geneva_drive/jobs/housekeeping_job"
+  autoload :SidekiqPerformStepJob, "geneva_drive/jobs/sidekiq_perform_step_job"
+  autoload :SidekiqHousekeepingJob, "geneva_drive/jobs/sidekiq_housekeeping_job"
 
   class << self
     # How long to keep completed workflows before cleanup.
@@ -180,6 +187,62 @@ module GenevaDrive
       Thread.current[:geneva_drive_inline_enqueue] = previous
     end
 
+    # Turns "this step execution should run" into a job: `:active_job` (the
+    # default, see ActiveJobDispatcher) or `:sidekiq` (see SidekiqDispatcher).
+    # Set it in an initializer, before any workflow class loads, since step
+    # job options are validated against it when a workflow class is defined.
+    #
+    # @example Run step jobs as native Sidekiq jobs
+    #   GenevaDrive.dispatcher = :sidekiq
+    #
+    # @return [#enqueue_step, #validate_job_options!]
+    def dispatcher
+      @dispatcher ||= GenevaDrive::ActiveJobDispatcher.new
+    end
+
+    # @param value [Symbol, #enqueue_step] `:active_job`, `:sidekiq`, or a
+    #   dispatcher object
+    # @return [void]
+    # @raise [ArgumentError] for anything else
+    def dispatcher=(value)
+      @dispatcher = case value
+      when :active_job
+        GenevaDrive::ActiveJobDispatcher.new
+      when :sidekiq
+        GenevaDrive::SidekiqDispatcher.new
+      else
+        unless value.respond_to?(:enqueue_step) && value.respond_to?(:validate_job_options!)
+          raise ArgumentError,
+            "GenevaDrive.dispatcher must be :active_job, :sidekiq, or an object responding to " \
+            "enqueue_step and validate_job_options! (got #{value.inspect})"
+        end
+        value
+      end
+    end
+
+    # Tells resumable steps running in this process to hand off at their next
+    # iteration boundary. Wired to Sidekiq's :quiet event by the engine, which
+    # fires on TSTP and at the start of every shutdown. Process-wide, unlike
+    # the thread-local flag the executor also honours.
+    #
+    # @return [void]
+    # @api private
+    def request_exit!
+      @exit_requested = true
+    end
+
+    # @return [Boolean] whether the host process asked running work to stop
+    # @api private
+    def exit_requested?
+      @exit_requested == true
+    end
+
+    # @return [void]
+    # @api private
+    def reset_exit_request!
+      @exit_requested = false
+    end
+
     # Returns true if job enqueueing should be deferred to after transaction commit.
     #
     # @return [Boolean]

data/test/dummy/config/initializers/geneva_drive.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 
-# license: LGPLv3.0
+# How step jobs reach your queue.
+# - :active_job (the default) enqueues GenevaDrive::PerformStepJob through
+#   Active Job, onto whatever adapter the app uses.
+# - :sidekiq pushes GenevaDrive::SidekiqPerformStepJob, a plain Sidekiq::Job,
+#   straight through Sidekiq::Client - for apps that write Sidekiq jobs rather
+#   than Active Job ones. Schedule GenevaDrive::SidekiqHousekeepingJob then.
+#   Supports Sidekiq 7.3 and later 7.x, and 8.x.
+#
+# GenevaDrive.dispatcher = :active_job
 
 # How long to keep completed/canceled workflows before automatic deletion.
 # Set to nil to disable automatic cleanup.
@@ -9,12 +17,12 @@
 #
 # GenevaDrive.delete_completed_workflows_after = 30.days
 
-# How long a step execution can be in "executing" state before being
+# How long a step execution can be in "in_progress" state before being
 # considered stuck. This typically happens when a worker process crashes
 # mid-execution. The HousekeepingJob will recover these based on the
 # stuck_recovery_action setting.
 #
-# GenevaDrive.stuck_executing_threshold = 1.hour
+# GenevaDrive.stuck_in_progress_threshold = 1.hour
 
 # How long a step execution can be past its scheduled_for time while
 # still in "scheduled" state before being considered stuck. This can
@@ -33,6 +41,30 @@
 #
 # GenevaDrive.housekeeping_batch_size = 1000
 
+# Maximum size in bytes of a resumable step cursor once serialized to JSON.
+# The cursor is a position marker (an id, page number, or pagination token),
+# not a place to store the data being processed - it is rewritten on every
+# checkpoint and copied to every successor execution. Exceeding the limit
+# raises GenevaDrive::CursorTooLargeError. Set to nil to disable the check.
+#
+# GenevaDrive.max_cursor_size = 128.kilobytes
+
+# Maximum size in bytes of a signal payload once serialized to JSON.
+# A payload describes an event (an order id, an amount, a decision), not the
+# data the step is going to work on - that belongs on the hero. Exceeding the
+# limit raises GenevaDrive::SignalPayloadTooLargeError from Workflow#signal!,
+# before anything is persisted. Set to nil to disable the check.
+#
+# GenevaDrive.max_signal_payload_size = 128.kilobytes
+
+# How long a step execution may sit in the "waiting" state before
+# housekeeping counts it in the geneva_drive.waiting_overdue gauge.
+# Waiting indefinitely is legitimate, so this is not a timeout - it keeps
+# a stalled rendezvous from going unnoticed. Alert on the overdue gauge.
+# Set to nil to disable the gauge.
+#
+# GenevaDrive.waiting_visibility_threshold = 7.days
+
 # Whether to defer job enqueueing until after the database transaction commits.
 # In production this ensures step execution records are visible to job workers
 # before the job runs. In test environments (the default when Rails.env.test?)

data/test/dummy/db/mysql/schema-8.1.rb

@@ -0,0 +1,95 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema[8.1].define(version: 2026_10_25_000614) do
+  create_table "geneva_drive_signals", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
+    t.bigint "workflow_id", null: false
+    t.string "name", null: false
+    t.string "idempotency_key"
+    t.string "state", default: "pending", null: false
+    t.json "payload"
+    t.datetime "claimed_at"
+    t.datetime "consumed_at"
+    t.bigint "claimed", default: 0, null: false
+    t.bigint "consumed", default: 0, null: false
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["workflow_id", "name", "idempotency_key"], name: "index_geneva_drive_signals_dedup", unique: true
+    t.index ["workflow_id", "state"], name: "index_geneva_drive_signals_on_workflow_id_and_state"
+    t.index ["workflow_id"], name: "index_geneva_drive_signals_on_workflow_id"
+  end
+
+  create_table "geneva_drive_step_executions", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
+    t.bigint "workflow_id", null: false
+    t.string "step_name", null: false
+    t.string "state", default: "scheduled", null: false
+    t.string "outcome"
+    t.datetime "scheduled_for", null: false
+    t.datetime "started_at"
+    t.datetime "completed_at"
+    t.datetime "failed_at"
+    t.datetime "canceled_at"
+    t.datetime "skipped_at"
+    t.string "error_class_name"
+    t.text "error_message"
+    t.text "error_backtrace"
+    t.string "job_id"
+    t.text "metadata", size: :long
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.virtual "active_unique_key", type: :string, limit: 767, as: "(case when (`state` in (_utf8mb4'scheduled',_utf8mb4'in_progress')) then cast(`workflow_id` as char charset utf8mb4) else NULL end)", stored: true
+    t.datetime "finished_at"
+    t.json "cursor"
+    t.bigint "continues_from_id"
+    t.bigint "signal_id"
+    t.datetime "waiting_since"
+    t.index ["active_unique_key"], name: "index_geneva_drive_step_executions_one_active", unique: true
+    t.index ["continues_from_id"], name: "index_geneva_drive_step_executions_on_continues_from_id"
+    t.index ["finished_at"], name: "index_geneva_drive_step_executions_on_finished_at"
+    t.index ["scheduled_for"], name: "index_geneva_drive_step_executions_on_scheduled_for"
+    t.index ["signal_id"], name: "index_geneva_drive_step_executions_on_signal_id"
+    t.index ["state", "scheduled_for"], name: "index_geneva_drive_step_executions_scheduled"
+    t.index ["state", "started_at"], name: "index_geneva_drive_step_executions_in_progress_started_at"
+    t.index ["state"], name: "index_geneva_drive_step_executions_on_state"
+    t.index ["workflow_id", "created_at"], name: "idx_on_workflow_id_created_at_af16a14fb2"
+    t.index ["workflow_id", "state"], name: "index_geneva_drive_step_executions_on_workflow_id_and_state"
+    t.index ["workflow_id"], name: "index_geneva_drive_step_executions_on_workflow_id"
+  end
+
+  create_table "geneva_drive_workflows", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
+    t.string "type", null: false
+    t.string "hero_type"
+    t.bigint "hero_id"
+    t.string "state", default: "ready", null: false
+    t.string "current_step_name"
+    t.string "next_step_name"
+    t.boolean "allow_multiple", default: false, null: false
+    t.text "metadata", size: :long
+    t.datetime "started_at"
+    t.datetime "transitioned_at"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.virtual "ongoing_unique_key", type: :string, limit: 767, as: "(case when ((`state` not in (_utf8mb4'finished',_utf8mb4'canceled')) and (`allow_multiple` = 0)) then concat(`type`,_utf8mb4'-',`hero_type`,_utf8mb4'-',`hero_id`) else NULL end)", stored: true
+    t.index ["hero_type", "hero_id"], name: "index_geneva_drive_workflows_on_hero_type_and_hero_id"
+    t.index ["ongoing_unique_key"], name: "index_geneva_drive_workflows_unique_ongoing", unique: true
+    t.index ["state"], name: "index_geneva_drive_workflows_on_state"
+    t.index ["type"], name: "index_geneva_drive_workflows_on_type"
+  end
+
+  create_table "users", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
+    t.string "email", null: false
+    t.string "name"
+    t.boolean "active", default: true
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+end