geneva_drive 0.7.0 → 0.8.0

data/lib/geneva_drive/step_collection.rb

@@ -65,30 +65,54 @@ class GenevaDrive::StepCollection
     ordered_steps[position]
   end
 
-  # Returns the next step after the given step name.
+  # Returns the next runnable step after the given step name.
+  #
+  # Steps declared with `removed_step` are stepped over: they hold a position
+  # in the sequence so that executions scheduled before their removal still
+  # resolve, but no execution is ever scheduled for one.
+  #
+  # A nil current_name means "the beginning", so the first runnable step is
+  # returned - which is how the first step of a workflow is chosen.
   #
   # @param current_name [String, Symbol, nil] the current step name
-  # @return [StepDefinition, nil] the next step or nil if at end
+  # @return [StepDefinition, nil] the next runnable step or nil if at end
   def next_after(current_name)
-    return first if current_name.nil?
+    return ordered_steps.find { |s| !s.removed? } if current_name.nil?
 
     current_index = ordered_steps.index { |s| s.name == current_name.to_s }
     return nil unless current_index
 
-    self[current_index + 1]
+    ordered_steps[(current_index + 1)..].find { |s| !s.removed? }
   end
 
-  # Returns the step before the given step name in the ordered sequence.
+  # Returns the previous runnable step before the given step name in the
+  # ordered sequence. Removed steps are stepped over, for the same reason
+  # {#next_after} steps over them.
   #
   # @param current_name [String, Symbol, nil] the current step name
-  # @return [StepDefinition, nil] the previous step or nil if at beginning
+  # @return [StepDefinition, nil] the previous runnable step or nil if at beginning
   def previous_before(current_name)
     return nil if current_name.nil?
 
     current_index = find_index { |s| s.name == current_name.to_s }
     return nil unless current_index && current_index > 0
 
-    self[current_index - 1]
+    ordered_steps[0...current_index].reverse_each.find { |s| !s.removed? }
+  end
+
+  # Returns the steps that can actually run, in order, with `removed_step`
+  # gravestones filtered out.
+  #
+  # @return [Array<StepDefinition>] the runnable step definitions
+  def runnable
+    ordered_steps.reject(&:removed?)
+  end
+
+  # Returns the `removed_step` gravestones, in order.
+  #
+  # @return [Array<StepDefinition>] the removed step definitions
+  def removed
+    ordered_steps.select(&:removed?)
   end
 
   # Checks if a step exists with the given name.

data/lib/geneva_drive/step_definition.rb

@@ -131,6 +131,15 @@ class GenevaDrive::StepDefinition
     false
   end
 
+  # Returns whether this step is a gravestone left by `removed_step`.
+  # Removed steps keep their name resolvable for executions scheduled before
+  # the step was taken out, but are never scheduled and never run.
+  #
+  # @return [Boolean] false for standard steps
+  def removed?
+    false
+  end
+
   # Whether this step parks until a matching signal arrives.
   #
   # @return [Boolean]

data/lib/geneva_drive/step_execution.rb

@@ -20,6 +20,7 @@ class GenevaDrive::StepExecution < ActiveRecord::Base
 
   require_relative "step_execution/metadata_accessor"
   include MetadataAccessor
+  include GenevaDrive::JsonColumn
 
   # Step execution states as enum with string values
   # Provides: scheduled?, in_progress?, etc. predicates
@@ -162,7 +163,7 @@ class GenevaDrive::StepExecution < ActiveRecord::Base
         end
       end
 
-      serialized
+      encode_json_column(:cursor, serialized)
     end
   end
 
@@ -250,7 +251,7 @@ class GenevaDrive::StepExecution < ActiveRecord::Base
   def cursor_value
     return nil unless self.class.resumable_columns?
     return nil if cursor.blank?
-    ActiveJob::Arguments.deserialize([cursor]).first
+    ActiveJob::Arguments.deserialize([self.class.decode_json_column(:cursor, cursor)]).first
   end
 
   # Sets the cursor value for resumable steps.

data/lib/geneva_drive/version.rb

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

data/lib/geneva_drive/workflow.rb

@@ -206,6 +206,92 @@ class GenevaDrive::Workflow < ActiveRecord::Base
       step_def
     end
 
