active_durable 0.6.0 → 0.7.0

data/lib/active_durable/flow_parallel.rb

@@ -36,7 +36,11 @@ module ActiveDurable
         prepare_branches!(name, branches)
         entry = @notebook[name]
         return finish_recorded_parallel(name, entry, branches) if entry&.completed? || entry&.failed?
-        raise StopForward, name if compensating?
+
+        if compensating? # stopped halfway: undo the branches that finished
+          remember_branches(name, branches, include_failed: true)
+          raise StopForward, name
+        end
 
         run_parallel(name, position, branches)
       end
@@ -77,6 +81,12 @@ module ActiveDurable
 
       def run_parallel(name, position, branches)
         outcomes = branch_outcomes(branches)
+        blocked = outcomes.find { |_, (state, _)| state == :blocked }
+        if blocked
+          @blocked_by = blocked.last.last
+          raise @blocked_by
+        end
+
         failed = outcomes.select { |_, (state, _)| state == :failed }
         if failed.any?
           full_name, (_, error) = failed.first
@@ -95,7 +105,7 @@ module ActiveDurable
         results.deep_dup
       end
 
-      # { full_name => [:completed, result] | [:retry, wake_at] | [:failed, error] }
+      # { full_name => [:completed, result] | [:retry, wake_at] | [:failed, error] | [:blocked, error] }
       def branch_outcomes(branches)
         outcomes = {}
         runnable = []
@@ -164,19 +174,31 @@ module ActiveDurable
         result = ActiveDurable.instrument("step", execution_id: execution_id, step: branch.full_name,
                                                   kind: branch.kind) do
           if branch.kind == "transaction"
-            @notebook.transaction { record_result(branch.full_name, branch.kind, nil, branch.block.call(ticket)) }
+            @notebook.transaction(records: branch.full_name) do
+              record_result(branch.full_name, branch.kind, nil, branch.block.call(ticket))
+            end
           else
             record_result(branch.full_name, branch.kind, nil, branch.block.call(ticket))
           end
         end
         ActiveDurable.crash_point(:after_record, branch.full_name)
         [:completed, result]
-      rescue NotSerializable, InvalidRecipe
-        raise
-      rescue NameError => e
-        raise CodeError.new(branch.full_name, e)
-      rescue StandardError => e
+      rescue Abort => e
         branch_failure(branch, entry, e)
+      rescue NotSerializable, InvalidRecipe, CheckpointFailed => e
+        block_branch(branch, entry, e)
+      rescue StandardError, ScriptError, SystemStackError => e
+        return block_branch(branch, entry, CodeError.new(branch.full_name, e)) if ActiveDurable.code_error?(e)
+
+        branch_failure(branch, entry, e)
+      end
+
+      # Like block_step!, from inside a branch thread: the run blocks once every branch has finished.
+      def block_branch(branch, entry, error)
+        error.step_name ||= branch.full_name if error.respond_to?(:step_name=)
+        @notebook.block!(branch.full_name, kind: branch.kind, position: nil, attempts: entry&.attempts || 0,
+                                           error: ActiveDurable.dump_error(error, step: branch.full_name))
+        [:blocked, error]
       end
 
       def branch_failure(branch, entry, error)
@@ -205,7 +227,7 @@ module ActiveDurable
 
           if entry.completed?
             @undo_stack << UndoEntry.new(entry.name, branch.kind, entry.result, branch.undo)
-          elsif include_failed && branch.options[:undo_on_failure] && (entry.failed? || entry.retrying?)
+          elsif include_failed && branch.options[:undo_on_failure] && (entry.failed? || entry.unfinished?)
             @undo_stack << UndoEntry.new(entry.name, branch.kind, nil, branch.undo)
           end
         end

data/lib/active_durable/notebook.rb

@@ -48,17 +48,28 @@ module ActiveDurable
                    wake_at: nil)
     end
 
+    # The step hit a bug or its result could not be recorded: it runs again after ActiveDurable.retry.
+    def block!(name, kind:, position:, attempts:, error:)
+      write!(name, kind: kind, position: position, status: "blocked", attempts: attempts, error: error, wake_at: nil)
+    end
+
     def wait!(name, kind:, position:, wake_at:)
       write!(name, kind: kind, position: position, status: "waiting", wake_at: wake_at)
     end
 
     # Runs the block in a database transaction and remembers the notebook writes made inside it only once it
