solid_objects 0.14.5 → 0.14.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45c9deb9d06f62e056668c5d3b547786ba69f9d866c302d850650d4ddeac7f9d
-  data.tar.gz: be67022b7559e87fa48adc91bc09466c005a77345e1631405cd4be76a038e8b5
+  metadata.gz: '0616851aa1c44a26313dac95fa3f868324910a64a7023435d2c2b6aed83b7610'
+  data.tar.gz: b54b99a40ee18b68f7d6b7f21eb9879c92a867b0715a52647f4f58b4f35997d9
 SHA512:
-  metadata.gz: 43ad462709bbb061bc9aef103ce4bed2b9f5432c2efd507a743ccbdd33c255c7c4c8540d8d203baef62ef1c552ffd8e6978403c83a400fa99329be9cafbc44ed
-  data.tar.gz: 909192b9a0ca8674439e4ade94c09b6d0cd03b6cddc1082d2f55d02e0de41b27b64688bd1cb8c8af77febb5dd3a78241b656fa8d77a12942b3e1678b61450e37
+  metadata.gz: 5a1a03e584ad3305114993f1898294ebcc719330d2ea6466aa29b38b218bae50fca92394cc57dac95dd8f584da6c506a57f7c145d4238ed2c06e0411a93fa4a8
+  data.tar.gz: 45b4818bc0beb1de4697155bd438c58bc3432e2d40e93c1deb6ff6db5c295d54fe9994e021ff5f7167564a3444fd2b8918b669f2dc550a88985b53e57f55d96c

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.14.6 - 2026-09-12
+
+- Preserve committed turns when an Active Record after-commit callback raises.
+  Caller assistance and workers expose the original callback exception without
+  restoring obsolete state, retrying/rejecting the completed message, or
+  masking the error as a missing claim. Track actual SQL commitment before
+  SQLite retries and deadline translation; retain pre-commit rollback, retry,
+  and domain-rejection behavior.
+
 ## 0.14.5 - 2026-09-03
 
 - Split broadcast claiming into separate pending and stale-processing probes,

data/README.md