+    # Marks a step as removed, leaving a gravestone in the position the step
+    # used to occupy.
+    #
+    # Deleting a `step` outright is unsafe while workflows are in flight.
+    # Executions scheduled under the old name find no definition when their
+    # job runs, and the workflow pauses with {StepNotDefinedError} - stuck
+    # until an operator intervenes. The gem cannot recover from this on its
+    # own: it knows the step is gone, but not whether the work it did still
+    # needs doing, and not which of the remaining steps would have run had it
+    # executed. Only the author of the removal knows that.
+    #
+    # `removed_step` is how that knowledge gets written down. Declaring it
+    # where the step used to be says "this step no longer needs to happen,
+    # carry on past it", and the gem can then act without guessing:
+    #
+    # - Executions already scheduled for the name resolve, are skipped, and
+    #   the workflow proceeds to the next runnable step.
+    # - Scheduling never spools a new execution for the name again.
+    # - `before_step:` / `after_step:` references to it keep working.
+    #
+    # Ship the `removed_step`, let in-flight workflows drain past it, then
+    # delete the line once {.removed_steps_in_flight} comes back empty.
+    #
+    # A removed step takes a name and nothing else. There is nothing to
+    # configure about a step that does not run.
+    #
+    # @param name [String, Symbol] the name of the step that was removed
+    # @return [RemovedStepDefinition] the gravestone
+    #
+    # @example Taking a step out of a live workflow
+    #   class PaymentWorkflow < GenevaDrive::Workflow
+    #     step :authorize do
+    #       # ...
+    #     end
+    #
+    #     removed_step :capture_payment
+    #
+    #     step :send_receipt do
+    #       # ...
+    #     end
+    #   end
+    def removed_step(name)
+      raise ArgumentError, "removed_step requires a step name" if name.nil?
+
+      caller_loc = caller_locations(1, 1).first
+      call_location = caller_loc ? [caller_loc.path, caller_loc.lineno] : nil
+
+      step_name = prepare_step_registration!(name, {})
+
+      step_def = GenevaDrive::RemovedStepDefinition.new(
+        name: step_name,
+        call_location: call_location
+      )
+
+      _step_definitions << step_def
+
+      step_def
+    end
+
+    # Returns the names of this workflow's removed steps that step execution
+    # rows still reference, so a `removed_step` gravestone is only deleted
+    # once nothing can land on it any more.
+    #
+    # Each name maps to the number of rows still referencing it. An empty
+    # hash means every in-flight workflow has drained past the removal and
+    # the `removed_step` lines can go.
+    #
+    # Rows belonging to finished and canceled workflows are ignored - they
+    # will never execute again.
+    #
+    # @return [Hash{String => Integer}] removed step names to referencing row counts
+    #
+    # @example
+    #   PaymentWorkflow.removed_steps_in_flight
+    #   # => {"capture_payment" => 3}
+    def removed_steps_in_flight
+      removed_names = steps.removed.map(&:name)
+      return {} if removed_names.empty?
+
+      GenevaDrive::StepExecution
+        .where(step_name: removed_names)
+        .where(workflow_id: where.not(state: %w[finished canceled]).select(:id))
+        .group(:step_name)
+        .count
+    end
+
     # Defines a blanket cancellation condition for the workflow.
     # Checked before every step execution.
     #
@@ -566,6 +652,73 @@ class GenevaDrive::Workflow < ActiveRecord::Base
 
     # No scheduled execution exists - create one for the next step
     step_def = steps.named(next_step_name)