-    # commits. flow.transaction steps and their undos use it: a step that rolled back must not look completed.
-    def transaction(&)
+    # commits. flow.transaction steps, their undos and hooks use it: a step that rolled back must not look
+    # completed. With `records:`, the block must have recorded that entry: Active Record swallows
+    # ActiveRecord::Rollback, so a block that raised it would otherwise look done.
+    def transaction(records: nil, &)
       pending = []
       Thread.current[pending_key] = pending
       result = Record.transaction(&)
       pending.each { |name, entry| remember(name, entry) }
+      if records && !self[records]&.completed?
+        raise Error, ":#{records} rolled back (ActiveRecord::Rollback), so nothing was recorded. Raise an error " \
+                     "or call flow.abort! to make it fail."
+      end
       result
     ensure
       Thread.current[pending_key] = nil

data/lib/active_durable/operations.rb

@@ -14,22 +14,25 @@ module ActiveDurable
   module Operations
     module_function
 
-    # A blocked execution tries again from where it stopped: failed steps (or failed undos, if it was
-    # compensating) get a fresh set of attempts. Deploy the fix first when the cause was a bug.
+    # A blocked execution tries again from where it stopped: the step that blocked it (or the failed undos, if it
+    # was compensating) gets a fresh set of attempts. Failed steps the recipe already handled, such as a payment
+    # provider it replaced with another one, stay failed: running them again would pay twice. Deploy the fix
+    # first when the cause was a bug.
     def retry(execution_id)
       execution = with_idle_execution(execution_id, allowed: %w[blocked]) do |record|
-        failed = record.steps.where(status: "failed")
-        failed = record.compensating ? failed.where(kind: "undo") : failed.where.not(kind: "undo")
-        failed.update_all(status: "retrying", attempts: 0, wake_at: nil, updated_at: ActiveDurable.now)
+        blocking_steps(record).update_all(status: "retrying", attempts: 0, wake_at: nil,
+                                          updated_at: ActiveDurable.now)
         reopen!(record, error: nil)
       end
       ActiveDurable.instrument("retried", execution_id: execution.id)
       execution
     end
 
-    # Undoes every completed step, last one first. Not possible once the point of no return was passed.
+    # Undoes every completed step, last one first. Not possible once the point of no return was passed, nor while
+    # the execution is running: the lease is only renewed on notebook writes, so a worker may still be inside a
+    # slow step after its lease ran out (the sweeper resumes it if the worker died).
     def compensate(execution_id, reason: "compensated by an operator")
-      execution = with_idle_execution(execution_id, allowed: %w[blocked pending running sleeping waiting]) do |record|
+      execution = with_idle_execution(execution_id, allowed: %w[blocked pending sleeping waiting]) do |record|
         raise Error, "#{record.id} is already compensating; use ActiveDurable.retry to resume it" if record.compensating
         if record.steps.exists?(kind: "pivot", status: "completed")
           raise Error, "#{record.id} already passed its point of no return; it can only move forward"
@@ -52,9 +55,7 @@ module ActiveDurable
       Record.transaction do
         original = Execution.lock.find(execution_id)
         check_rerunnable!(original)
-        start = original.steps.where.not(kind: %w[undo hook]).find_by(name: from)
-        raise Error, "#{original.id} has no step :#{from} in its notebook" unless start
-
+        start = rerun_start(original, from)
         execution = Execution.create!(id: rerun_id(original), recipe: original.recipe,
                                       recipe_version: original.recipe_version, input: original.input,
                                       status: "pending", forked_from: original.id)
@@ -65,6 +66,15 @@ module ActiveDurable
       execution
     end
 
+    def rerun_start(original, from)
+      start = original.steps.where.not(kind: %w[undo hook]).find_by(name: from)
+      raise Error, "#{original.id} has no step :#{from} in its notebook" unless start
+      return start if start.position
+
+      parallel = from.split("/", 2).first
+      raise Error, ":#{from} is a branch of flow.parallel :#{parallel}; rerun from :#{parallel} instead"
+    end
+
     def with_idle_execution(execution_id, allowed:)
       execution = Record.transaction do
         record = Execution.lock.find(execution_id)
@@ -95,18 +105,44 @@ module ActiveDurable
                    "only completed executions, or blocked ones that are not compensating, can be rerun"
     end
 
