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

package/dist/cloudflare.cjs

@@ -269,6 +269,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
@@ -459,22 +518,53 @@ 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();
 		}
 	};
 };
@@ -1827,54 +1917,46 @@ const sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
 //#endregion
 //#region src/storage/sqlite/core/transactions/index.ts
 const sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer, defaultTransactionMode) => (getClient, options) => {
-	const transactionCounter = transactionNestingCounter();
 	allowNestedTransactions = options?.allowNestedTransactions ?? allowNestedTransactions;
-	let hasBegun = false;
-	return {
-		connection: connection(),
-		driverType,
-		begin: async function() {
+	const useSavepoints = options?.useSavepoints ?? false;
+	const tx = databaseTransaction({
+		begin: async () => {
 			const client = await getClient;
-			if (allowNestedTransactions) {
-				if (transactionCounter.level >= 1) {
-					transactionCounter.increment();
-					if (options?.useSavepoints) await client.command(SQL`SAVEPOINT transaction${SQL.plain(transactionCounter.level.toString())}`);
-					return;
-				}
-				transactionCounter.increment();
-			} else if (hasBegun) throw new InvalidOperationError("Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.");
-			hasBegun = true;
 			const mode = options?.mode ?? defaultTransactionMode ?? "IMMEDIATE";
 			await client.command(SQL`BEGIN ${SQL.plain(mode)} TRANSACTION`);
 		},
-		commit: async function() {
+		commit: async () => {
 			const client = await getClient;
-			if (allowNestedTransactions && transactionCounter.level > 1) {
-				if (options?.useSavepoints) await client.command(SQL`RELEASE transaction${SQL.plain(transactionCounter.level.toString())}`);
-				transactionCounter.decrement();
-				return;
-			}
 			try {
-				if (allowNestedTransactions) transactionCounter.reset();
-				hasBegun = false;
 				await client.command(SQL`COMMIT`);
 			} finally {
-				if (options?.close) await options?.close(client);
+				if (options?.close) await options.close(client);
 			}
 		},
-		rollback: async function(error) {
+		rollback: async (error) => {
 			const client = await getClient;
-			if (allowNestedTransactions && transactionCounter.level > 1) {
-				transactionCounter.decrement();
-				return;
-			}
 			try {
-				hasBegun = false;
 				await client.command(SQL`ROLLBACK`);
 			} finally {
-				if (options?.close) await options?.close(client, error);
+				if (options?.close) await options.close(client, error);
 			}
 		},
+		savepoint: async (level) => {
+			await (await getClient).command(SQL`SAVEPOINT transaction${SQL.plain(level.toString())}`);
+		},
+		releaseSavepoint: async (level) => {
+			await (await getClient).command(SQL`RELEASE transaction${SQL.plain(level.toString())}`);
+		}
+	}, {
+		allowNestedTransactions,
+		useSavepoints
+	});
+	return {
+		connection: connection(),
+		driverType,
+		begin: tx.begin,
+		commit: tx.commit,
+		rollback: tx.rollback,
 		execute: sqlExecutor(sqliteSQLExecutor(driverType, serializer), { connect: () => getClient }),
 		_transactionOptions: {
 			...options,
@@ -1920,24 +2002,6 @@ const isSQLiteError = (error) => {
 	if (error instanceof Error && "code" in error) return true;
 	return false;
 };
-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 sqliteAmbientClientConnection = (options) => {
 	const { client, driverType, initTransaction, allowNestedTransactions, defaultTransactionMode, serializer, errorMapper } = options;
 	return createAmbientConnection({
@@ -2500,6 +2564,5 @@ exports.sqliteSingletonConnectionPool = sqliteSingletonConnectionPool;
 exports.sqliteTransaction = sqliteTransaction;
 exports.tableExists = tableExists;
 exports.toSqlitePoolOptions = toSqlitePoolOptions;
-exports.transactionNestingCounter = transactionNestingCounter;
 exports.useD1DumboDriver = useD1DumboDriver;
 //# sourceMappingURL=cloudflare.cjs.map