+
+    # The step this workflow is pointed at can be gone from the code - that is
+    # what paused it in the first place if it paused with StepNotDefinedError.
+    # Say so plainly instead of dying on nil deeper in create_step_execution,
+    # and name the way out.
+    unless step_def
+      raise GenevaDrive::StepNotDefinedError.new(
+        "Cannot resume #{self.class.name} ##{id}: step '#{next_step_name}' is no longer defined in " \
+        "#{self.class.name}. Pick the step to continue from with resume_at!(:step_name) - the steps " \
+        "still defined are #{steps.runnable.map(&:name).join(", ")} - or cancel! the workflow. To stop " \
+        "future removals from stranding workflows this way, leave a removed_step :#{next_step_name} " \
+        "gravestone in place of the deleted step.",
+        step_execution: nil,
+        workflow: self
+      )
+    end
+
+    create_step_execution(step_def, wait: nil)
+  end
+
+  # Resumes a paused workflow at a specific step, instead of at whatever step
+  # it was pointed at when it paused.
+  #
+  # This is the operator's escape hatch for a workflow stranded on a step that
+  # no longer exists - the step was deleted without leaving a
+  # {GenevaDrive::Workflow.removed_step} gravestone, so the workflow paused
+  # with {StepNotDefinedError} and plain {#resume!} has nowhere to go.
+  #
+  # Where to land is deliberately a human decision. A deleted step's position
+  # in the sequence says nothing about whether the steps that follow it were
+  # ever meant to run: a `capture_payment` that normally ends the workflow by
+  # calling `finished!` sits directly before `refund`, and nothing in the
+  # database distinguishes "carry on" from "stop here". Only the person who
+  # removed the step knows which, so this method asks them.
+  #
+  # Any stray scheduled execution is canceled first, so the workflow continues
+  # from the named step and nowhere else.
+  #
+  # @param step_name [String, Symbol] the step to continue from
+  # @return [StepExecution] the created step execution
+  # @raise [InvalidStateError] if the workflow is not paused
+  # @raise [StepNotDefinedError] if the named step is not defined, or is a removed_step
+  #
+  # @example Continue a stranded workflow past a deleted step
+  #   workflow = GenevaDrive::Workflow.find(id)
+  #   workflow.resume_at!(:send_receipt)
+  def resume_at!(step_name)
+    raise GenevaDrive::InvalidStateError, "Cannot resume a #{state} workflow" unless state == "paused"
+
+    step_def = steps.named(step_name.to_s)
+
+    if step_def.nil? || step_def.removed?
+      reason = step_def ? "a removed_step" : "not defined"
+      raise GenevaDrive::StepNotDefinedError.new(
+        "Cannot resume #{self.class.name} ##{id} at '#{step_name}': that step is #{reason} in " \
+        "#{self.class.name}. The steps it can be resumed at are #{steps.runnable.map(&:name).join(", ")}.",
+        step_execution: nil,
+        workflow: self
+      )
+    end
+
+    logger.info("Resuming paused workflow at step #{step_def.name.inspect} (was pointed at #{next_step_name.inspect})")
+
+    with_lock do
+      update!(state: "ready", current_step_name: nil, transitioned_at: nil)
+    end
+
     create_step_execution(step_def, wait: nil)
   end
 
@@ -920,7 +1073,7 @@ class GenevaDrive::Workflow < ActiveRecord::Base
   #
   # @return [void]
   def log_workflow_created
-    step_count = self.class.step_definitions.size
+    step_count = steps.runnable.size
     logger.info("Created workflow with #{step_count} step(s) defined")
   end
 
@@ -928,7 +1081,10 @@ class GenevaDrive::Workflow < ActiveRecord::Base
   #
   # @return [StepExecution, nil] the created step execution
   def schedule_first_step!
-    first_step = self.class.step_definitions.first
+    # next_after(nil) means "from the beginning" and honours both the
+    # before_step:/after_step: ordering and removed_step gravestones, neither
+    # of which the raw _step_definitions array knows about.
+    first_step = steps.next_after(nil)
     unless first_step
       logger.info("No steps defined, finishing workflow immediately")
       return finish_workflow!
@@ -981,6 +1137,18 @@ class GenevaDrive::Workflow < ActiveRecord::Base
   # @return [StepExecution] the same execution (rescheduled if a signal matched)
   def rendezvous_waiting_execution!(step_execution)
     step_def = step_execution.step_definition
+
+    # The step was removed while this execution sat parked. It waits for an
+    # event that nothing will ever match now, so release it here rather than
+    # leaving it parked for good.
+    if step_def&.removed?
+      logger.info("Step #{step_execution.step_name} was parked but is now a removed_step — releasing it and continuing")
+
+      step_execution.mark_skipped!
+      settle_signal_for_skipped!(step_execution)
+      return schedule_next_step!
+    end
+
     matcher = step_def&.signal_matcher
 
     if matcher

