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

package/dist/pg.d.cts

@@ -949,9 +949,12 @@ interface WithConnectionFactory<ConnectionType extends AnyConnection = AnyConnec
 }
 //#endregion
 //#region src/core/connections/pool.d.ts
+type PoolCloseOptions = {
+  force?: boolean;
+};
 interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection> extends WithSQLExecutor, WithConnectionFactory<ConnectionType>, WithDatabaseTransactionFactory<ConnectionType> {
   driverType: ConnectionType['driverType'];
-  close: () => Promise<void>;
+  close: (options?: PoolCloseOptions) => Promise<void>;
 }
 //#endregion
 //#region src/core/index.d.ts
@@ -1045,6 +1048,7 @@ type PgTransaction = DatabaseTransaction<PgConnection, PgTransactionOptions>;
 type PgIsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SERIALIZABLE';
 type PgTransactionOptions = DatabaseTransactionOptions & {
   isolationLevel?: PgIsolationLevel;
+  useSavepoints?: boolean;
 };
 declare const pgTransaction: <ConnectionType extends AnyConnection = AnyConnection>(connection: () => ConnectionType, serializer: JSONSerializer) => <DbClient extends PgPoolOrClient = PgPoolOrClient>(getClient: Promise<DbClient>, options?: {
   close: (client: DbClient, error?: unknown) => Promise<void>;
@@ -1072,9 +1076,11 @@ type PgClientOptions = {
 };
 type PgClientConnectionOptions = PgClientOptions & {
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions;
 };
 type PgPoolClientConnectionOptions = PgPoolClientOptions & {
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions;
 };
 declare const pgClientConnection: (options: PgClientConnectionOptions) => PgClientConnection;
 declare const pgPoolClientConnection: (options: PgPoolClientConnectionOptions) => PgPoolClientConnection;
@@ -1100,10 +1106,12 @@ declare const pgNativePool: (options: {
   connectionString: string;
   database?: string | undefined;
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions | undefined;
 }) => PgNativePool;
 declare const pgAmbientNativePool: (options: {
   pool: pg.Pool;
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions | undefined;
 }) => PgNativePool;
 declare const pgAmbientConnectionPool: (options: {
   connection: PgPoolClientConnection | PgClientConnection;
@@ -1112,10 +1120,12 @@ declare const pgClientPool: (options: {
   connectionString: string;
   database?: string | undefined;
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions | undefined;
 }) => PgAmbientClientPool;
 declare const pgAmbientClientPool: (options: {
   client: pg.Client;
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions | undefined;
 }) => PgAmbientClientPool;
 type PgPoolPooledOptions = {
   connectionString: string;
@@ -1153,9 +1163,15 @@ type PgPoolNotPooledOptions = {
   connection: PgPoolClientConnection | PgClientConnection;
   pooled?: false;
 };
-type PgPoolOptions = (PgPoolPooledOptions | PgPoolNotPooledOptions) & JSONSerializationOptions;
-declare function pgPool(options: PgPoolPooledOptions): PgNativePool;
-declare function pgPool(options: PgPoolNotPooledOptions): PgAmbientClientPool;
+type PgPoolOptions = (PgPoolPooledOptions | PgPoolNotPooledOptions) & JSONSerializationOptions & {
+  transactionOptions?: PgTransactionOptions;
+};
+declare function pgPool(options: PgPoolPooledOptions & {
+  transactionOptions?: PgTransactionOptions;
+}): PgNativePool;
+declare function pgPool(options: PgPoolNotPooledOptions & {
+  transactionOptions?: PgTransactionOptions;
+}): PgAmbientClientPool;
 declare const getPgPool: (connectionStringOrOptions: string | pg.PoolConfig) => pg.Pool;
 declare const endPgPool: ({
   connectionString,

package/dist/pg.d.ts

@@ -949,9 +949,12 @@ interface WithConnectionFactory<ConnectionType extends AnyConnection = AnyConnec
 }
 //#endregion
 //#region src/core/connections/pool.d.ts
+type PoolCloseOptions = {
+  force?: boolean;
+};
 interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection> extends WithSQLExecutor, WithConnectionFactory<ConnectionType>, WithDatabaseTransactionFactory<ConnectionType> {
   driverType: ConnectionType['driverType'];
-  close: () => Promise<void>;
+  close: (options?: PoolCloseOptions) => Promise<void>;
 }
 //#endregion
 //#region src/core/index.d.ts
@@ -1045,6 +1048,7 @@ type PgTransaction = DatabaseTransaction<PgConnection, PgTransactionOptions>;
 type PgIsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SERIALIZABLE';
 type PgTransactionOptions = DatabaseTransactionOptions & {
   isolationLevel?: PgIsolationLevel;
+  useSavepoints?: boolean;
 };
 declare const pgTransaction: <ConnectionType extends AnyConnection = AnyConnection>(connection: () => ConnectionType, serializer: JSONSerializer) => <DbClient extends PgPoolOrClient = PgPoolOrClient>(getClient: Promise<DbClient>, options?: {
   close: (client: DbClient, error?: unknown) => Promise<void>;
@@ -1072,9 +1076,11 @@ type PgClientOptions = {
 };
 type PgClientConnectionOptions = PgClientOptions & {
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions;
 };
 type PgPoolClientConnectionOptions = PgPoolClientOptions & {
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions;
 };
 declare const pgClientConnection: (options: PgClientConnectionOptions) => PgClientConnection;
 declare const pgPoolClientConnection: (options: PgPoolClientConnectionOptions) => PgPoolClientConnection;
@@ -1100,10 +1106,12 @@ declare const pgNativePool: (options: {
   connectionString: string;
   database?: string | undefined;
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions | undefined;
 }) => PgNativePool;
 declare const pgAmbientNativePool: (options: {
   pool: pg.Pool;
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions | undefined;
 }) => PgNativePool;
 declare const pgAmbientConnectionPool: (options: {
   connection: PgPoolClientConnection | PgClientConnection;
@@ -1112,10 +1120,12 @@ declare const pgClientPool: (options: {
   connectionString: string;
   database?: string | undefined;
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions | undefined;
 }) => PgAmbientClientPool;
 declare const pgAmbientClientPool: (options: {
   client: pg.Client;
   serializer: JSONSerializer;
+  transactionOptions?: PgTransactionOptions | undefined;
 }) => PgAmbientClientPool;
 type PgPoolPooledOptions = {
   connectionString: string;
@@ -1153,9 +1163,15 @@ type PgPoolNotPooledOptions = {
   connection: PgPoolClientConnection | PgClientConnection;
   pooled?: false;
 };
-type PgPoolOptions = (PgPoolPooledOptions | PgPoolNotPooledOptions) & JSONSerializationOptions;
-declare function pgPool(options: PgPoolPooledOptions): PgNativePool;
-declare function pgPool(options: PgPoolNotPooledOptions): PgAmbientClientPool;
+type PgPoolOptions = (PgPoolPooledOptions | PgPoolNotPooledOptions) & JSONSerializationOptions & {
+  transactionOptions?: PgTransactionOptions;
+};
+declare function pgPool(options: PgPoolPooledOptions & {
+  transactionOptions?: PgTransactionOptions;
+}): PgNativePool;
+declare function pgPool(options: PgPoolNotPooledOptions & {
+  transactionOptions?: PgTransactionOptions;
+}): PgAmbientClientPool;
 declare const getPgPool: (connectionStringOrOptions: string | pg.PoolConfig) => pg.Pool;
 declare const endPgPool: ({
   connectionString,

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();