+    # Moving forward: the step named by the error, or the whole flow.parallel it belongs to, and every step that
+    # hit a bug. Compensating: every failed undo, since each of them stopped the compensation.
+    def blocking_steps(record)
+      steps = record.steps
+      return steps.where(kind: "undo", status: "failed") if record.compensating
+
+      name = record.error.is_a?(Hash) ? record.error["step"].to_s : ""
+      failed = steps.where(status: "failed").where.not(kind: %w[undo hook])
+      parallel = failed.where(kind: "parallel").pluck(:name)
+                       .find { |group| name == group || name.start_with?("#{group}/") }
+      named = if parallel
+                failed.where(name: parallel).or(failed.where("name LIKE ?", "#{Step.sanitize_sql_like(parallel)}/%"))
+              else
+                failed.where(name: name)
+              end
+      named.or(steps.where(status: "blocked"))
+    end
+
+    # A random suffix, never a count: a pruned rerun must not hand its id, and so its tickets, to a new one.
     def rerun_id(original)
-      root = original.id.sub(/~rerun-\d+\z/, "")
-      count = Execution.where("id LIKE ?", "#{Execution.sanitize_sql_like(root)}~rerun-%").count
-      "#{root}~rerun-#{count + 1}"
+      root = original.id.sub(/~rerun-\h+\z/, "")
+      "#{root}~rerun-#{SecureRandom.hex(4)}"
     end
 
+    # The steps before `from` that completed or failed (a failure the recipe handled must stay handled), and the
+    # branches of each flow.parallel among them, in the order they finished, so their undos still run.
     def copy_steps(original, execution, before:)
+      forward = original.steps.where.not(kind: %w[undo hook]).where(status: %w[completed failed])
+      kept = forward.where(position: ...before).order(:position).to_a
+      groups = kept.select { |step| step.kind == "parallel" }.map { |step| "#{step.name}/" }
+      branches = forward.where(position: nil).order(:updated_at, :id).select do |step|
+        groups.any? { |prefix| step.name.start_with?(prefix) }
+      end
       now = ActiveDurable.now
-      rows = original.steps.where.not(kind: %w[undo hook]).where(status: "completed").where(position: ...before)
-                     .map do |step|
+      rows = (kept + branches).map do |step|
         { execution_id: execution.id, name: step.name, kind: step.kind, position: step.position,
-          status: "completed", attempts: step.attempts, result: step.result, created_at: now, updated_at: now }
+          status: step.status, attempts: step.attempts, result: step.result, error: step.error,
+          created_at: now, updated_at: now }
       end
       Step.insert_all!(rows) if rows.any?
     end

data/lib/active_durable/pruner.rb

@@ -6,8 +6,6 @@ module ActiveDurable
   #
   # @api private
   module Pruner
-    FINISHED = %w[completed compensated superseded].freeze
-
     module_function
 
     # Returns how many executions were deleted. Each batch is deleted in its own transaction, steps and signals
@@ -18,7 +16,7 @@ module ActiveDurable
       cutoff = now - older_than.to_f
       deleted = 0
       loop do
-        ids = Execution.where(status: FINISHED).where("updated_at < ?", cutoff).limit(batch_size).pluck(:id)
+        ids = Execution.where(status: Execution::FINISHED).where("updated_at < ?", cutoff).limit(batch_size).pluck(:id)
         break if ids.empty?
 
         Record.transaction do

data/lib/active_durable/runner.rb

@@ -38,7 +38,7 @@ module ActiveDurable
       lease.release!(status: status, wake_at: wake_at)
       ActiveDurable.enqueue(execution.id, wait_until: wake_at) if wake_at
       # A signal may have been committed while we held the lease; its own job found us busy.
-      if status == "waiting" && SignalRecord.pending.exists?(execution_id: execution.id)
+      if status == "waiting" && SignalRecord.awaited.exists?(execution_id: execution.id)
         ActiveDurable.enqueue(execution.id)
       end
       throw SUSPEND, status.to_sym
@@ -58,12 +58,16 @@ module ActiveDurable
       block!(e)
     rescue StandardError => e
       fail!(e)
+    rescue ScriptError, SystemStackError => e # LoadError, NotImplementedError: bugs that StandardError misses
+      block!(@flow&.blocked_by || e)
     end
 
     # Only a step that failed for good (StepFailed) or a business rejection (Abort) undoes the saga. Anything else
     # the recipe raises is a bug: the execution is blocked, so fixing the code and calling ActiveDurable.retry
