@event-driven-io/dumbo 0.13.0-beta.43 → 0.13.0-beta.44

package/dist/index.cjs

@@ -323,6 +323,65 @@ const executeInAmbientConnection = async (handle, options) => {
 
 //#endregion
 //#region src/core/connections/transaction.ts
+const transactionNestingCounter = () => {
+	let transactionLevel = 0;
+	return {
+		reset: () => {
+			transactionLevel = 0;
+		},
+		increment: () => {
+			transactionLevel++;
+		},
+		decrement: () => {
+			transactionLevel--;
+			if (transactionLevel < 0) throw new Error("Transaction level is out of bounds");
+		},
+		get level() {
+			return transactionLevel;
+		}
+	};
+};
+const databaseTransaction = (backend, options) => {
+	const allowNestedTransactions = options?.allowNestedTransactions ?? false;
+	const useSavepoints = options?.useSavepoints ?? false;
+	const counter = transactionNestingCounter();
+	let hasBegun = false;
+	return {
+		begin: async () => {
+			if (!allowNestedTransactions && hasBegun) throw new InvalidOperationError("Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.");
+			if (allowNestedTransactions) {
+				if (counter.level >= 1) {
+					counter.increment();
+					if (useSavepoints && backend.savepoint) await backend.savepoint(counter.level);
+					return;
+				}
+				counter.increment();
+			}
+			hasBegun = true;
+			await backend.begin();
+		},
+		commit: async () => {
+			if (allowNestedTransactions && counter.level > 1) {
+				if (useSavepoints && backend.releaseSavepoint) await backend.releaseSavepoint(counter.level);
+				counter.decrement();
+				return;
+			}
+			if (allowNestedTransactions) counter.reset();
+			hasBegun = false;
+			await backend.commit();
+		},
+		rollback: async (error) => {
+			if (allowNestedTransactions && counter.level > 1) {
+				if (useSavepoints && backend.rollbackToSavepoint) await backend.rollbackToSavepoint(counter.level);
+				counter.decrement();
+				return;
+			}
+			if (allowNestedTransactions) counter.reset();
+			hasBegun = false;
+			await backend.rollback(error);
+		}
+	};
+};
 const toTransactionResult = (transactionResult) => transactionResult !== void 0 && transactionResult !== null && typeof transactionResult === "object" && "success" in transactionResult ? transactionResult : {
 	success: true,
 	result: transactionResult
@@ -729,33 +788,80 @@ const createAmbientConnectionPool = (options) => {
 const createSingletonConnectionPool = (options) => {
 	const { driverType, getConnection } = options;
 	let connectionPromise = null;
+	let closed = false;
+	const activeOperations = /* @__PURE__ */ new Set();
+	const closedError = () => /* @__PURE__ */ new Error("Singleton connection pool has been closed");
+	const run = async (operation) => {
+		if (closed) throw closedError();
+		const activeOperation = operation();
+		activeOperations.add(activeOperation);
+		try {
+			return await activeOperation;
+		} finally {
+			activeOperations.delete(activeOperation);
+		}
+	};
 	const getExistingOrNewConnection = () => {
 		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
 		return connectionPromise;
 	};
+	const innerTransactionFactory = transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection);
 	return {
 		driverType,
-		connection: () => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve())),
-		execute: sqlExecutorInAmbientConnection({
-			driverType,
-			connection: getExistingOrNewConnection
-		}),
-		withConnection: (handle, _options) => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection }),
-		...transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection),
-		close: async () => {
+		connection: () => run(() => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve()))),
+		execute: (() => {
+			const ambientExecutor = sqlExecutorInAmbientConnection({
+				driverType,
+				connection: getExistingOrNewConnection
+			});
+			return {
+				query: (sql, opts) => run(() => ambientExecutor.query(sql, opts)),
+				batchQuery: (sqls, opts) => run(() => ambientExecutor.batchQuery(sqls, opts)),
+				command: (sql, opts) => run(() => ambientExecutor.command(sql, opts)),
+				batchCommand: (sqls, opts) => run(() => ambientExecutor.batchCommand(sqls, opts))
+			};
+		})(),
+		withConnection: (handle, _options) => run(() => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection })),
+		transaction: (transactionOptions) => {
+			if (closed) throw closedError();
+			return innerTransactionFactory.transaction(transactionOptions);
+		},
+		withTransaction: (handle, transactionOptions) => run(() => innerTransactionFactory.withTransaction(handle, transactionOptions)),
+		close: async (closeOptions) => {
+			if (closed) return;
+			closed = true;
+			if (!closeOptions?.force) await Promise.allSettled([...activeOperations]);
 			if (!connectionPromise) return;
-			await (await connectionPromise).close();
+			const connection = await connectionPromise;
+			connectionPromise = null;
+			await connection.close();
 		}
 	};
 };
 const createBoundedConnectionPool = (options) => {
 	const { driverType, maxConnections } = options;
-	const guardMaxConnections = guardBoundedAccess(options.getConnection, {
+	const allConnections = /* @__PURE__ */ new Set();
+	const getTrackedConnection = async () => {
+		const connection = await options.getConnection();
+		allConnections.add(connection);
+		return connection;
+	};
+	const guardMaxConnections = guardBoundedAccess(getTrackedConnection, {
 		maxResources: maxConnections,
 		reuseResources: true
 	});
 	let closed = false;
+	const closedError = () => /* @__PURE__ */ new Error("Bounded connection pool has been closed");
+	const ensureOpen = () => {
+		if (closed) throw closedError();
+	};
+	const closeAllConnections = async () => {
+		const connections = [...allConnections];
+		allConnections.clear();
+		await Promise.all(connections.map((conn) => conn.close()));
+	};
 	const executeWithPooling = async (operation) => {
+		ensureOpen();
 		const conn = await guardMaxConnections.acquire();
 		try {
 			return await operation(conn);
@@ -766,6 +872,7 @@ const createBoundedConnectionPool = (options) => {
 	return {
 		driverType,
 		connection: async () => {
+			ensureOpen();
 			const conn = await guardMaxConnections.acquire();
 			return wrapPooledConnection(conn, () => Promise.resolve(guardMaxConnections.release(conn)));
 		},
@@ -776,11 +883,20 @@ const createBoundedConnectionPool = (options) => {
 			batchCommand: (sqls, opts) => executeWithPooling((c) => c.execute.batchCommand(sqls, opts))
 		},
 		withConnection: executeWithPooling,
-		...transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release),
-		close: async () => {
+		transaction: (transactionOptions) => {
+			ensureOpen();
+			return transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release).transaction(transactionOptions);
+		},
+		withTransaction: (handle, transactionOptions) => executeWithPooling((conn) => {
+			const withTx = conn.withTransaction;
+			return withTx(handle, transactionOptions);
+		}),
+		close: async (closeOptions) => {
 			if (closed) return;
 			closed = true;
+			if (!closeOptions?.force) await guardMaxConnections.waitForIdle();
 			await guardMaxConnections.stop({ force: true });
+			await closeAllConnections();
 		}
 	};
 };
@@ -2509,6 +2625,7 @@ exports.createSingletonConnectionPool = createSingletonConnectionPool;
 exports.createTransientConnection = createTransientConnection;
 exports.databaseSchemaComponent = databaseSchemaComponent;
 exports.databaseSchemaSchemaComponent = databaseSchemaSchemaComponent;
+exports.databaseTransaction = databaseTransaction;
 exports.defaultDatabaseLockOptions = defaultDatabaseLockOptions;
 exports.defaultProcessorsRegistry = defaultProcessorsRegistry;
 exports.describeSQL = describeSQL;
@@ -2574,4 +2691,5 @@ exports.transactionFactoryWithAmbientConnection = transactionFactoryWithAmbientC
 exports.transactionFactoryWithAsyncAmbientConnection = transactionFactoryWithAsyncAmbientConnection;
 exports.transactionFactoryWithDbClient = transactionFactoryWithDbClient;
 exports.transactionFactoryWithNewConnection = transactionFactoryWithNewConnection;
+exports.transactionNestingCounter = transactionNestingCounter;
 //# sourceMappingURL=index.cjs.map