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

package/dist/pg.js

@@ -346,6 +346,65 @@ const executeInNewConnection = 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
@@ -2052,57 +2111,92 @@ async function batchCommand(client, sqls, serializer, options) {
 
 //#endregion
 //#region src/storage/postgresql/pg/connections/transaction.ts
-const pgTransaction = (connection, serializer) => (getClient, options) => ({
-	connection: connection(),
-	driverType: PgDriverType,
-	begin: async () => {
-		const client = await getClient;
-		const parts = ["BEGIN"];
-		if (options?.isolationLevel) parts.push(`ISOLATION LEVEL ${options.isolationLevel}`);
-		if (options?.readonly) parts.push("READ ONLY");
-		await client.query(parts.join(" "));
-	},
-	commit: async () => {
-		const client = await getClient;
-		try {
-			await client.query("COMMIT");
-		} finally {
-			if (options?.close) await options?.close(client);
+const pgTransaction = (connection, serializer) => (getClient, options) => {
+	const allowNestedTransactions = options?.allowNestedTransactions ?? false;
+	const tx = databaseTransaction({
+		begin: async () => {
+			const client = await getClient;
+			const parts = ["BEGIN"];
+			if (options?.isolationLevel) parts.push(`ISOLATION LEVEL ${options.isolationLevel}`);
+			if (options?.readonly) parts.push("READ ONLY");
+			await client.query(parts.join(" "));
+		},
+		commit: async () => {
+			const client = await getClient;
+			try {
+				await client.query("COMMIT");
+			} finally {
+				if (options?.close) await options.close(client);
+			}
+		},
+		rollback: async (error) => {
+			const client = await getClient;
+			try {
+				await client.query("ROLLBACK");
+			} finally {
+				if (options?.close) await options.close(client, error);
+			}
+		},
+		savepoint: async (level) => {
+			await (await getClient).query(`SAVEPOINT pg_savepoint_${level}`);
+		},
+		releaseSavepoint: async (level) => {
+			await (await getClient).query(`RELEASE SAVEPOINT pg_savepoint_${level}`);
+		},
+		rollbackToSavepoint: async (level) => {
+			await (await getClient).query(`ROLLBACK TO SAVEPOINT pg_savepoint_${level}`);
 		}
-	},
-	rollback: async (error) => {
-		const client = await getClient;
-		try {
-			await client.query("ROLLBACK");
-		} finally {
-			if (options?.close) await options?.close(client, error);
+	}, {
+		allowNestedTransactions,
+		useSavepoints: options?.useSavepoints ?? false
+	});
+	return {
+		connection: connection(),
+		driverType: PgDriverType,
+		begin: tx.begin,
+		commit: tx.commit,
+		rollback: tx.rollback,
+		execute: sqlExecutor(pgSQLExecutor({ serializer }), { connect: () => getClient }),
+		_transactionOptions: {
+			...options ?? {},
+			allowNestedTransactions
 		}
-	},
-	execute: sqlExecutor(pgSQLExecutor({ serializer }), { connect: () => getClient }),
-	_transactionOptions: options ?? {}
-});
+	};
+};
 
 //#endregion
 //#region src/storage/postgresql/pg/connections/connection.ts
 const PgDriverType = "PostgreSQL:pg";
 const pgClientConnection = (options) => {
-	const { connect, close } = options;
+	const { connect, close, transactionOptions } = options;
 	return createConnection({
 		driverType: PgDriverType,
 		connect,
 		close,
-		initTransaction: (connection) => pgTransaction(connection, options.serializer),
+		initTransaction: (connection) => {
+			const txFactory = pgTransaction(connection, options.serializer);
+			return (client, perCallOptions) => txFactory(client, {
+				...transactionOptions ?? {},
+				...perCallOptions ?? {}
+			});
+		},
 		executor: pgSQLExecutor,
 		serializer: options.serializer
 	});
 };
 const pgPoolClientConnection = (options) => {
-	const { connect, close } = options;
+	const { connect, close, transactionOptions } = options;
 	return createConnection({
 		driverType: PgDriverType,
 		connect,
 		close,
-		initTransaction: (connection) => pgTransaction(connection, options.serializer),
+		initTransaction: (connection) => {
+			const txFactory = pgTransaction(connection, options.serializer);
+			return (client, perCallOptions) => txFactory(client, {
+				...transactionOptions ?? {},
+				...perCallOptions ?? {}
+			});
+		},
 		executor: pgSQLExecutor,
 		serializer: options.serializer
 	});
@@ -2141,7 +2235,7 @@ const setPgTypeParser = (client, options) => {
 //#endregion
 //#region src/storage/postgresql/pg/connections/pool.ts
 const pgNativePool = (options) => {
-	const { connectionString, database } = options;
+	const { connectionString, database, transactionOptions } = options;
 	const pool = getPgPool({
 		connectionString,
 		database
@@ -2157,7 +2251,8 @@ const pgNativePool = (options) => {
 			return client;
 		},
 		close: (client) => Promise.resolve(client.release()),
-		serializer: options.serializer
+		serializer: options.serializer,
+		...transactionOptions ? { transactionOptions } : {}
 	});
 	const open = () => Promise.resolve(getConnection());
 	const close = () => endPgPool({
@@ -2172,14 +2267,15 @@ const pgNativePool = (options) => {
 	});
 };
 const pgAmbientNativePool = (options) => {
-	const { pool } = options;
+	const { pool, transactionOptions } = options;
 	return createConnectionPool({
 		driverType: PgDriverType,
 		getConnection: () => pgConnection({
 			type: "PoolClient",
 			connect: () => pool.connect(),
 			close: (client) => Promise.resolve(client.release()),
-			serializer: options.serializer
+			serializer: options.serializer,
+			...transactionOptions ? { transactionOptions } : {}
 		})
 	});
 };
@@ -2191,7 +2287,7 @@ const pgAmbientConnectionPool = (options) => {
 	});
 };
 const pgClientPool = (options) => {
-	const { connectionString, database } = options;
+	const { connectionString, database, transactionOptions } = options;
 	return createConnectionPool({
 		driverType: PgDriverType,
 		getConnection: () => {
@@ -2211,20 +2307,22 @@ const pgClientPool = (options) => {
 				type: "Client",
 				connect,
 				close: (client) => client.end(),
-				serializer: options.serializer
+				serializer: options.serializer,
+				...transactionOptions ? { transactionOptions } : {}
 			});
 		}
 	});
 };
 const pgAmbientClientPool = (options) => {
-	const { client } = options;
+	const { client, transactionOptions } = options;
 	const getConnection = () => {
 		const connect = () => Promise.resolve(client);
 		return pgConnection({
 			type: "Client",
 			connect,
 			close: () => Promise.resolve(),
-			serializer: options.serializer
+			serializer: options.serializer,
+			...transactionOptions ? { transactionOptions } : {}
 		});
 	};
 	const open = () => Promise.resolve(getConnection());
@@ -2237,26 +2335,31 @@ const pgAmbientClientPool = (options) => {
 	});
 };
 function pgPool(options) {
-	const { connectionString, database } = options;
+	const { connectionString, database, transactionOptions } = options;
 	const serializer = options.serialization?.serializer ?? JSONSerializer;
+	const txOpts = transactionOptions ? { transactionOptions } : {};
 	if ("client" in options && options.client) return pgAmbientClientPool({
 		client: options.client,
-		serializer
+		serializer,
+		...txOpts
 	});
 	if ("connection" in options && options.connection) return pgAmbientConnectionPool({ connection: options.connection });
 	if ("pooled" in options && options.pooled === false) return pgClientPool({
 		connectionString,
 		database,
-		serializer
+		serializer,
+		...txOpts
 	});
 	if ("pool" in options && options.pool) return pgAmbientNativePool({
 		pool: options.pool,
-		serializer
+		serializer,
+		...txOpts
 	});
 	return pgNativePool({
 		connectionString,
 		database,
-		serializer
+		serializer,
+		...txOpts
 	});
 }
 const pools = /* @__PURE__ */ new Map();