@@ -110,15 +110,13 @@ bundle exec solid_objects start
 ```
 
 Stop that process before the deadline and restart it afterwards. The reminder
-is still in the Rails database and runs when the process returns. We have given
-`self.available += 1` a supervisor and excellent posture.
+is still in the Rails database and runs when the process returns. The reminder survived the restart.
 
 ## Why this exists
 
 The handwritten Rails version usually starts with `with_lock`. Then it gains an
 `expires_at` column, a cron job, an Active Job retry policy, and an Action Cable
-broadcast that must agree with the write. A small invariant has become a rich
-tapestry of callbacks and scheduled cleanup.
+broadcast that must agree with the write. A small invariant has spread across callbacks and scheduled cleanup.
 
 This is complicated, hard to test, fragile and unnecessary.
 
@@ -133,14 +131,12 @@ PostgreSQL, or MySQL. Redis and a separate actor service are not required.
 - Account, device, assessment, and approval workflows that survive deploys.
 - Reactive ERB views that must follow committed actor revisions.
 
-Different identities can run concurrently. Put the whole application behind
-one actor ID and Rails will faithfully operate your new bottleneck.
+Different identities can run concurrently. One actor ID for the whole application is a bottleneck.
 
 ## When a transaction is better
 
 Often. If the entire invariant fits inside one request, use `with_lock`, a
-database constraint, or a short transaction. A row lock does not need a
-personal brand, and it is usually the clearest answer.
+database constraint, or a short transaction. A row lock is usually the clearest answer.
 
 Use Solid Objects when work must happen later, survive a restart, or stay
 ordered across several requests or jobs. A plain counter remains one line of
@@ -171,15 +167,13 @@ Exactly once is not hiding in a more advanced configuration. Read the
 - [Detailed documentation](docs/)
 
 The dashboard, benchmarks, migration cookbook, schema, and exhaustive API
-explanations remain in `docs/`. The README is stopping before it develops a
-robust interplay with its own table of contents.
+explanations remain in `docs/`. The README stops here.
 
 ## Status and license
 
 Solid Objects Ruby is a pre-1.0 early release. Its correctness core is tested
 against SQLite, PostgreSQL, and MySQL, but the project makes no production-ready
-claim. That requires more hardening and operational soak evidence. Pre-1.0 is
-not decorative punctuation.
+claim. That requires more hardening and operational soak evidence. Expect breaking changes.
 
 Solid Objects is released under the [MIT License](MIT-LICENSE). It is an
 independent project and is not affiliated with, sponsored by, or endorsed by

data/docs/architecture.md

@@ -314,9 +314,30 @@ Any lease or message predicate failure raises `LostActivation` and rolls back ev
 
 The state version can advance because of state migration even when the message itself makes no state change.
 
+Active Record may raise from an application `after_commit` callback while the
+transaction call unwinds, after SQL has committed. The adapter retains the
+actual transaction object and checks its fully committed state before any
+deadline conversion or SQLite retry. Reaching the end of the block, releasing
+a savepoint, or observing an in-memory message update is not proof of SQL
+commitment. A failing `before_commit` callback follows the rollback path.
+
+An internal `CommittedTransactionError` carries the original error through
+executor, SQLite retry, and coordination rescue handlers. The synchronous
+invocation and worker boundaries re-raise the original exception with its
+original backtrace and cause. The wrapper prevents a callback's `Rejected`,
+`LostActivation`, or database error from being mistaken for a pre-commit
+outcome. It is not a durable message error or a new delivery mechanism.
+
+After commitment, actor state, application writes, message completion/result,
+and outboxes remain durable. The executor preserves the committed activation
+state and does not retry, reject, or dead-letter that turn. Caller assistance
+still deactivates and releases its lease during cleanup; cached worker state
+can process later messages. A worker running its continuous loop exposes the
+error and runs its existing shutdown cleanup.
+
 ## Failure path
 
-Actor exceptions roll back all in-memory changes by restoring the pre-turn state. A separate short transaction conditionally owned by the current generation:
+Before commitment, actor and commit-action exceptions roll back all in-memory changes by restoring the pre-turn state. A separate short transaction conditionally owned by the current generation:
 
 - Stores a sanitized error
 - Deletes claimed membership
@@ -403,9 +424,15 @@ outer commit, and callers timing out on work they indirectly block.
 waiting and immediately returns a `MessageReference`. Runtime workers process
 it normally.
 
+An executing caller receives an inline after-commit callback error even though
+the turn committed. An independently waiting caller observes the durable
+result and may return before that callback raises in the worker. Completed
+history is not changed retroactively; callback failures must be observed in
+the executing process. Later Rails callbacks may not run after one raises.
+
 ## Domain rejection
 
-Actor code can call `reject` for a validation or business-rule outcome that
+Before commitment, actor code can call `reject` for a validation or business-rule outcome that
 must not retry. The executor restores pre-turn state, discards staged intents,
 stores the structured rejection, completes the claimed membership, and
 continues with the next sequence in one fenced transaction. Synchronous callers

data/docs/correctness.md

@@ -125,6 +125,29 @@ it is available only when Solid Objects and `ActiveRecord::Base` share one
 connection pool. Commit actions must contain only bounded database work.
 External I/O belongs in the effect outbox.
 
+### Errors after SQL commit
+
+Active Record `after_commit` callbacks registered by commit actions run after
+SQL commitment. If one raises, the application writes, actor state, message
+result/completion, and claimed-membership deletion remain committed. The
+executor does not restore the pre-turn snapshot, retry the business action,
+reject the message, or create a dead letter. A `before_commit` callback can
+still roll back everything even after the fenced transaction block finishes.
+
+The executing synchronous caller or `Worker#run_once` receives the original
+callback exception, including its identity, backtrace, and cause. This also
+applies when the callback raises `Rejected`, `LostActivation`, or a database
+deadline/lock error: its class does not change a committed turn into a failed
+one. Synchronous cleanup releases the activation; a worker retains the
+committed state until normal deactivation or shutdown, so later messages can
+continue from that state.
+
+A separate waiting caller can observe the durable result before the callback
+finishes. There is no retroactive failure delivery or durable callback-error
+result. Inspect and report errors in the executing process. Rails may skip
+later callbacks when one raises; these callbacks are not a durable delivery
+mechanism. Use an idempotent effect for work that needs independent retries.
+
 ## Reactive components
 
 A successful fenced turn advances `instances.state_revision` to that message's
@@ -205,7 +228,7 @@ wakes the caller, and raises `SolidObjects::ActorDestroyed`.
 
 ## Domain rejection
 
-`reject` is a terminal domain outcome, not an infrastructure failure. It rolls
+`reject` before commitment is a terminal domain outcome, not an infrastructure failure. It rolls
 back in-memory state and staged intents, stores a structured rejection on the
 message, removes claimed membership, and lets the next sequence run. It is
 never retried or dead-lettered. The synchronous caller receives

data/lib/solid_objects/database_adapter.rb

@@ -123,17 +123,21 @@ module SolidObjects
 
     # @rbs () { () -> untyped } -> untyped
     def transaction(&block)
+      active_transaction = nil
       raise DatabaseDeadlineExceeded, "synchronous invocation deadline expired" if SyncDeadline.expired?
 
       with_connection do |connection|
         with_transaction_deadline(connection) do
           connection.transaction(requires_new: true) do
+            active_transaction = connection.current_transaction
             configure_transaction_deadline(connection)
             with_transaction_clock { block.call }
           end
         end
       end
     rescue => error
