@event-driven-io/dumbo 0.13.0-beta.46 → 0.13.0-beta.47

package/dist/pg.d.cts

@@ -1,5 +1,5 @@
-import { $ as DatabaseTransaction, Ao as JSONSerializationOptions, Mo as JSONSerializer, N as AnyConnection, P as Connection, St as DumboDatabaseDriver, en as DbSQLExecutor, et as DatabaseTransactionOptions, r as postgreSQLMetadata, y as ConnectionPool } from "./index-_dj3upBo.cjs";
-import { S as parseDatabaseName, _ as releaseAdvisoryLock, a as PostgreSQLExpandSQLInProcessor, b as PostgreSQLConnectionString, c as defaultPostgreSqlDatabase, d as tableExists, f as tableExistsSQL, g as advisoryLock, h as acquireAdvisoryLock, i as PostgreSQLArrayProcessor, l as functionExists, m as AdvisoryLock, n as PostgreSQLDriverType, o as PostgreSQLJSON, p as DefaultPostgreSQLMigratorOptions, r as postgreSQLColumnProcessors, s as pgFormatter, t as PostgreSQLDatabaseName, u as functionExistsSQL, v as tryAcquireAdvisoryLock, x as defaultPostgreSQLConnectionString, y as mapPostgresError } from "./index-kYttgYkC.cjs";
+import { $ as DatabaseTransaction, Ct as DumboDatabaseDriver, Fo as JSONSerializationOptions, Lo as JSONSerializer, N as AnyConnection, P as Connection, et as DatabaseTransactionOptions, r as postgreSQLMetadata, tn as DbSQLExecutor, y as ConnectionPool } from "./index-BJ-dm7dG.cjs";
+import { S as parseDatabaseName, _ as releaseAdvisoryLock, a as PostgreSQLExpandSQLInProcessor, b as PostgreSQLConnectionString, c as defaultPostgreSqlDatabase, d as tableExists, f as tableExistsSQL, g as advisoryLock, h as acquireAdvisoryLock, i as PostgreSQLArrayProcessor, l as functionExists, m as AdvisoryLock, n as PostgreSQLDriverType, o as PostgreSQLJSON, p as DefaultPostgreSQLMigratorOptions, r as postgreSQLColumnProcessors, s as pgFormatter, t as PostgreSQLDatabaseName, u as functionExistsSQL, v as tryAcquireAdvisoryLock, x as defaultPostgreSQLConnectionString, y as mapPostgresError } from "./index-BkJ1pipM.cjs";
 import pg from "pg";
 
 //#region src/storage/postgresql/pg/connections/transaction.d.ts

package/dist/pg.d.ts

@@ -1,5 +1,5 @@
-import { $ as DatabaseTransaction, Ao as JSONSerializationOptions, Mo as JSONSerializer, N as AnyConnection, P as Connection, St as DumboDatabaseDriver, en as DbSQLExecutor, et as DatabaseTransactionOptions, r as postgreSQLMetadata, y as ConnectionPool } from "./index-B5krjjrh.js";
-import { S as parseDatabaseName, _ as releaseAdvisoryLock, a as PostgreSQLExpandSQLInProcessor, b as PostgreSQLConnectionString, c as defaultPostgreSqlDatabase, d as tableExists, f as tableExistsSQL, g as advisoryLock, h as acquireAdvisoryLock, i as PostgreSQLArrayProcessor, l as functionExists, m as AdvisoryLock, n as PostgreSQLDriverType, o as PostgreSQLJSON, p as DefaultPostgreSQLMigratorOptions, r as postgreSQLColumnProcessors, s as pgFormatter, t as PostgreSQLDatabaseName, u as functionExistsSQL, v as tryAcquireAdvisoryLock, x as defaultPostgreSQLConnectionString, y as mapPostgresError } from "./index-BaLXbc2l.js";
+import { $ as DatabaseTransaction, Ct as DumboDatabaseDriver, Fo as JSONSerializationOptions, Lo as JSONSerializer, N as AnyConnection, P as Connection, et as DatabaseTransactionOptions, r as postgreSQLMetadata, tn as DbSQLExecutor, y as ConnectionPool } from "./index-4hcCG4SA.js";
+import { S as parseDatabaseName, _ as releaseAdvisoryLock, a as PostgreSQLExpandSQLInProcessor, b as PostgreSQLConnectionString, c as defaultPostgreSqlDatabase, d as tableExists, f as tableExistsSQL, g as advisoryLock, h as acquireAdvisoryLock, i as PostgreSQLArrayProcessor, l as functionExists, m as AdvisoryLock, n as PostgreSQLDriverType, o as PostgreSQLJSON, p as DefaultPostgreSQLMigratorOptions, r as postgreSQLColumnProcessors, s as pgFormatter, t as PostgreSQLDatabaseName, u as functionExistsSQL, v as tryAcquireAdvisoryLock, x as defaultPostgreSQLConnectionString, y as mapPostgresError } from "./index-B7366zWR.js";
 import pg from "pg";
 
 //#region src/storage/postgresql/pg/connections/transaction.d.ts