-    # carries it forward instead of refunding customers.
+    # carries it forward instead of refunding customers. A step that hit a bug blocks the run even if the recipe
+    # rescued its error.
     def fail!(error)
+      return block!(@flow.blocked_by) if @flow&.blocked_by
       return block!(error) if @flow.nil? || @flow.pivoted? || !compensates?(error)
 
       start_compensation!(error) unless @flow.compensating?
@@ -124,14 +128,14 @@ module ActiveDurable
 
       ActiveDurable.crash_point(:before_hook, name)
       ActiveDurable.instrument("hook", execution_id: execution.id, step: name, kind: "hook") do
-        notebook.transaction do
+        notebook.transaction(records: name) do
           hook.call
           ActiveDurable.crash_point(:after_hook_call, name)
           notebook.complete!(name, kind: "hook", position: nil, result: nil)
         end
       end
       ActiveDurable.crash_point(:after_hook_record, name)
-    rescue StandardError => e
+    rescue StandardError, ScriptError, SystemStackError => e
       raise if e.is_a?(HookFailed)
 
       raise HookFailed.new(event, e)
@@ -148,13 +152,13 @@ module ActiveDurable
       ActiveDurable.crash_point(:before_undo, entry.name)
       ActiveDurable.instrument("undo", execution_id: execution.id, step: entry.name) do
         if entry.kind == "transaction"
-          notebook.transaction { call_undo(entry, ticket, name) }
+          notebook.transaction(records: name) { call_undo(entry, ticket, name) }
         else
           call_undo(entry, ticket, name)
         end
       end
       ActiveDurable.crash_point(:after_undo_record, entry.name)
-    rescue StandardError => e
+    rescue StandardError, ScriptError, SystemStackError => e
       retry_undo!(entry, name, record, e)
     end
 
@@ -172,13 +176,19 @@ module ActiveDurable
       notebook.complete!(name, kind: "undo", position: nil, result: nil)
     end
 
+    # An undo is retried until config.undo_attempts, then the execution is blocked. A bug blocks it at once.
     def retry_undo!(entry, name, record, error)
       attempts = (record&.attempts || 0) + 1
       dumped = ActiveDurable.dump_error(error, step: name)
       max = ActiveDurable.config.undo_attempts
+      if ActiveDurable.code_error?(error)
+        notebook.fail!(name, kind: "undo", position: nil, attempts: attempts, error: dumped)
+        raise UndoFailed.new("undo of :#{entry.name} cannot run: #{error.class}: #{error.message}", step_name: name)
+      end
       if attempts >= max
         notebook.fail!(name, kind: "undo", position: nil, attempts: attempts, error: dumped)
-        raise UndoFailed, "undo of :#{entry.name} failed #{attempts} times (#{error.class}: #{error.message})"
+        raise UndoFailed.new("undo of :#{entry.name} failed #{attempts} times (#{error.class}: #{error.message})",
+                             step_name: name)
       end
 
       wake_at = ActiveDurable.now + RetryPolicy.new(attempts: max).delay(attempts)

data/lib/active_durable/serializer.rb

@@ -2,8 +2,9 @@
 
 module ActiveDurable
   # Step results, inputs and signal payloads live in the notebook as JSON. This module turns a value
-  # into exactly what a later replay will read back (string keys, no symbols), so the first run and a
-  # replay behave the same. Anything that is not plain JSON is rejected with a message that says where.
+  # into exactly what a later replay will read back (string keys, no symbols, UTF-8 strings), so the first run
+  # and a replay behave the same. Anything that is not plain JSON, or that some database cannot store (a NUL
+  # character, bytes that are not UTF-8), is rejected with a message that says where.
   #
   # @api private
   module Serializer
@@ -11,7 +12,8 @@ module ActiveDurable
 
     def normalize(value, path = "value")
       case value
-      when nil, true, false, String, Integer then value
+      when nil, true, false, Integer then value
+      when String then utf8(value, path)
       when Float then finite_float(value, path)
       when Symbol then value.to_s
       when Array then value.each_with_index.map { |item, index| normalize(item, "#{path}[#{index}]") }
@@ -29,10 +31,32 @@ module ActiveDurable
         key = key.to_s if key.is_a?(Symbol)
         raise NotSerializable, "#{path} has a #{key.class} key; use strings or symbols" unless key.is_a?(String)
 
+        key = utf8(key, "a key of #{path}")
         out[key] = normalize(item, "#{path}[#{key.inspect}]")
       end
     end
 
