@zudojs/transactions 1.1.1 → 1.2.0

package/README.md

@@ -47,6 +47,47 @@ await manager.run(handler, {
 });
 ```
 
+## Reaching the adapter handle
+
+Whatever your adapter's `begin()` returned (typically a database client or
+connection bound to the transaction) is available inside the transaction:
+
+```typescript
+import { currentTransactionHandle, getTransactionHandle } from "@zudojs/transactions";
+
+await manager.run(async (transaction) => {
+  const tx = getTransactionHandle<PoolClient>(transaction);
+  // or, anywhere below this call in the same async flow:
+  const same = manager.getCurrentHandle<PoolClient>();
+  const alsoSame = currentTransactionHandle<PoolClient>(); // default context only
+  await tx!.query("INSERT ...");
+});
+```
+
+A savepoint resolves to its connection's handle and a participant to the
+joined transaction's. Outside a transaction, or in a non-transactional scope
+(`supports`/`not_supported`/`never` with nothing to join), the result is
+`undefined`. Use the handle to issue work; commit and roll back through the
+manager, not the handle.
+
+## Timeouts
+
+With `timeout`, the transaction's `signal` aborts when it runs out, with a
+`TransactionTimeoutError` as `signal.reason`. `run()` then stops waiting for
+the callback, rolls back, and rejects with that error. JavaScript cannot stop
+the callback itself, so pass the signal to anything cancellable:
+
+```typescript
+await manager.run(
+  async (transaction) => {
+    await fetch(url, { signal: transaction.signal });
+  },
+  { timeout: 5_000 },
+);
+```
+
+`timed_out` is emitted once, when the timeout fires.
+
 ## Propagation
 
 | Mode            | Transaction in progress      | None in progress         |
@@ -81,7 +122,8 @@ the transaction.
 | Condition                              | Error                          |
 | -------------------------------------- | ------------------------------ |
 | Transaction outlived its `timeout`      | `TransactionTimeoutError`      |
-| Marked rollback-only, then committed    | `TransactionRollbackError`     |
+| Marked rollback-only, then committed    | `TransactionRollbackOnlyError` (a `TransactionRollbackError`): "commit refused: transaction marked rollback-only" |
+| Rolling back a committed transaction    | `TransactionStateError`        |
 | Adapter lacks the requested isolation   | `TransactionIsolationError`    |
 | Adapter lacks another requested feature | `TransactionCapabilityError`   |
 | Savepoint create/rollback/release fails | `SavepointError`               |
@@ -108,6 +150,9 @@ the transaction.
   back and `commit()` rejects. A rollback can never be reported as a commit.
 - Committing a transaction that is not active throws rather than silently
   doing nothing. Only an already-committed transaction is a no-op.
+- Rolling back a committed transaction throws `TransactionStateError`: the
+  commit cannot be undone, and pretending otherwise hid bugs. Rolling back a
+  transaction that is already rolled back (or failed) is still a no-op.
 - A `nested` transaction rolls back to its savepoint, never to the connection.
   Savepoints are always created on the connection, including when the
   enclosing scope is itself a savepoint or a participant.

package/dist/context/context.handle.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Public, read-only access to a transaction's adapter handle.
+ *
+ * @module context/context.handle
+ */
+import type { Transaction } from "../transactionTypes/transaction.interface.js";
+import type { TransactionContext } from "../transactionTypes/transactionAdapter.js";
+/**
+ * The adapter handle a transaction runs on: whatever the adapter's
+ * `begin()` returned (for example a database client or connection bound to
+ * the transaction).
+ *
+ * A savepoint resolves to its connection's handle and a participant to the
+ * handle of the transaction it joined. A non-transactional scope
+ * (`supports`, `not_supported`, `never`) has none and yields `undefined`.
+ *
+ * The handle is for issuing work inside the transaction. Committing or
+ * rolling back through it directly bypasses the manager's state machine,
+ * hooks and events; use the manager for that.
+ *
+ * @typeParam THandle - The handle type your adapter's `begin()` returns.
+ * @throws {TypeError} when the transaction was not created by this package.
+ */
+export declare function getTransactionHandle<THandle = unknown>(transaction: Transaction): THandle | undefined;
+/**
+ * The adapter handle of the transaction in scope for the current async
+ * execution, or `undefined` outside a transaction.
+ *
+ * Uses the default context unless one is supplied; pass the same context
+ * the manager was created with when it was given a custom one (or call the
+ * manager's `getCurrentHandle()`).
+ *
+ * @typeParam THandle - The handle type your adapter's `begin()` returns.
+ */
+export declare function currentTransactionHandle<THandle = unknown>(context?: TransactionContext): THandle | undefined;
+//# sourceMappingURL=context.handle.d.ts.map

package/dist/context/context.handle.js

@@ -0,0 +1,41 @@
+/**
+ * Public, read-only access to a transaction's adapter handle.
+ *
+ * @module context/context.handle
+ */
+import { connectionHandle } from "../transaction/transaction.internal.js";
+import { getDefaultContext } from "./context.core.js";
+/**
+ * The adapter handle a transaction runs on: whatever the adapter's
+ * `begin()` returned (for example a database client or connection bound to
+ * the transaction).
+ *
+ * A savepoint resolves to its connection's handle and a participant to the
+ * handle of the transaction it joined. A non-transactional scope
+ * (`supports`, `not_supported`, `never`) has none and yields `undefined`.
+ *
+ * The handle is for issuing work inside the transaction. Committing or
+ * rolling back through it directly bypasses the manager's state machine,
+ * hooks and events; use the manager for that.
+ *
+ * @typeParam THandle - The handle type your adapter's `begin()` returns.
+ * @throws {TypeError} when the transaction was not created by this package.
+ */
+export function getTransactionHandle(transaction) {
+    return connectionHandle(transaction);
+}
+/**
+ * The adapter handle of the transaction in scope for the current async
+ * execution, or `undefined` outside a transaction.
+ *
+ * Uses the default context unless one is supplied; pass the same context
+ * the manager was created with when it was given a custom one (or call the
+ * manager's `getCurrentHandle()`).
+ *
+ * @typeParam THandle - The handle type your adapter's `begin()` returns.
+ */
+export function currentTransactionHandle(context = getDefaultContext()) {
+    const transaction = context.get();
+    return transaction ? getTransactionHandle(transaction) : undefined;
+}
+//# sourceMappingURL=context.handle.js.map

package/dist/context/index.d.ts

@@ -4,4 +4,5 @@
  * @module context
  */
 export { createTransactionContext, getDefaultContext, resetDefaultContext, } from "./context.core.js";
+export { getTransactionHandle, currentTransactionHandle, } from "./context.handle.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/context/index.js

@@ -4,4 +4,5 @@
  * @module context
  */
 export { createTransactionContext, getDefaultContext, resetDefaultContext, } from "./context.core.js";
+export { getTransactionHandle, currentTransactionHandle, } from "./context.handle.js";
 //# sourceMappingURL=index.js.map

package/dist/manager/manager.commit.d.ts

@@ -20,7 +20,9 @@ import type { TransactionEmitter } from "./manager.events.js";
  * is a programming error, not a no-op.
  *
  * @throws {TransactionTimeoutError} when the transaction outlived its timeout.
- * @throws {TransactionRollbackError} when the transaction is rollback-only.
+ * @throws {TransactionRollbackOnlyError} when the transaction is rollback-only
+ *   (a `TransactionRollbackError` subclass): the commit was refused and the
+ *   transaction rolled back.
  * @throws {TransactionStateError} when the transaction cannot be committed.
  * @throws {TransactionCommitError} when the adapter refuses the commit.
  */
@@ -28,6 +30,12 @@ export declare function commitTransaction(transaction: Transaction, adapter: Tra
 /**
  * Rollback a transaction with hooks and adapter coordination.
  *
+ * Rolling back a transaction that is already rolled back or failed is a
+ * no-op; a committed transaction cannot be undone, so asking to roll it
+ * back is a programming error (the same rule `Transaction.rollback()`
+ * enforces) rather than a silent no-op.
+ *
+ * @throws {TransactionStateError} when the transaction is already committed.
  * @throws {TransactionRollbackError} when the adapter refuses the rollback.
  */
 export declare function rollbackTransaction(transaction: Transaction, adapter: TransactionAdapter, reason?: unknown, hooks?: TransactionHooks, emit?: TransactionEmitter): Promise<void>;

package/dist/manager/manager.commit.js

@@ -9,7 +9,7 @@
  */
 import { asSavepointHandle, internals, } from "../transaction/transaction.internal.js";
 import { canTransition } from "../transaction/transactionStateMachine.js";
-import { SavepointError, TransactionCommitError, TransactionRollbackError, TransactionStateError, TransactionTimeoutError, } from "../transactionErrors/transactionError.types.js";
+import { SavepointError, TransactionCommitError, TransactionRollbackError, TransactionRollbackOnlyError, TransactionStateError, TransactionTimeoutError, } from "../transactionErrors/transactionError.types.js";
 import { noopEmitter, TRANSACTION_EVENTS } from "./manager.events.js";
 /** Moves a transaction to `failed` when the state machine allows it. */
 function markFailed(transaction) {
@@ -65,7 +65,9 @@ async function adapterRollback(transaction, adapter, reason) {
  * is a programming error, not a no-op.
  *
  * @throws {TransactionTimeoutError} when the transaction outlived its timeout.
- * @throws {TransactionRollbackError} when the transaction is rollback-only.
+ * @throws {TransactionRollbackOnlyError} when the transaction is rollback-only
+ *   (a `TransactionRollbackError` subclass): the commit was refused and the
+ *   transaction rolled back.
  * @throws {TransactionStateError} when the transaction cannot be committed.
  * @throws {TransactionCommitError} when the adapter refuses the commit.
  */
@@ -85,15 +87,12 @@ export async function commitTransaction(transaction, adapter, hooks, emit = noop
         const reason = internals(transaction)._getRollbackOnlyReason() ?? "marked rollback-only";
         await rollbackTransaction(transaction, adapter, reason, hooks, emit);
         // A timeout is a distinct failure from a caller marking the transaction
-        // rollback-only, and the timed-out case used to be indistinguishable
-        // because both raised TransactionRollbackError.
+        // rollback-only. `timed_out` was already emitted by the timer when the
+        // timeout fired; emitting it again here reported one timeout twice.
         if (transaction.timedOut) {
-            emit(TRANSACTION_EVENTS.TIMED_OUT, transaction, reason);
             throw new TransactionTimeoutError(transaction.id, transaction.options.timeout ?? 0);
         }
-        throw new TransactionRollbackError(transaction.id, {
-            originalError: reason,
-        });
+        throw new TransactionRollbackOnlyError(transaction.id, reason);
     }
     if (hooks?.beforeCommit)
         await hooks.beforeCommit({ transaction });
@@ -133,6 +132,12 @@ export async function commitTransaction(transaction, adapter, hooks, emit = noop
 /**
  * Rollback a transaction with hooks and adapter coordination.
  *
+ * Rolling back a transaction that is already rolled back or failed is a
+ * no-op; a committed transaction cannot be undone, so asking to roll it
+ * back is a programming error (the same rule `Transaction.rollback()`
+ * enforces) rather than a silent no-op.
+ *
+ * @throws {TransactionStateError} when the transaction is already committed.
  * @throws {TransactionRollbackError} when the adapter refuses the rollback.
  */
 export async function rollbackTransaction(transaction, adapter, reason, hooks, emit = noopEmitter) {
@@ -140,9 +145,10 @@ export async function rollbackTransaction(transaction, adapter, reason, hooks, e
         await transaction.rollback(reason);
         return;
     }
-    if (transaction.state === "committed" ||
-        transaction.state === "rolled_back" ||
-        transaction.state === "failed") {
+    if (transaction.state === "committed") {
+        throw new TransactionStateError(transaction.state, "rollback");
+    }
+    if (transaction.state === "rolled_back" || transaction.state === "failed") {
         return;
     }
     if (hooks?.beforeRollback)

package/dist/manager/manager.core.d.ts

@@ -39,6 +39,12 @@ export declare function createTransactionManager(options: TransactionManagerOpti
      * Only a transaction this call opened is completed here: joining an
      * enclosing transaction must not commit it, and a failure inside a
      * participant marks the enclosing transaction rollback-only instead.
+     *
+     * When the transaction times out, `transaction.signal` aborts and this
+     * stops waiting for the callback: the transaction is rolled back and
+     * the call rejects with `TransactionTimeoutError`. An error raised
+     * after a successful commit (for example by an `afterCommit` hook) is
+     * rethrown without attempting a rollback.
      */
     run<T>(callback: (transaction: Transaction) => Promise<T>, opts?: TransactionOptions): Promise<T>;
     /**
@@ -53,5 +59,11 @@ export declare function createTransactionManager(options: TransactionManagerOpti
     rollback(transaction: Transaction, reason?: unknown): Promise<void>;
     /** The transaction in scope for the current async execution, if any. */
     getCurrent(): Transaction | undefined;
+    /**
+     * The adapter handle (what `adapter.begin()` returned) of the
+     * transaction in scope for the current async execution, or `undefined`
+     * outside a transaction. See `getTransactionHandle`.
+     */
+    getCurrentHandle<THandle = unknown>(): THandle | undefined;
 };
 //# sourceMappingURL=manager.core.d.ts.map

package/dist/manager/manager.core.js

@@ -7,6 +7,8 @@ import { getDefaultContext } from "../context/context.core.js";
 import { internals } from "../transaction/transaction.internal.js";
 import { isTerminal } from "../transaction/transactionStateMachine.js";
 import { TransactionRollbackError } from "../transactionErrors/transactionError.types.js";
+import { getTransactionHandle } from "../context/context.handle.js";
+import { raceSignal } from "../utils/utils.signal.js";
 import { commitTransaction, rollbackTransaction } from "./manager.commit.js";
 import { resolvePropagation, suspendsTransaction, } from "./manager.propagation.js";
 import { withRetry } from "./manager.retry.js";
@@ -90,6 +92,12 @@ export function createTransactionManager(options) {
          * Only a transaction this call opened is completed here: joining an
          * enclosing transaction must not commit it, and a failure inside a
          * participant marks the enclosing transaction rollback-only instead.
+         *
+         * When the transaction times out, `transaction.signal` aborts and this
+         * stops waiting for the callback: the transaction is rolled back and
+         * the call rejects with `TransactionTimeoutError`. An error raised
+         * after a successful commit (for example by an `afterCommit` hook) is
+         * rethrown without attempting a rollback.
          */
         async run(callback, opts) {
             // A failed attempt that only JOINED an enclosing transaction has not
@@ -109,11 +117,13 @@ export function createTransactionManager(options) {
                 joined = transaction.kind === "participant";
                 const body = async () => {
                     try {
-                        const result = await callback(transaction);
+                        const result = await raceSignal(callback(transaction), transaction.signal);
                         await this.commit(transaction);
                         return result;
                     }
                     catch (error) {
+                        if (transaction.state === "committed")
+                            throw error;
                         try {
                             await this.rollback(transaction, error);
                         }
@@ -166,6 +176,15 @@ export function createTransactionManager(options) {
         getCurrent() {
             return context.get();
         },
+        /**
+         * The adapter handle (what `adapter.begin()` returned) of the
+         * transaction in scope for the current async execution, or `undefined`
+         * outside a transaction. See `getTransactionHandle`.
+         */
+        getCurrentHandle() {
+            const current = context.get();
+            return current ? getTransactionHandle(current) : undefined;
+        },
     };
 }
 //# sourceMappingURL=manager.core.js.map

package/dist/transaction/transaction.core.js

@@ -2,7 +2,7 @@
  * Core Transaction implementation with state machine enforcement.
  */
 import { randomBytes } from "node:crypto";
-import { TransactionRollbackError, TransactionStateError, } from "../transactionErrors/transactionError.types.js";
+import { TransactionRollbackError, TransactionRollbackOnlyError, TransactionStateError, TransactionTimeoutError, } from "../transactionErrors/transactionError.types.js";
 import { canTransition, createTransitionFunction, } from "./transactionStateMachine.js";
 import { attachInternals } from "./transaction.internal.js";
 import { deferCallbacksToParent } from "./transaction.savepoint.js";
@@ -43,6 +43,10 @@ export function createTransaction(options = {}, parentId, kind = "root", parent)
     const afterRollbackCallbacks = [];
     let callbackErrors = [];
     let handle;
+    const controller = new AbortController();
+    const signal = parent
+        ? AbortSignal.any([controller.signal, parent.signal])
+        : controller.signal;
     const transition = createTransitionFunction(() => state, (next) => {
         state = next;
     });
@@ -75,6 +79,9 @@ export function createTransaction(options = {}, parentId, kind = "root", parent)
         get timedOut() {
             return timedOut;
         },
+        get signal() {
+            return signal;
+        },
         /**
          * Mark the transaction committed and run its after-commit callbacks.
          *
@@ -88,9 +95,7 @@ export function createTransaction(options = {}, parentId, kind = "root", parent)
                 throw new TransactionStateError(state, "commit");
             }
             if (rollbackOnly) {
-                throw new TransactionRollbackError(id, {
-                    originalError: rollbackOnlyReason ?? "marked rollback-only",
-                });
+                throw new TransactionRollbackOnlyError(id, rollbackOnlyReason);
             }
             transition("committing");
             transition("committed");
@@ -145,6 +150,7 @@ export function createTransaction(options = {}, parentId, kind = "root", parent)
         _transition: transition,
         _markTimedOut: () => {
             timedOut = true;
+            controller.abort(new TransactionTimeoutError(id, frozenOptions.timeout ?? 0));
         },
         _getRollbackOnlyReason: () => rollbackOnlyReason,
         _drainCallbackErrors: () => callbackErrors.splice(0),

package/dist/transaction/transaction.participant.js

@@ -43,6 +43,9 @@ export function createParticipant(parent) {
         get timedOut() {
             return parent.timedOut;
         },
+        get signal() {
+            return parent.signal;
+        },
         /** No-op: the transaction is committed by whoever opened it. */
         async commit() { },
         /** Marks the joined transaction rollback-only. */

package/dist/transactionErrors/index.d.ts

@@ -2,5 +2,5 @@
  * Transaction error types.
  */
 export { TransactionError, type TransactionErrorOptions, } from "./transactionError.base.js";
-export { TransactionStateError, TransactionTimeoutError, TransactionCommitError, TransactionRollbackError, TransactionAdapterError, TransactionPropagationError, TransactionIsolationError, SavepointError, TransactionRequiredError, TransactionUnexpectedError, TransactionCapabilityError, } from "./transactionError.types.js";
+export { TransactionStateError, TransactionTimeoutError, TransactionCommitError, TransactionRollbackError, TransactionRollbackOnlyError, TransactionAdapterError, TransactionPropagationError, TransactionIsolationError, SavepointError, TransactionRequiredError, TransactionUnexpectedError, TransactionCapabilityError, } from "./transactionError.types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/transactionErrors/index.js

@@ -2,5 +2,5 @@
  * Transaction error types.
  */
 export { TransactionError, } from "./transactionError.base.js";
-export { TransactionStateError, TransactionTimeoutError, TransactionCommitError, TransactionRollbackError, TransactionAdapterError, TransactionPropagationError, TransactionIsolationError, SavepointError, TransactionRequiredError, TransactionUnexpectedError, TransactionCapabilityError, } from "./transactionError.types.js";
+export { TransactionStateError, TransactionTimeoutError, TransactionCommitError, TransactionRollbackError, TransactionRollbackOnlyError, TransactionAdapterError, TransactionPropagationError, TransactionIsolationError, SavepointError, TransactionRequiredError, TransactionUnexpectedError, TransactionCapabilityError, } from "./transactionError.types.js";
 //# sourceMappingURL=index.js.map

package/dist/transactionErrors/transactionError.types.d.ts

@@ -5,5 +5,5 @@
  * same names, constructor signatures and codes, so `instanceof` checks match
  * across both import paths.
  */
-export { TransactionStateError, TransactionTimeoutError, TransactionCommitError, TransactionRollbackError, TransactionAdapterError, TransactionPropagationError, TransactionIsolationError, SavepointError, TransactionRequiredError, TransactionUnexpectedError, TransactionCapabilityError, } from "@zudojs/errors";
+export { TransactionStateError, TransactionTimeoutError, TransactionCommitError, TransactionRollbackError, TransactionRollbackOnlyError, TransactionAdapterError, TransactionPropagationError, TransactionIsolationError, SavepointError, TransactionRequiredError, TransactionUnexpectedError, TransactionCapabilityError, } from "@zudojs/errors";
 //# sourceMappingURL=transactionError.types.d.ts.map

package/dist/transactionErrors/transactionError.types.js

@@ -5,5 +5,5 @@
  * same names, constructor signatures and codes, so `instanceof` checks match
  * across both import paths.
  */
-export { TransactionStateError, TransactionTimeoutError, TransactionCommitError, TransactionRollbackError, TransactionAdapterError, TransactionPropagationError, TransactionIsolationError, SavepointError, TransactionRequiredError, TransactionUnexpectedError, TransactionCapabilityError, } from "@zudojs/errors";
+export { TransactionStateError, TransactionTimeoutError, TransactionCommitError, TransactionRollbackError, TransactionRollbackOnlyError, TransactionAdapterError, TransactionPropagationError, TransactionIsolationError, SavepointError, TransactionRequiredError, TransactionUnexpectedError, TransactionCapabilityError, } from "@zudojs/errors";
 //# sourceMappingURL=transactionError.types.js.map

package/dist/transactionTypes/transaction.interface.d.ts

@@ -64,9 +64,23 @@ export interface Transaction {
     readonly metadata: ReadonlyMap<string, unknown>;
     /** Whether a timeout was detected. */
     readonly timedOut: boolean;
+    /**
+     * Aborted when the transaction outlives its `timeout`, with a
+     * `TransactionTimeoutError` as `signal.reason`. Pass it to cancellable
+     * work (queries, `fetch`, timers) so a timed-out callback stops instead
+     * of running on. `run()` also stops waiting for the callback, rolls back
+     * and rejects with that error. A participant exposes the signal of the
+     * transaction it joined; a savepoint's signal also aborts with its
+     * parent's. Never aborts when no timeout is set.
+     */
+    readonly signal: AbortSignal;
     /** Commit the transaction. */
     commit(): Promise<void>;
-    /** Rollback the transaction. */
+    /**
+     * Rollback the transaction. Idempotent once rolled back or failed; throws
+     * `TransactionStateError` on a committed transaction, which can no
+     * longer be undone.
+     */
     rollback(reason?: unknown): Promise<void>;
     /** Mark the transaction as rollback-only (prevents commit). */
     markRollbackOnly(reason?: unknown): void;

package/dist/utils/index.d.ts

@@ -4,4 +4,5 @@
  * @module utils
  */
 export { isTerminalState, isModifiable, summarizeTransaction, } from "./utils.helper.js";
+export { raceSignal } from "./utils.signal.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -4,4 +4,5 @@
  * @module utils
  */
 export { isTerminalState, isModifiable, summarizeTransaction, } from "./utils.helper.js";
+export { raceSignal } from "./utils.signal.js";
 //# sourceMappingURL=index.js.map

package/dist/utils/utils.signal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Abort-signal helpers.
+ *
+ * @module utils/utils.signal
+ */
+/**
+ * Resolves or rejects with `work`, or rejects with `signal.reason` as soon
+ * as `signal` aborts, whichever happens first.
+ *
+ * The abandoned `work` promise keeps running (JavaScript cannot cancel it);
+ * its eventual rejection is observed so it never surfaces as an unhandled
+ * rejection. Cooperative code should watch the same signal and stop.
+ */
+export declare function raceSignal<T>(work: Promise<T>, signal: AbortSignal): Promise<T>;
+//# sourceMappingURL=utils.signal.d.ts.map

package/dist/utils/utils.signal.js

@@ -0,0 +1,34 @@
+/**
+ * Abort-signal helpers.
+ *
+ * @module utils/utils.signal
+ */
+/**
+ * Resolves or rejects with `work`, or rejects with `signal.reason` as soon
+ * as `signal` aborts, whichever happens first.
+ *
+ * The abandoned `work` promise keeps running (JavaScript cannot cancel it);
+ * its eventual rejection is observed so it never surfaces as an unhandled
+ * rejection. Cooperative code should watch the same signal and stop.
+ */
+export function raceSignal(work, signal) {
+    if (signal.aborted) {
+        work.catch(() => undefined);
+        return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            work.catch(() => undefined);
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        work.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
+//# sourceMappingURL=utils.signal.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/transactions",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Transaction lifecycle and coordination with state machine, AsyncLocalStorage context propagation, savepoints, hooks, and adapter abstraction.",
   "license": "MIT",
   "author": {
@@ -25,14 +25,14 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/errors": "1.1.0"
+    "@zudojs/errors": "1.3.0"
   },
   "engines": {
     "node": ">=24.0.0"
   },
   "devDependencies": {
     "typescript": "7.0.2",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.1"
   },
   "publishConfig": {
     "access": "public"
@@ -43,7 +43,7 @@
     "savepoints",
     "rollback"
   ],
-  "homepage": "https://github.com/oyinlola-tech/zudo#readme",
+  "homepage": "https://zudojs.oyinlola.site/docs/packages-transactions",
   "bugs": {
     "url": "https://github.com/oyinlola-tech/zudo/issues"
   },