data/lib/geneva_drive.rb

@@ -39,6 +39,7 @@ module GenevaDrive
   autoload :FlowControl, "geneva_drive/flow_control"
   autoload :StepDefinition, "geneva_drive/step_definition"
   autoload :ResumableStepDefinition, "geneva_drive/resumable_step_definition"
+  autoload :RemovedStepDefinition, "geneva_drive/removed_step_definition"
   autoload :StepCollection, "geneva_drive/step_collection"
   autoload :Workflow, "geneva_drive/workflow"
   autoload :StepExecution, "geneva_drive/step_execution"
@@ -49,6 +50,7 @@ module GenevaDrive
   autoload :ExceptionPolicy, "geneva_drive/exception_policy"
   autoload :JobOptions, "geneva_drive/job_options"
   autoload :CombinedExceptionPolicy, "geneva_drive/combined_exception_policy"
+  autoload :JsonColumn, "geneva_drive/json_column"
   autoload :MigrationHelpers, "geneva_drive/migration_helpers"
   autoload :TestHelpers, "geneva_drive/test_helpers"
 

data/test/dummy/config/database.yml

@@ -1,13 +1,48 @@
-# PostgreSQL configuration for GenevaDrive test suite
+<%
+  # Everything the database tasks write under db/ is adapter-specific, the
+  # schema dump above all: parallelize() builds every worker database out of
+  # that dump, and a PostgreSQL one carries jsonb columns SQLite cannot load.
+  # CI points DATABASE_URL at a different engine per leg, so each engine gets
+  # its own corner of db/ and the legs stop overwriting each other's artifacts.
+  #
+  # This has to be resolved here rather than in an initializer - db:prepare and
+  # the other database tasks hang off :load_config, which never runs those.
+  url = ENV["DATABASE_URL"]
+  adapter = if url
+    ActiveRecord::DatabaseConfigurations::ConnectionUrlResolver.new(url).to_hash[:adapter]
+  else
+    "sqlite3"
+  end
+
+  # MariaDB and MySQL are both the mysql2 adapter but do not produce the same
+  # dump - MariaDB has no JSON type - so the engine, when the runner names one,
+  # is what the artifacts get filed under.
+  engine = ENV.fetch("GENEVA_DRIVE_ENGINE", adapter)
+  artifacts = "db/#{engine}"
+
+  # The dump is keyed by Rails minor on top of that: it is written as
+  # `ActiveRecord::Schema[8.1].define`, and 7.2 refuses to load a version it
+  # has never heard of. The databases themselves are not version-specific -
+  # the migrations produce the same DDL - so only the dump gets the suffix.
+  schema_dump = "#{engine}/schema-#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}.rb"
+
+  # Rails only creates db/ itself, not the subdirectory the dump lives in.
+  require "fileutils"
+  FileUtils.mkdir_p(Rails.root.join(artifacts))
+%>
+# The test suite runs against SQLite by default so that a fresh clone can run
+# `rake` with no database server. CI - and `bin/matrix` locally - override this
+# with DATABASE_URL to also exercise PostgreSQL and MySQL.
 default: &default
-  adapter: postgresql
-  encoding: unicode
+  adapter: sqlite3
   pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+  schema_dump: <%= schema_dump %>
 
 development:
   <<: *default
-  database: geneva_drive_development
+  database: storage/development.sqlite3
 
 test:
   <<: *default
