@getstrata/core 2.2.8 → 2.2.9

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @getstrata/core changelog
 
+## 2.2.9
+
+- Support native cancellable transaction acquisition
+
 ## 2.2.8
 
 - Add bounded read-only Postgres outbox metrics

package/dist/core/database/baseRepository.d.ts

@@ -11,6 +11,12 @@ type ExtendedQueryOptions<TEntity extends object> = QueryOptions<TEntity> & {
 interface DatabaseConnection {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
     begin?<T>(callback: (transaction: DatabaseConnection) => Promise<T>): Promise<T>;
+    /** Optional native cancellable pool checkout; absence must not be silently emulated. */
+    reserve?(options: {
+        signal?: AbortSignal;
+    }): Promise<DatabaseConnection & {
+        release(): void | Promise<void>;
+    }>;
     /** SQLite closes synchronously; pooled drivers return a promise. */
     close?(): void | Promise<void>;
 }

package/dist/core/database/transaction.d.ts

@@ -1,4 +1,9 @@
 import type { DatabaseConnection } from "./baseRepository.ts";
 import { hasActiveTransaction, requestTransactionRollback } from "./transactionControl.ts";
-declare function runInTransaction<TValue>(operation: (connection: DatabaseConnection) => Promise<TValue>): Promise<TValue>;
+interface TransactionOptions {
+    /** Cancel admission/pool checkout only. Does not cancel SQL or an admitted business callback. */
+    acquisitionSignal?: AbortSignal;
+}
+declare function runInTransaction<TValue>(operation: (connection: DatabaseConnection) => Promise<TValue>, options?: TransactionOptions): Promise<TValue>;
+export type { TransactionOptions };
 export { hasActiveTransaction, requestTransactionRollback, runInTransaction };

package/dist/entries/audit/exportAuditLogs.js

@@ -697,18 +697,35 @@ async function runInSavepoint(connection, operation) {
 function supportsTransactions(connection) {
   return typeof connection.begin === "function";
 }
-async function runInTransaction(operation) {
+async function runInTransaction(operation, options = {}) {
+  const signal = options.acquisitionSignal;
+  signal?.throwIfAborted();
+  const admittedOperation = (connection) => {
+    signal?.throwIfAborted();
+    return operation(connection);
+  };
   const pool = resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), operation);
+    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
   }
   return await settleTransaction(() => runWithDeferredModelEvents(async () => {
-    return await pool.begin(async (transaction) => {
-      return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(transaction))))));
-    });
+    if (signal && !pool.reserve)
+      throw new Error("Active database connection does not support cancellable transaction acquisition.");
+    const reserved = signal ? await pool.reserve?.({ signal }) : undefined;
+    const connection = reserved ?? pool;
+    try {
+      signal?.throwIfAborted();
+      if (!supportsTransactions(connection))
+        throw new Error("Reserved database connection does not support transactions.");
+      return await connection.begin(async (transaction) => {
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+      });
+    } finally {
+      await reserved?.release();
+    }
   }));
 }
 var transactionFrame, outerFrames;

package/dist/entries/auth/scimAuthMiddleware.js

@@ -653,18 +653,35 @@ async function runInSavepoint(connection, operation) {
 function supportsTransactions(connection) {
   return typeof connection.begin === "function";
 }
-async function runInTransaction(operation) {
+async function runInTransaction(operation, options = {}) {
+  const signal = options.acquisitionSignal;
+  signal?.throwIfAborted();
+  const admittedOperation = (connection) => {
+    signal?.throwIfAborted();
+    return operation(connection);
+  };
   const pool = resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), operation);
+    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
   }
   return await settleTransaction(() => runWithDeferredModelEvents(async () => {
-    return await pool.begin(async (transaction) => {
-      return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(transaction))))));
-    });
+    if (signal && !pool.reserve)
+      throw new Error("Active database connection does not support cancellable transaction acquisition.");
+    const reserved = signal ? await pool.reserve?.({ signal }) : undefined;
+    const connection = reserved ?? pool;
+    try {
+      signal?.throwIfAborted();
+      if (!supportsTransactions(connection))
+        throw new Error("Reserved database connection does not support transactions.");
+      return await connection.begin(async (transaction) => {
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+      });
+    } finally {
+      await reserved?.release();
+    }
   }));
 }
 var transactionFrame, outerFrames;

package/dist/entries/jobs/exportAuditLogsJob.js

@@ -697,18 +697,35 @@ async function runInSavepoint(connection, operation) {
 function supportsTransactions(connection) {
   return typeof connection.begin === "function";
 }
-async function runInTransaction(operation) {
+async function runInTransaction(operation, options = {}) {
+  const signal = options.acquisitionSignal;
+  signal?.throwIfAborted();
+  const admittedOperation = (connection) => {
+    signal?.throwIfAborted();
+    return operation(connection);
+  };
   const pool = resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), operation);
+    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
   }
   return await settleTransaction(() => runWithDeferredModelEvents(async () => {
-    return await pool.begin(async (transaction) => {
-      return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(transaction))))));
-    });
+    if (signal && !pool.reserve)
+      throw new Error("Active database connection does not support cancellable transaction acquisition.");
+    const reserved = signal ? await pool.reserve?.({ signal }) : undefined;
+    const connection = reserved ?? pool;
+    try {
+      signal?.throwIfAborted();
+      if (!supportsTransactions(connection))
+        throw new Error("Reserved database connection does not support transactions.");
+      return await connection.begin(async (transaction) => {
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+      });
+    } finally {
+      await reserved?.release();
+    }
   }));
 }
 var transactionFrame, outerFrames;

package/dist/entries/tenant/databaseTenantContext.js