+      raise CommittedTransactionError.new(error) if active_transaction&.state&.fully_committed?
+
       raise unless deadline_error?(error)
 
       raise DatabaseDeadlineExceeded,

data/lib/solid_objects/database_adapters/sqlite.rb

@@ -33,6 +33,8 @@ module SolidObjects
         attempts = 0
         begin
           yield
+        rescue CommittedTransactionError
+          raise
         rescue => error
           raise unless busy_error?(error)
 
@@ -53,6 +55,8 @@ module SolidObjects
         with_connection do |connection|
           with_transaction_deadline(connection) { yield }
         end
+      rescue CommittedTransactionError
+        raise
       rescue DatabaseDeadlineExceeded
         raise if SyncDeadline.expired?
 

data/lib/solid_objects/errors.rb

@@ -67,6 +67,23 @@ module SolidObjects
   class DatabaseDeadlineExceeded < Error
   end
 
+  class CommittedTransactionError < Error
+    # @rbs @original_error: StandardError
+
+    attr_reader :original_error
+
+    # @rbs (StandardError) -> void
+    def initialize(original_error)
+      @original_error = original_error
+      super(original_error.message)
+    end
+
+    # @rbs () -> bot
+    def reraise
+      raise original_error, cause: original_error.cause
+    end
+  end
+
   class SyncEnqueueTimeout < Error
     # @rbs @timeout: Numeric
     # @rbs @actor_type: String

data/lib/solid_objects/executor.rb

@@ -4,6 +4,7 @@ module SolidObjects
   class Executor
     # @rbs @activation: Activation
     # @rbs @message: Message
+    # @rbs @completion_transaction: untyped
 
     # @rbs (activation: Activation, message: Message) -> void
     def initialize(activation:, message:)
@@ -35,7 +36,7 @@ module SolidObjects
         state_changed: state_after.value != state_before
       )
       true
-    rescue LostActivation
+    rescue CommittedTransactionError, LostActivation
       raise
     rescue Rejected => rejection
       activation.restore_state(state_before) if state_before
@@ -96,6 +97,7 @@ module SolidObjects
       moved_reminders = []
 
       activation.lease.fenced_transaction do |instance|
+        @completion_transaction = Record.connection.current_transaction
         # A busy database makes the adapter retry this whole block, so an
         # attempt that was rolled back must not leave its work in the lists the
         # reporting below reads. Each attempt starts from empty.
@@ -154,6 +156,12 @@ module SolidObjects
       report_large_state(state_after.byte_size)
       SolidObjects.instrument_after_commit(:"message.completed", **instrumentation_payload)
       SolidObjects.wake_up.signal
+    rescue CommittedTransactionError
+      raise
+    rescue => error
+      raise unless @completion_transaction&.state&.fully_committed?
+
+      raise CommittedTransactionError.new(error)
     end
 
     # @rbs (Integer) -> void

data/lib/solid_objects/synchronous_invocation.rb

@@ -20,6 +20,8 @@ module SolidObjects
       SyncDeadline.with(timeout:) do
         call_before_deadline(message_reference, timeout:)
       end
+    rescue CommittedTransactionError => error
+      error.reraise
     rescue ActiveRecord::RecordNotFound
       raise ActorDestroyed, "actor was destroyed while waiting for its result"
     end

data/lib/solid_objects/version.rb

@@ -1,5 +1,5 @@
 # rbs_inline: enabled
 
 module SolidObjects
-  VERSION = "0.14.5"
+  VERSION = "0.14.6"
 end

data/lib/solid_objects/worker.rb

@@ -59,6 +59,8 @@ module SolidObjects
       ).around { activation.drain }
       release_activation(activation) if activation.pass_exhausted?
       processed
+    rescue CommittedTransactionError => error
+      error.reraise
     rescue ActorDestroyed
       release_activation(activation) if activation
       0

data/sig/generated/lib/solid_objects/errors.rbs

@@ -67,6 +67,18 @@ module SolidObjects
   class DatabaseDeadlineExceeded < Error
   end
 
+  class CommittedTransactionError < Error
+    @original_error: StandardError
+
+    attr_reader original_error: untyped
+
+    # @rbs (StandardError) -> void
+    def initialize: (StandardError) -> void
+
+    # @rbs () -> bot
+    def reraise: () -> bot
+  end
+
   class SyncEnqueueTimeout < Error
     @timeout: Numeric
 

data/sig/generated/lib/solid_objects/executor.rbs

@@ -2,6 +2,8 @@
 
 module SolidObjects
   class Executor
+    @completion_transaction: untyped
+
     @message: Message
 
     @activation: Activation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_objects
 version: !ruby/object:Gem::Version
-  version: 0.14.5
+  version: 0.14.6
 platform: ruby
 authors:
 - Lucas Carlson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-03 00:00:00.000000000 Z
+date: 2026-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable