@spfn/core 0.3.0-beta.27 → 0.3.0-beta.28

package/dist/contract/index.d.ts

@@ -1,4 +1,4 @@
-import { E as EventRouterDef } from '../router-D5B0cpVN.js';
+import { E as EventRouterDef } from '../router-CX5uVjmU.js';
 import { R as Router } from '../router-4YoIy5fN.js';
 import { C as ContractDocument, a as ContractViolation, b as ContractOperation, c as ContractSnapshot } from '../types-5Rl11_Nb.js';
 export { d as CompatibilityPolicy, e as ContractEvent, f as ContractEvents, g as ContractRequest, h as ContractViolationKind, J as JsonSchema } from '../types-5Rl11_Nb.js';

package/dist/db/index.d.ts

@@ -1165,11 +1165,11 @@ type TransactionContext<TDatabase extends DrizzleDatabase = DrizzleDatabase> = {
     /** Unique transaction ID for logging and tracing */
     txId: string;
     level: number;
-    /** Callbacks to execute before the root transaction commits (still inside it) */
+    /** beforeCommit callbacks registered in THIS frame (root or savepoint) */
     beforeCommitCallbacks: BeforeCommitCallback[];
-    /** Callbacks to execute after root transaction commits */
+    /** afterCommit callbacks registered in THIS frame (root or savepoint) */
     afterCommitCallbacks: AfterCommitCallback[];
-    /** Callbacks to execute after the root transaction rolled back */
+    /** afterRollback callbacks registered in THIS frame (root or savepoint) */
     afterRollbackCallbacks: AfterRollbackCallback[];
     /** Serializes the savepoint frames opened directly off THIS context */
     nestedFrames: NestedFrameGate;
@@ -1204,7 +1204,12 @@ callback: () => Promise<T>): Promise<T>;
  *
  * - Inside a transaction: queued and executed after root transaction commits
  * - Outside a transaction: executed immediately (already "committed")
- * - Nested transactions: callbacks bubble up to root transaction
+ * - Nested transactions: the callback belongs to the savepoint that registered
+ *   it. It reaches the root only if that savepoint (and every one around it)
+ *   resolved; a savepoint that rolls back drops it, even when the root commits
+ * - A hook registered after its frame (root or savepoint) has settled is
+ *   dropped: the frame's queue was handed on, or discarded, when it settled.
+ *   Register hooks in the awaited call chain, not from detached work
  * - Callbacks run outside transaction context (new connection for DB access)
  * - Errors are logged but never thrown (commit already succeeded)
  *
@@ -1233,7 +1238,13 @@ declare function onAfterCommit(callback: AfterCommitCallback): void;
  * - Outside a transaction: executed immediately with a WARNING (same rationale as
  *   onAfterCommit — there is nothing left to commit), and the abort semantics
  *   below do not apply: there is no transaction for a throw to roll back
- * - Nested transactions: callbacks bubble up to root transaction
+ * - Nested transactions: the callback belongs to the savepoint that registered
+ *   it. A savepoint that resolved hands it to the root, where it still runs
+ *   before the root's COMMIT (never at the savepoint); one that rolls back
+ *   drops it, and the root commits without it
+ * - A hook registered after its frame (root or savepoint) has settled is
+ *   dropped: the frame's queue was handed on, or discarded, when it settled.
+ *   Register hooks in the awaited call chain, not from detached work
  * - Callbacks run in registration order, inside the transaction context
  *   (getTransaction() returns the live tx)
  * - The queue is snapshot before the pass, so a callback registered BY a