+    # Binary strings (Net::HTTP response bodies) are fine when their bytes are UTF-8; other encodings are converted.
+    def utf8(value, path)
+      string = value
+      if [Encoding::BINARY, Encoding::US_ASCII].include?(string.encoding)
+        string = string.dup.force_encoding(Encoding::UTF_8)
+      elsif string.encoding != Encoding::UTF_8
+        string = string.encode(Encoding::UTF_8)
+      end
+      unless string.valid_encoding?
+        raise NotSerializable, "#{path} has bytes that are not UTF-8. Decode it with the right encoding, or " \
+                               "Base64-encode binary data."
+      end
+      if string.include?("\u0000")
+        raise NotSerializable, "#{path} contains a NUL character (\\u0000), which PostgreSQL cannot store. " \
+                               "Strip it, or Base64-encode binary data."
+      end
+      string
+    rescue EncodingError => e
+      raise NotSerializable, "#{path} cannot be converted to UTF-8 (#{e.message})"
+    end
+
     def finite_float(value, path)
       raise NotSerializable, "#{path} is #{value}, which JSON cannot store" unless value.finite?
 

data/lib/active_durable/signal_record.rb

@@ -13,6 +13,17 @@ module ActiveDurable
 
     scope :pending, -> { where(consumed_at: nil) }
 
+    # Pending signals that their execution is waiting for right now. Any other pending signal (a duplicate, or one
+    # for a later flow.wait_for) must not wake the execution up: it would only go back to waiting, forever.
+    scope :awaited, lambda {
+      steps = Step.arel_table
+      waiting = steps.project(Arel.sql("1"))
+                     .where(steps[:execution_id].eq(arel_table[:execution_id])
+                     .and(steps[:name].eq(arel_table[:name]))
+                     .and(steps[:status].eq("waiting")))
+      pending.where(waiting.exists)
+    }
+
     after_create_commit { ActiveDurable.enqueue(execution_id) }
 
     def self.next_for(execution_id, name)

data/lib/active_durable/step.rb

@@ -23,6 +23,16 @@ module ActiveDurable
       status == "retrying"
     end
 
+    # It hit a bug, or its result could not be recorded. It runs again when the execution is retried.
+    def blocked?
+      status == "blocked"
+    end
+
+    # It ran without recording a result: between attempts, or stopped by a bug. Its effect may have happened.
+    def unfinished?
+      retrying? || blocked?
+    end
+
     def waiting?
       status == "waiting"
     end

data/lib/active_durable/sweeper.rb

@@ -35,7 +35,7 @@ module ActiveDurable
                        .where("updated_at < ?", now - ActiveDurable.config.sweep_grace.to_f)
       ready = quiet.where(status: %w[pending running])
                    .or(quiet.where(wake_at: ..now))
-                   .or(quiet.where(status: "waiting", id: SignalRecord.pending.select(:execution_id)))
+                   .or(quiet.where(status: "waiting", id: SignalRecord.awaited.select(:execution_id)))
       ready.pluck(:id)
     end
   end

data/lib/active_durable/testing.rb

@@ -110,7 +110,7 @@ module ActiveDurable
 
     # @api private
     def waiting_can_move?(execution, signals, now)
-      return true if SignalRecord.pending.exists?(execution_id: execution.id)
+      return true if SignalRecord.awaited.exists?(execution_id: execution.id)
 
       waiting = execution.steps.find_by(status: "waiting")
       if waiting && signals.key?(waiting.name)

data/lib/active_durable/version.rb

@@ -2,5 +2,5 @@
 
 module ActiveDurable
   # The gem's version.
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/active_durable.rb

@@ -119,7 +119,8 @@ module ActiveDurable
     # @param input [Hash] keyword arguments for the recipe; stored as JSON
     # @return [Execution]
     # @raise [UnknownRecipe] if no recipe has that name
-    # @raise [ArgumentError] if the id already belongs to an execution of another recipe
+    # @raise [ArgumentError] if the id already belongs to an execution of another recipe, or is blank, has a "/",
+    #   a NUL character or bytes that are not UTF-8
     # @raise [NotSerializable] if the input cannot be stored as JSON
     # @example
     #   Durable.start(:checkout, id: "checkout-#{order.id}", order_id: order.id)