-  database: geneva_drive_test
+  database: <%= artifacts %>/test.sqlite3

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# license: LGPLv3.0
+
+# How long to keep completed/canceled workflows before automatic deletion.
+# Set to nil to disable automatic cleanup.
+# When enabled, finished and canceled workflows older than this threshold
+# will be deleted along with their step execution records.
+#
+# GenevaDrive.delete_completed_workflows_after = 30.days
+
+# How long a step execution can be in "executing" 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
+
+# How long a step execution can be past its scheduled_for time while
+# still in "scheduled" state before being considered stuck. This can
+# happen if jobs fail to enqueue or are lost by the queue backend.
+#
+# GenevaDrive.stuck_scheduled_threshold = 15.minutes
+
+# Action to take when recovering stuck step executions.
+# - :reattempt - Mark as recovered and schedule a retry (default)
+# - :cancel - Mark as recovered and cancel the workflow
+#
+# GenevaDrive.stuck_recovery_action = :reattempt
+
+# Maximum number of workflows/step executions to process in a single
+# housekeeping run. Prevents runaway processing if there's a large backlog.
+#
+# GenevaDrive.housekeeping_batch_size = 1000
+
+# 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?)
+# this is set to false so that jobs are enqueued immediately — transactional
+# tests (especially with SQLite) never commit the outermost transaction, which
+# can cause after_commit callbacks to misbehave or not fire at all.
+#
+# Set to true in tests if you need strict transaction semantics for a specific
+# test suite, or if you are not using transactional tests.
+#
+# GenevaDrive.enqueue_after_commit = !Rails.env.test?

data/test/dummy_install/db/migrate/20260217112949_create_geneva_drive_workflows.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# license: LGPLv3.0
+
+class CreateGenevaDriveWorkflows < ActiveRecord::Migration[7.2]
+  include GenevaDrive::MigrationHelpers
+
+  def change
+    create_table :geneva_drive_workflows, **geneva_drive_table_options do |t|
+      # Core identification (STI)
+      t.string :type, null: false, index: true
+
+      # Polymorphic association to the hero of the workflow
+      t.string :hero_type, null: false
+      t.column :hero_id, geneva_drive_key_type, null: false
+
+      # State machine
+      t.string :state, null: false, default: "ready", index: true
+
+      # Current position in workflow
+      t.string :current_step_name
+      t.string :next_step_name
+
+      # Multiple workflows of same type for same hero
+      t.boolean :allow_multiple, default: false, null: false
+
+      # Timestamps
+      t.datetime :started_at
+      t.datetime :transitioned_at
+
+      t.timestamps
+    end
+
+    # Polymorphic index
+    add_index :geneva_drive_workflows, [:hero_type, :hero_id]
+
+    reversible do |direction|
+      direction.up { create_db_specific_indices }
+    end
+  end
+
+  def create_db_specific_indices
+    # Database-specific uniqueness constraint for ongoing workflows
+    # Ensures only one ongoing workflow per (type, hero) unless allow_multiple is true
+    adapter = connection.adapter_name.downcase
+    if adapter.include?("postgresql")
+      execute <<-SQL
+        CREATE UNIQUE INDEX index_geneva_drive_workflows_unique_ongoing
+        ON geneva_drive_workflows (type, hero_type, hero_id)
+        WHERE state NOT IN ('finished', 'canceled') AND allow_multiple = false;
+      SQL
+    elsif adapter.include?("mysql")
+      execute <<-SQL
+        ALTER TABLE geneva_drive_workflows
+        ADD COLUMN ongoing_unique_key VARCHAR(767)
+        AS (
+          CASE
+            WHEN state NOT IN ('finished', 'canceled') AND allow_multiple = 0
+            THEN CONCAT(type, '-', hero_type, '-', hero_id)
+            ELSE NULL
+          END
+        ) STORED;
+      SQL
+      execute <<-SQL
+        CREATE UNIQUE INDEX index_geneva_drive_workflows_unique_ongoing
+        ON geneva_drive_workflows (ongoing_unique_key);
+      SQL
+    elsif adapter.include?("sqlite")
+      execute <<-SQL
+        CREATE UNIQUE INDEX index_geneva_drive_workflows_unique_ongoing
+        ON geneva_drive_workflows (type, hero_type, hero_id)
+        WHERE state NOT IN ('finished', 'canceled') AND allow_multiple = 0;
+      SQL
+    end
+  end
+end

data/test/dummy_install/db/migrate/20260217112950_create_geneva_drive_step_executions.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# license: LGPLv3.0
+
+class CreateGenevaDriveStepExecutions < ActiveRecord::Migration[7.2]
+  include GenevaDrive::MigrationHelpers
+
+  def change
+    key_type = geneva_drive_key_type
+
+    create_table :geneva_drive_step_executions, **geneva_drive_table_options do |t|
+      # Link to workflow (cascade delete when workflow is deleted)
+      t.references :workflow,
+        null: false,
+        foreign_key: {to_table: :geneva_drive_workflows, on_delete: :cascade},
+        index: true,
+        type: key_type
+
+      # Which step this execution represents
+      t.string :step_name, null: false
+
+      # Execution state machine
+      t.string :state, null: false, default: "scheduled", index: true
+
+      # Outcome for audit purposes
+      t.string :outcome
+
+      # Scheduling
+      t.datetime :scheduled_for, null: false, index: true
+
+      # Execution tracking (individual timestamps for audit trail)
+      t.datetime :started_at
+      t.datetime :completed_at
+      t.datetime :failed_at
+      t.datetime :canceled_at
+      t.datetime :skipped_at
+
+      # Error tracking
+      t.string :error_class_name
+      t.text :error_message
+      t.text :error_backtrace
+
+      # Job tracking (for debugging)
+      t.string :job_id
+
+      t.timestamps
+    end
+
+    # Index for finding scheduled executions
+    add_index :geneva_drive_step_executions,
+      [:state, :scheduled_for],
+      name: "index_geneva_drive_step_executions_scheduled"
+
+    # Index for workflow execution history
+    add_index :geneva_drive_step_executions, [:workflow_id, :created_at]
+
+    # Index for common query patterns
+    add_index :geneva_drive_step_executions, [:workflow_id, :state]
+
+    reversible do |direction|
+      direction.up { create_db_specific_indices }
+    end
+  end
+
+  def create_db_specific_indices
+    # Database-specific uniqueness constraint for active step executions
+    # Ensures only one active (scheduled/in_progress) step per workflow
+    adapter = connection.adapter_name.downcase
+    if adapter.include?("postgresql")
+      execute <<-SQL
+        CREATE UNIQUE INDEX index_geneva_drive_step_executions_one_active
+        ON geneva_drive_step_executions (workflow_id)
+        WHERE state IN ('scheduled', 'in_progress');
+      SQL
+    elsif adapter.include?("mysql")
+      execute <<-SQL
+        ALTER TABLE geneva_drive_step_executions
+        ADD COLUMN active_unique_key VARCHAR(767)
+        AS (
+          CASE
+            WHEN state IN ('scheduled', 'in_progress')
+            THEN CAST(workflow_id AS CHAR)
+            ELSE NULL
+          END
+        ) STORED;
+      SQL
+      execute <<-SQL
+        CREATE UNIQUE INDEX index_geneva_drive_step_executions_one_active
+        ON geneva_drive_step_executions (active_unique_key);
+      SQL
+    elsif adapter.include?("sqlite")
+      execute <<-SQL
+        CREATE UNIQUE INDEX index_geneva_drive_step_executions_one_active
+        ON geneva_drive_step_executions (workflow_id)
+        WHERE state IN ('scheduled', 'in_progress');
+      SQL
+    end
+  end
+end

data/test/dummy_install/db/migrate/20260217112951_add_finished_at_to_geneva_drive_step_executions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# license: LGPLv3.0
+
+class AddFinishedAtToGenevaDriveStepExecutions < ActiveRecord::Migration[7.2]
+  def change
+    add_column :geneva_drive_step_executions, :finished_at, :datetime
+
+    add_index :geneva_drive_step_executions, :finished_at
+
+    reversible do |direction|
+      direction.up do
+        # Backfill finished_at from existing timestamp columns.
+        # Uses COALESCE to pick the first non-null value.
+        execute <<-SQL.squish
+          UPDATE geneva_drive_step_executions
+          SET finished_at = COALESCE(completed_at, failed_at, canceled_at, skipped_at)
+          WHERE finished_at IS NULL
+            AND (completed_at IS NOT NULL
+              OR failed_at IS NOT NULL
+              OR canceled_at IS NOT NULL
+              OR skipped_at IS NOT NULL)
+        SQL
+      end
+    end
+  end
+end

data/test/dummy_install/db/migrate/20260217112952_add_error_class_name_to_geneva_drive_step_executions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# license: LGPLv3.0
+
+class AddErrorClassNameToGenevaDriveStepExecutions < ActiveRecord::Migration[7.2]
+  def change
+    add_column :geneva_drive_step_executions, :error_class_name, :string, if_not_exists: true
+  end
+end