@@ -697,18 +697,35 @@ async function runInSavepoint(connection, operation) {
 function supportsTransactions(connection) {
   return typeof connection.begin === "function";
 }
-async function runInTransaction(operation) {
+async function runInTransaction(operation, options = {}) {
+  const signal = options.acquisitionSignal;
+  signal?.throwIfAborted();
+  const admittedOperation = (connection) => {
+    signal?.throwIfAborted();
+    return operation(connection);
+  };
   const pool = resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), operation);
+    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
   }
   return await settleTransaction(() => runWithDeferredModelEvents(async () => {
-    return await pool.begin(async (transaction) => {
-      return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(transaction))))));
-    });
+    if (signal && !pool.reserve)
+      throw new Error("Active database connection does not support cancellable transaction acquisition.");
+    const reserved = signal ? await pool.reserve?.({ signal }) : undefined;
+    const connection = reserved ?? pool;
+    try {
+      signal?.throwIfAborted();
+      if (!supportsTransactions(connection))
+        throw new Error("Reserved database connection does not support transactions.");
+      return await connection.begin(async (transaction) => {
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+      });
+    } finally {
+      await reserved?.release();
+    }
   }));
 }
 var transactionFrame, outerFrames;

package/dist/entries/tenant/tenantDatabaseScope.js

@@ -631,18 +631,35 @@ async function runInSavepoint(connection, operation) {
 function supportsTransactions(connection) {
   return typeof connection.begin === "function";
 }
-async function runInTransaction(operation) {
+async function runInTransaction(operation, options = {}) {
+  const signal = options.acquisitionSignal;
+  signal?.throwIfAborted();
+  const admittedOperation = (connection) => {
+    signal?.throwIfAborted();
+    return operation(connection);
+  };
   const pool = resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), operation);
+    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
   }
   return await settleTransaction(() => runWithDeferredModelEvents(async () => {
-    return await pool.begin(async (transaction) => {
-      return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(transaction))))));
-    });
+    if (signal && !pool.reserve)
+      throw new Error("Active database connection does not support cancellable transaction acquisition.");
+    const reserved = signal ? await pool.reserve?.({ signal }) : undefined;
+    const connection = reserved ?? pool;
+    try {
+      signal?.throwIfAborted();
+      if (!supportsTransactions(connection))
+        throw new Error("Reserved database connection does not support transactions.");
+      return await connection.begin(async (transaction) => {
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+      });
+    } finally {
+      await reserved?.release();
+    }
   }));
 }
 var transactionFrame, outerFrames;

package/dist/framework/public-api.d.ts

@@ -64,6 +64,7 @@ export { loadSeedersFromDirectory, runSeedersFromDirectory, } from "../core/data
 export type { Seeder, SeederDatabase } from "../core/database/seeders/types.ts";
 export { createSqliteConnection } from "../core/database/sqliteConnection.ts";
 export { defineTable } from "../core/database/table.ts";
+export type { TransactionOptions } from "../core/database/transaction.ts";
 export { hasActiveTransaction, requestTransactionRollback, runInTransaction, } from "../core/database/transaction.ts";
 export type { ModelWhere, ModelWriteValues, QueryJoin, QueryJoinOn, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, } from "../core/database/types.ts";
 export type { WhereNode } from "../core/database/whereBuilder.ts";

package/dist/index.js

@@ -730,18 +730,35 @@ async function runInSavepoint(connection, operation) {
 function supportsTransactions(connection) {
   return typeof connection.begin === "function";
 }
-async function runInTransaction(operation) {
+async function runInTransaction(operation, options = {}) {
+  const signal = options.acquisitionSignal;
+  signal?.throwIfAborted();
+  const admittedOperation = (connection) => {
+    signal?.throwIfAborted();
+    return operation(connection);
+  };
   const pool = resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), operation);
+    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
   }
   return await settleTransaction(() => runWithDeferredModelEvents(async () => {
-    return await pool.begin(async (transaction) => {
-      return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(transaction))))));
-    });
+    if (signal && !pool.reserve)
+      throw new Error("Active database connection does not support cancellable transaction acquisition.");
+    const reserved = signal ? await pool.reserve?.({ signal }) : undefined;
+    const connection = reserved ?? pool;
+    try {
+      signal?.throwIfAborted();
+      if (!supportsTransactions(connection))
+        throw new Error("Reserved database connection does not support transactions.");
+      return await connection.begin(async (transaction) => {
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+      });
+    } finally {
+      await reserved?.release();
+    }
   }));
 }
 var transactionFrame, outerFrames;
@@ -9235,6 +9252,7 @@ function createOutboxMetricsCollector(options = {}) {
         throw new Error("Outbox metrics collection is still settling.");
       const deadline = performance.now() + timeoutMs;
       let expired = false;
+      const acquisition = new AbortController;
       let timer;
       const remaining = () => {
         const value = Math.floor(deadline - performance.now());
@@ -9266,7 +9284,7 @@ function createOutboxMetricsCollector(options = {}) {
           });
           return { sampleLimit, states };
         });
-      });
+      }, { acquisitionSignal: acquisition.signal });
       active = work;
       work.finally(() => {
         if (active === work)
@@ -9278,7 +9296,9 @@ function createOutboxMetricsCollector(options = {}) {
           new Promise((_, reject) => {
             timer = setTimeout(() => {
               expired = true;
-              reject(new Error("Outbox metrics collection timed out."));
+              const error = new Error("Outbox metrics collection timed out.");
+              acquisition.abort(error);
+              reject(error);
             }, timeoutMs);
           })
         ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "2.2.8",
+  "version": "2.2.9",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",