@@ -129,26 +130,45 @@ module ActiveDurable
                      input: Serializer.normalize(input, "input") }
       return Execution.create!(attributes.merge(id: "#{recipe.name}-#{SecureRandom.uuid}")) if id.nil?
 
-      execution = Execution.create_or_find_by!(id: id.to_s) { |record| record.assign_attributes(attributes) }
+      id = check_id!(id)
+      execution = begin
+        Execution.create_or_find_by!(id: id) { |record| record.assign_attributes(attributes) }
+      rescue ActiveRecord::RecordNotFound
+        # Rails < 7.1 on MySQL: inside the app's transaction, the plain read after the duplicate insert uses an
+        # older snapshot and misses the row another start just committed. A locking read sees it.
+        Execution.lock.find(id)
+      end
       return execution if execution.recipe == recipe.name
 
       raise ArgumentError, "execution #{id} already exists for recipe :#{execution.recipe}"
     end
 
+    # @api private
+    def check_id!(id)
+      id = Serializer.normalize(id.to_s, "the execution id")
+      raise ArgumentError, "execution ids cannot be blank" if id.strip.empty?
+      return id unless id.include?("/")
+
+      raise ArgumentError, "execution ids cannot contain \"/\" (#{id}): the dashboard could not route them. " \
+                           "Use - or : instead."
+    rescue NotSerializable => e
+      raise ArgumentError, e.message
+    end
+
     # Delivers a signal to a saga waiting, now or later, in flow.wait_for(name). A signal that arrives before the
-    # saga waits is kept until it does.
+    # saga waits is kept until it does, also while the saga is blocked.
     #
     # @param execution_id [String]
     # @param name [Symbol, String] the name given to {Flow#wait_for}
     # @param payload [Object] what wait_for returns; stored as JSON
     # @return [void]
     # @raise [ActiveRecord::RecordNotFound] if there is no such execution
-    # @raise [Error] if the execution already finished
+    # @raise [Error] if the execution already finished: completed, compensated or superseded
     # @example In a webhook controller
     #   Durable.signal("loan-42", :kyc_done, verified: true)
     def signal(execution_id, name, payload = nil)
       execution = Execution.find(execution_id)
-      raise Error, "execution #{execution_id} already finished (#{execution.status})" if execution.terminal?
+      raise Error, "execution #{execution_id} already finished (#{execution.status})" if execution.finished?
 
       SignalRecord.create!(execution_id: execution.id, name: name.to_s,
                            payload: Serializer.normalize(payload, "signal payload"))

data/lib/generators/active_durable/install/templates/create_active_durable_tables.rb.tt

@@ -4,7 +4,7 @@ class CreateActiveDurableTables < ActiveRecord::Migration<%= migration_version %
   def change
     # One row per saga run. It is also the buzón: create it in the same transaction as your record.
     create_table :durable_executions, id: false do |t|
-      t.string :id, null: false, primary_key: true
+      t.string :id, null: false, primary_key: true, **exact
       t.string :recipe, null: false
       t.integer :recipe_version, null: false, default: 1
       t.string :status, null: false
@@ -15,7 +15,7 @@ class CreateActiveDurableTables < ActiveRecord::Migration<%= migration_version %
       t.datetime :wake_at, precision: 6
       t.datetime :locked_until, precision: 6
       t.string :lease_token
-      t.string :forked_from
+      t.string :forked_from, **exact
       t.timestamps precision: 6
     end
     add_index :durable_executions, %i[status wake_at]
@@ -25,8 +25,8 @@ class CreateActiveDurableTables < ActiveRecord::Migration<%= migration_version %
 
     # The notebook: one row per step (and per undo) of an execution.
     create_table :durable_steps do |t|
-      t.string :execution_id, null: false
-      t.string :name, null: false
+      t.string :execution_id, null: false, **exact
+      t.string :name, null: false, **exact
       t.string :kind, null: false
       t.integer :position
       t.string :status, null: false
@@ -42,8 +42,8 @@ class CreateActiveDurableTables < ActiveRecord::Migration<%= migration_version %
 
     # Signals for flow.wait_for. They can arrive before the saga starts waiting.
     create_table :durable_signals do |t|
-      t.string :execution_id, null: false
-      t.string :name, null: false
+      t.string :execution_id, null: false, **exact
+      t.string :name, null: false, **exact
       t.column :payload, json_type
       t.datetime :consumed_at, precision: 6
       t.datetime :created_at, null: false, precision: 6