package/dist/pg.js

@@ -290,6 +290,91 @@ const mapPostgresError = (error) => {
 	});
 };
 
+//#endregion
+//#region src/core/taskProcessing/abort.ts
+const never = { signal: new AbortController().signal };
+const from = (options) => options?.abort ?? never;
+const getSignal = (abort) => "signal" in abort ? abort.signal : abort;
+const reason = (abort) => {
+	const signal = getSignal(abort);
+	return signal.reason instanceof Error ? signal.reason : new DumboError(typeof signal.reason === "string" ? signal.reason : "Operation aborted");
+};
+const scope = (parent, onAbort) => {
+	const controller = new AbortController();
+	return {
+		abort: (reason) => controller.abort(reason),
+		dispose: onAbortSignal(parent, (reason) => {
+			controller.abort(reason);
+			onAbort?.(reason);
+		}),
+		signal: controller.signal
+	};
+};
+const execute = (operation, options) => {
+	const abort = options?.abort;
+	if (!abort) return operation();
+	const signal = abort.signal;
+	if (signal.aborted) return Promise.reject(reason(abort));
+	return new Promise((resolve, reject) => {
+		let finished = false;
+		const rejectOnAbort = () => {
+			if (finished) return;
+			finished = true;
+			reject(reason(abort));
+		};
+		signal.addEventListener("abort", rejectOnAbort, { once: true });
+		let operationPromise;
+		try {
+			operationPromise = operation();
+		} catch (error) {
+			finished = true;
+			signal.removeEventListener("abort", rejectOnAbort);
+			reject(error);
+			return;
+		}
+		operationPromise.then((result) => {
+			if (finished) return;
+			finished = true;
+			signal.removeEventListener("abort", rejectOnAbort);
+			resolve(result);
+		}).catch((error) => {
+			if (finished) return;
+			finished = true;
+			signal.removeEventListener("abort", rejectOnAbort);
+			reject(error);
+		});
+	});
+};
+const throwIfAborted = (options) => {
+	const abort = options?.abort;
+	if (abort?.signal.aborted) throw reason(abort);
+};
+const rejectIfAborted = (options) => {
+	const abort = options?.abort;
+	return abort?.signal.aborted ? Promise.reject(reason(abort)) : void 0;
+};
+const onAbortSignal = (abort, handle) => {
+	if (!abort) return () => {};
+	const signal = abort.signal;
+	if (signal.aborted) {
+		handle(reason(abort));
+		return () => {};
+	}
+	const abortListener = () => handle(reason(abort));
+	signal.addEventListener("abort", abortListener, { once: true });
+	return () => signal.removeEventListener("abort", abortListener);
+};
+const Abort = {
+	execute,
+	from,
+	never,
+	onAbort: onAbortSignal,
+	reason,
+	rejectIfAborted,
+	scope,
+	throwIfAborted
+};
+
 //#endregion
 //#region src/core/execute/execute.ts
 const mapSQLQueryResult = (result, mapping) => {
@@ -314,20 +399,45 @@ var BatchCommandNoChangesError = class BatchCommandNoChangesError extends DumboE
 	}
 };
 const sqlExecutor = (sqlExecutor, options) => ({
-	query: (sql, queryOptions) => executeInNewDbClient((client) => sqlExecutor.query(client, sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInNewDbClient((client) => sqlExecutor.batchQuery(client, sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInNewDbClient((client) => sqlExecutor.command(client, sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInNewDbClient((client) => sqlExecutor.batchCommand(client, sqls, commandOptions), options)
+	query: (sql, queryOptions) => executeInNewDbClient((client) => sqlExecutor.query(client, sql, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	batchQuery: (sqls, queryOptions) => executeInNewDbClient((client) => sqlExecutor.batchQuery(client, sqls, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	command: (sql, commandOptions) => executeInNewDbClient((client) => sqlExecutor.command(client, sql, commandOptions), {
+		...options,
+		...commandOptions
+	}),
+	batchCommand: (sqls, commandOptions) => executeInNewDbClient((client) => sqlExecutor.batchCommand(client, sqls, commandOptions), {
+		...options,
+		...commandOptions
+	})
 });
 const sqlExecutorInNewConnection = (options) => ({
-	query: (sql, queryOptions) => executeInNewConnection((connection) => connection.execute.query(sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInNewConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInNewConnection((connection) => connection.execute.command(sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInNewConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
+	query: (sql, queryOptions) => executeInNewConnection((connection) => connection.execute.query(sql, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	batchQuery: (sqls, queryOptions) => executeInNewConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	command: (sql, commandOptions) => executeInNewConnection((connection) => connection.execute.command(sql, commandOptions), {
+		...options,
+		...commandOptions
+	}),
+	batchCommand: (sqls, commandOptions) => executeInNewConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), {
+		...options,
+		...commandOptions
+	})
 });
 const executeInNewDbClient = async (handle, options) => {
+	Abort.throwIfAborted(options);
 	const { connect, close } = options;
-	const client = await connect();
+	const client = await connect({ abort: Abort.from(options) });
 	try {
 		return await handle(client);
 	} catch (error) {
@@ -336,7 +446,8 @@ const executeInNewDbClient = async (handle, options) => {
 	}
 };
 const executeInNewConnection = async (handle, options) => {
-	const connection = await options.connection();
+	Abort.throwIfAborted(options);
+	const connection = await options.connection({ abort: Abort.from(options) });
 	try {
 		return await handle(connection);
 	} finally {
@@ -409,10 +520,10 @@ const toTransactionResult = (transactionResult) => transactionResult !== void 0
 	success: true,
 	result: transactionResult
 };
-const executeInTransaction = async (transaction, handle) => {
+const executeInTransaction = async (transaction, handle, context = { abort: Abort.never }) => {
 	await transaction.begin();
 	try {
-		const { success, result } = toTransactionResult(await handle(transaction));
+		const { success, result } = toTransactionResult(await handle(transaction, context));
 		if (success) await transaction.commit();
 		else await transaction.rollback();
 		return result;
@@ -421,18 +532,32 @@ const executeInTransaction = async (transaction, handle) => {
 		throw e;
 	}
 };
+const executeInNestedTransaction = async (transaction, handle, options, context) => {
+	Abort.throwIfAborted(options);
+	if (!(options?.allowNestedTransactions ?? transaction._transactionOptions.allowNestedTransactions ?? false)) throw new InvalidOperationError("Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.");
+	return executeInTransaction(transaction, handle, context);
+};
 const transactionFactoryWithDbClient = (connect, initTransaction) => {
 	let currentTransaction = void 0;
-	const getOrInitCurrentTransaction = (options) => currentTransaction ?? (currentTransaction = initTransaction(connect(), {
-		close: () => {
-			currentTransaction = void 0;
-			return Promise.resolve();
-		},
-		...options ?? {}
-	}));
+	const getOrInitCurrentTransaction = (options) => {
+		Abort.throwIfAborted(options);
+		if (currentTransaction) return currentTransaction;
+		currentTransaction = initTransaction(connect({ abort: Abort.from(options) }), {
+			close: () => {
+				currentTransaction = void 0;
+				return Promise.resolve();
+			},
+			...options ?? {}
+		});
+		return currentTransaction;
+	};
 	return {
 		transaction: getOrInitCurrentTransaction,
-		withTransaction: (handle, options) => executeInTransaction(getOrInitCurrentTransaction(options), handle)
+		withTransaction: (handle, options) => {
+			const abortRejection = Abort.rejectIfAborted(options);
+			if (abortRejection) return abortRejection;
+			return executeInTransaction(getOrInitCurrentTransaction(options), handle, { abort: Abort.from(options) });
+		}
 	};
 };
 const wrapInConnectionClosure = async (connection, handle) => {
@@ -444,7 +569,8 @@ const wrapInConnectionClosure = async (connection, handle) => {
 };
 const transactionFactoryWithNewConnection = (connect) => ({
 	transaction: (options) => {
-		const connection = connect();
+		Abort.throwIfAborted(options);
+		const connection = connect({ abort: Abort.from(options) });
 		const transaction = connection.transaction(options);
 		return {
 			...transaction,
@@ -453,7 +579,9 @@ const transactionFactoryWithNewConnection = (connect) => ({
 		};
 	},
 	withTransaction: (handle, options) => {
-		const connection = connect();
+		const abortRejection = Abort.rejectIfAborted(options);
+		if (abortRejection) return abortRejection;
+		const connection = connect({ abort: Abort.from(options) });
 		const withTx = connection.withTransaction;
 		return wrapInConnectionClosure(connection, () => withTx(handle, options));
 	}
@@ -465,9 +593,10 @@ const createConnection = (options) => {
 	const { driverType, connect, close, initTransaction, executor, serializer } = options;
 	let client = null;
 	let connectPromise = null;
-	const getClient = async () => {
+	const getClient = async (context) => {
+		Abort.throwIfAborted(context);
 		if (client) return client;
-		if (!connectPromise) connectPromise = connect().then((c) => {
+		if (!connectPromise) connectPromise = connect(context ?? { abort: Abort.never }).then((c) => {
 			client = c;
 			return c;
 		});
@@ -493,7 +622,10 @@ const createAmbientConnectionPool = (options) => {
 		getConnection: () => connection,
 		execute: connection.execute,
 		transaction: (options) => connection.transaction(options),
-		withConnection: (handle, _options) => handle(connection),
+		withConnection: (handle, options) => {
+			Abort.throwIfAborted(options);
+			return handle(connection, { abort: Abort.from(options) });
+		},
 		withTransaction: (handle, options) => {
 			const withTx = connection.withTransaction;
 			return withTx(handle, options);
@@ -502,11 +634,17 @@ const createAmbientConnectionPool = (options) => {
 };
 const createConnectionPool = (pool) => {
 	const { driverType, getConnection } = pool;
-	const connection = "connection" in pool ? pool.connection : () => Promise.resolve(getConnection());
+	const connection = "connection" in pool ? pool.connection : (options) => {
+		Abort.throwIfAborted(options);
+		return Promise.resolve(getConnection({ abort: Abort.from(options) }));
+	};
 	return {
 		driverType,
 		connection,
-		withConnection: "withConnection" in pool ? pool.withConnection : (handle, _options) => executeInNewConnection(handle, { connection }),
+		withConnection: "withConnection" in pool ? pool.withConnection : (handle, options) => executeInNewConnection((connection) => handle(connection, { abort: Abort.from(options) }), {
+			connection,
+			...options
+		}),
 		close: "close" in pool ? pool.close : () => Promise.resolve(),
 		execute: "execute" in pool ? pool.execute : sqlExecutorInNewConnection({
 			driverType,
@@ -2150,18 +2288,20 @@ const pgTransaction = (connection, serializer) => (getClient, options) => {
 		allowNestedTransactions,
 		useSavepoints: options?.useSavepoints ?? false
 	});
-	return {
+	const transaction = {
 		connection: connection(),
 		driverType: PgDriverType,
 		begin: tx.begin,
 		commit: tx.commit,
 		rollback: tx.rollback,
 		execute: sqlExecutor(pgSQLExecutor({ serializer }), { connect: () => getClient }),
+		withTransaction: (handle, options) => executeInNestedTransaction(transaction, handle, options),
 		_transactionOptions: {
 			...options ?? {},
 			allowNestedTransactions
 		}
 	};
+	return transaction;
 };
 
 //#endregion