@@ -1265,13 +1276,30 @@ declare function onBeforeCommit(callback: BeforeCommitCallback): void;
 /**
  * Register a callback to run after the current transaction rolled back
  *
- * - Inside a transaction: queued and executed after the ROOT transaction rolled
- *   back, before the causing error leaves runInTransaction / the middleware
+ * - Inside a transaction: queued and executed once the work registered with it
+ *   is rolled back, before the causing error leaves runInTransaction / the
+ *   middleware
  * - Outside a transaction: no-op with a warning — there is no rollback to wait for
- * - Nested transactions: callbacks bubble up to root transaction. A nested
- *   rollback that the root survives does NOT fire them; these hooks are about
- *   the root transaction's fate, not a savepoint's
- * - Callbacks run outside the transaction context (new connection for DB access)
+ * - Nested transactions: the callback belongs to the savepoint that registered
+ *   it. If that savepoint rolls back, the callback runs right then, awaited
+ *   before the error leaves the nested runInTransaction, and never again — the
+ *   root's own afterRollback callbacks do not run when the root commits. If the
+ *   savepoint resolved, the callback passes to the root and runs only if the
+ *   root rolls back
+ * - After a ROOT rollback, callbacks run outside any transaction context (new
+ *   connection for DB access). After a SAVEPOINT rollback the root is still
+ *   open: getTransactionContext() is the parent's, so DB work in the callback
+ *   joins the parent transaction and commits or rolls back with it
+ * - A statement that FAILS in a savepoint's callback aborts the parent
+ *   transaction: the error is logged and swallowed here, but the root's next
+ *   statement then fails with 25P02 (current transaction is aborted). If the
+ *   root runs none, its COMMIT fails with the callback's error. Either way,
+ *   everything the root wrote rolls back. A compensation may call
+ *   runInTransaction itself — that opens a savepoint on the parent, which
+ *   contains such a failure — and hooks it registers belong to the parent
+ * - A hook registered after its frame (root or savepoint) has settled is
+ *   dropped: the frame's queue was handed on, or discarded, when it settled.
+ *   Register hooks in the awaited call chain, not from detached work
  * - Errors are logged but never thrown: the original error keeps propagating
  *   unchanged, never replaced by a callback failure
  *

package/dist/db/index.js

@@ -1790,17 +1790,14 @@ function runWithTransaction(tx, txId, callback) {
   } else {
     txLogger.debug("Root transaction context set", { txId, level: newLevel });
   }
-  const beforeCommitCallbacks = existingContext?.beforeCommitCallbacks ?? [];
-  const afterCommitCallbacks = existingContext?.afterCommitCallbacks ?? [];
-  const afterRollbackCallbacks = existingContext?.afterRollbackCallbacks ?? [];
   return asyncContext.run(
     {
       tx,
       txId,
       level: newLevel,
-      beforeCommitCallbacks,
-      afterCommitCallbacks,
-      afterRollbackCallbacks,
+      beforeCommitCallbacks: [],
+      afterCommitCallbacks: [],
+      afterRollbackCallbacks: [],
       nestedFrames: createNestedFrameGate()
     },
     callback
@@ -1872,6 +1869,18 @@ async function runAfterRollbackCallbacks(callbacks, txId, context, enableLogging
     }));
   }
 }
+function promoteFrameHooks(frame, parent) {
+  parent.beforeCommitCallbacks.push(...frame.beforeCommitCallbacks);
+  parent.afterCommitCallbacks.push(...frame.afterCommitCallbacks);
+  parent.afterRollbackCallbacks.push(...frame.afterRollbackCallbacks);
+}
+async function discardFrameHooks(frame, parent, error, txId, context, enableLogging) {
+  await asyncContext.run(
+    { ...parent, nestedFrames: createNestedFrameGate() },
+    () => runAfterRollbackCallbacks(frame.afterRollbackCallbacks, txId, context, enableLogging)
+  ).catch(() => void 0);
+  throw error;
+}
 async function runInTransaction(callback, options = {}) {
   const defaultTimeout = env.TRANSACTION_TIMEOUT;
   const {
@@ -1977,7 +1986,20 @@ async function runInTransaction(callback, options = {}) {
   const openTransaction = (body) => {
     if (savepointOwner) {
       return savepointOwner.nestedFrames.run(
-        () => savepointOwner.tx.transaction(body)
+        () => savepointOwner.tx.transaction(body).then(
+          (result) => {
+            promoteFrameHooks({ beforeCommitCallbacks, afterCommitCallbacks, afterRollbackCallbacks }, savepointOwner);
+            return result;
+          },
+          (error) => discardFrameHooks(
+            { afterRollbackCallbacks },
+            savepointOwner,
+            error,
+            txId,
+            context,
+            enableLogging
+          )
+        )
       );
     }
     if (requiresNew) {
@@ -1995,13 +2017,11 @@ async function runInTransaction(callback, options = {}) {
         await transaction.execute(sql.raw(`SET LOCAL idle_in_transaction_session_timeout = ${idleTimeout}`));
       }
       return await runWithTransaction(transaction, txId, async () => {
-        if (!isNested) {
-          const ctx = getTransactionContext();
-          if (ctx) {
-            beforeCommitCallbacks = ctx.beforeCommitCallbacks;
-            afterCommitCallbacks = ctx.afterCommitCallbacks;
-            afterRollbackCallbacks = ctx.afterRollbackCallbacks;
-          }
+        const ctx = getTransactionContext();
+        if (ctx) {
+          beforeCommitCallbacks = ctx.beforeCommitCallbacks;
+          afterCommitCallbacks = ctx.afterCommitCallbacks;
+          afterRollbackCallbacks = ctx.afterRollbackCallbacks;
         }
         const innerResult = await callback(transaction);
         if (!isNested && beforeCommitCallbacks.length > 0) {