@@ -58,4 +58,9 @@ class CreateActiveDurableTables < ActiveRecord::Migration<%= migration_version %
   def json_type
     connection.adapter_name.downcase.include?("postg") ? :jsonb : :json
   end
+
+  # MySQL compares strings ignoring case and accents by default; ids and step names must match exactly.
+  def exact
+    connection.adapter_name.match?(/mysql|trilogy/i) ? { collation: "utf8mb4_bin" } : {}
+  end
 end

data/lib/generators/active_durable/upgrade/templates/make_active_durable_ids_case_sensitive.rb.tt

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# ActiveDurable 0.7: MySQL compared ids and step names ignoring case and accents, so "order-abc" and "order-ÁBC"
+# shared one saga. These columns now compare byte by byte, as on PostgreSQL and SQLite. Elsewhere it does nothing.
+#
+# On MySQL it rebuilds the three tables and blocks writes to them while it runs: run it at a quiet time, or prune
+# first. MySQL cannot roll DDL back, so if it stops halfway, run it again: it finishes the columns and puts the
+# foreign keys back.
+class MakeActiveDurableIdsCaseSensitive < ActiveRecord::Migration<%= migration_version %>
+  COLUMNS = {
+    durable_executions: %w[id forked_from],
+    durable_steps: %w[execution_id name],
+    durable_signals: %w[execution_id name]
+  }.freeze
+
+  def up
+    change_collation { |_table| "utf8mb4_bin" }
+  end
+
+  def down
+    change_collation { |table| table_collation(table) }
+  end
+
+  private
+
+  def change_collation
+    return unless connection.adapter_name.match?(/mysql|trilogy/i)
+
+    changes = COLUMNS.flat_map do |table, names|
+      wanted = yield(table)
+      connection.columns(table).select { |column| names.include?(column.name) && column.collation != wanted }
+                .map { |column| [table, column, wanted] }
+    end
+
+    # Both ends of a foreign key must share a collation, so the keys come off while the columns change.
+    on_delete = remove_foreign_keys if changes.any?
+    changes.each do |table, column, collation|
+      change_column table, column.name, :string, limit: column.limit, null: column.null, collation: collation
+    end
+    restore_foreign_keys(on_delete || {})
+  end
+
+  FOREIGN_KEY_TABLES = %i[durable_steps durable_signals].freeze
+
+  def foreign_key(table)
+    connection.foreign_keys(table).find { |key| key.column == "execution_id" }
+  end
+
+  def remove_foreign_keys
+    FOREIGN_KEY_TABLES.each_with_object({}) do |table, on_delete|
+      key = foreign_key(table)
+      next unless key
+
+      on_delete[table] = key.options[:on_delete]
+      remove_foreign_key table, column: :execution_id
+    end
+  end
+
+  # Also puts back keys that an earlier run, stopped halfway, left off.
+  def restore_foreign_keys(on_delete)
+    FOREIGN_KEY_TABLES.each do |table|
+      next if foreign_key(table)
+
+      add_foreign_key table, :durable_executions, column: :execution_id, on_delete: on_delete.fetch(table, :cascade)
+    end
+  end
+
+  def table_collation(table)
+    select_value("SELECT TABLE_COLLATION FROM information_schema.TABLES " \
+                 "WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = #{connection.quote(table.to_s)}")
+  end
+end

data/lib/generators/active_durable/upgrade/upgrade_generator.rb

@@ -16,7 +16,7 @@ module ActiveDurable
       desc "Adds the migrations that newer ActiveDurable versions need. Run it after updating the gem."
 
       # In the order they were released. Never edit one that shipped: add a new one.
-      MIGRATIONS = %w[add_active_durable_prune_index].freeze
+      MIGRATIONS = %w[add_active_durable_prune_index make_active_durable_ids_case_sensitive].freeze
 
       # @api private
       def create_migration_files

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_durable
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - William Romero
@@ -121,6 +121,7 @@ files:
 - lib/generators/active_durable/install/install_generator.rb
 - lib/generators/active_durable/install/templates/create_active_durable_tables.rb.tt
 - lib/generators/active_durable/upgrade/templates/add_active_durable_prune_index.rb.tt
+- lib/generators/active_durable/upgrade/templates/make_active_durable_ids_case_sensitive.rb.tt
 - lib/generators/active_durable/upgrade/upgrade_generator.rb
 - lib/tasks/active_durable.rake
 - sig/active_durable.rbs