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

package/dist/index.js

@@ -212,6 +212,364 @@ var InvalidOperationError = class InvalidOperationError extends DumboError {
 	}
 };
 
+//#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/taskProcessing/taskProcessor.ts
+var TaskProcessor = class {
+	queue = [];
+	isProcessing = false;
+	activeTasks = 0;
+	activeGroups = /* @__PURE__ */ new Set();
+	options;
+	stopped = false;
+	idleWaiters = [];
+	activeTaskAbortCallbacks = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+	}
+	enqueue(task, options) {
+		if (options?.abort?.signal.aborted) return Promise.reject(Abort.reason(options.abort.signal));
+		if (this.stopped) return Promise.reject(new DumboError("TaskProcessor has been stopped"));
+		if (this.queue.length >= this.options.maxQueueSize) return Promise.reject(new TransientDatabaseError("Too many pending connections. Please try again later."));
+		return this.schedule(task, options);
+	}
+	waitForEndOfProcessing() {
+		if (this.activeTasks === 0 && this.queue.length === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.idleWaiters.push(resolve);
+		});
+	}
+	async stop(options) {
+		if (this.stopped) return;
+		this.stopped = true;
+		const stoppedError = new DumboError("TaskProcessor has been stopped");
+		for (const item of this.queue.splice(0)) {
+			item.abort(stoppedError);
+			item.reject(stoppedError);
+		}
+		this.activeGroups.clear();
+		if (options?.force) for (const abort of this.activeTaskAbortCallbacks) abort(stoppedError);
+		if (options?.force) return;
+		if (options?.closeDeadline === void 0) {
+			await this.waitForEndOfProcessing();
+			return;
+		}
+		if (!await waitForProcessingOrDeadline(this.waitForEndOfProcessing(), options.closeDeadline)) for (const abort of this.activeTaskAbortCallbacks) abort(stoppedError);
+	}
+	schedule(task, options) {
+		return new Promise((resolve, reject) => {
+			let didQueueTimeout = false;
+			let didAbortBeforeStart = false;
+			let didStart = false;
+			let queueWaitTimer = noopQueueWaitTimer;
+			const abortScope = Abort.scope(options?.abort, (reason) => {
+				queueWaitTimer.cancel();
+				didAbortBeforeStart = !didStart;
+				reject(reason);
+			});
+			queueWaitTimer = createQueueWaitTimer(this.options.maxTaskIdleTime, (reason) => {
+				didQueueTimeout = true;
+				abortScope.abort(reason);
+				abortScope.dispose();
+				reject(reason);
+			});
+			const taskWithContext = () => {
+				return new Promise((resolveTask) => {
+					if (didQueueTimeout || didAbortBeforeStart) {
+						resolveTask();
+						return;
+					}
+					let taskPromise;
+					try {
+						taskPromise = task({
+							ack: resolveTask,
+							abort: abortScope
+						});
+					} catch (err) {
+						abortScope.dispose();
+						resolveTask();
+						reject(err);
+						return;
+					}
+					taskPromise.then((result) => {
+						abortScope.dispose();
+						resolve(result);
+					}).catch((err) => {
+						abortScope.dispose();
+						resolveTask();
+						reject(err);
+					});
+				});
+			};
+			this.queue.push({
+				task: taskWithContext,
+				options,
+				reject: (reason) => {
+					queueWaitTimer.cancel();
+					abortScope.dispose();
+					reject(reason);
+				},
+				markStarted: () => {
+					didStart = true;
+					queueWaitTimer.cancel();
+				},
+				abort: (reason) => {
+					abortScope.dispose();
+					abortScope.abort(reason);
+				}
+			});
+			if (!this.isProcessing) this.ensureProcessing();
+		});
+	}
+	ensureProcessing() {
+		if (this.isProcessing) return;
+		this.isProcessing = true;
+		this.processQueue();
+	}
+	processQueue() {
+		try {
+			while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
+				const item = this.takeFirstAvailableItem();
+				if (item === null) return;
+				const groupId = item.options?.taskGroupId;
+				if (groupId) this.activeGroups.add(groupId);
+				this.activeTasks++;
+				this.executeItem(item);
+			}
+		} catch (error) {
+			console.error(error);
+			throw error;
+		} finally {
+			this.isProcessing = false;
+			if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) this.ensureProcessing();
+		}
+	}
+	async executeItem({ task, options, markStarted, abort }) {
+		markStarted();
+		this.activeTaskAbortCallbacks.add(abort);
+		try {
+			await task();
+		} finally {
+			this.activeTaskAbortCallbacks.delete(abort);
+			this.activeTasks--;
+			if (options && options.taskGroupId) this.activeGroups.delete(options.taskGroupId);
+			this.resolveIdleWaiters();
+			this.ensureProcessing();
+		}
+	}
+	takeFirstAvailableItem = () => {
+		const taskIndex = this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId));
+		if (taskIndex === -1) return null;
+		const [item] = this.queue.splice(taskIndex, 1);
+		return item ?? null;
+	};
+	hasItemsToProcess = () => this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)) !== -1;
+	resolveIdleWaiters = () => {
+		if (this.activeTasks > 0 || this.queue.length > 0) return;
+		const waiters = this.idleWaiters.splice(0);
+		for (const resolve of waiters) resolve();
+	};
+};
+const noopQueueWaitTimer = { cancel: () => {} };
+const createQueueWaitTimer = (timeoutMs, reject) => {
+	if (timeoutMs === void 0) return noopQueueWaitTimer;
+	let timeoutId = setTimeout(() => {
+		reject(/* @__PURE__ */ new Error("Task was not started within the maximum waiting time"));
+	}, timeoutMs);
+	timeoutId.unref();
+	return { cancel: () => {
+		if (!timeoutId) return;
+		clearTimeout(timeoutId);
+		timeoutId = null;
+	} };
+};
+const waitForProcessingOrDeadline = async (processing, closeDeadline) => {
+	let timeoutId = null;
+	try {
+		return await Promise.race([processing.then(() => true), new Promise((resolve) => {
+			timeoutId = setTimeout(() => resolve(false), closeDeadline);
+			timeoutId.unref();
+		})]);
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+};
+
+//#endregion
+//#region src/core/taskProcessing/executionGuards.ts
+const guardConcurrentAccess = (options) => {
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: options?.maxActiveTasks ?? Number.MAX_SAFE_INTEGER,
+		maxQueueSize: options?.maxQueueSize ?? Number.MAX_SAFE_INTEGER,
+		...options?.maxTaskIdleTime !== void 0 ? { maxTaskIdleTime: options.maxTaskIdleTime } : {}
+	});
+	return {
+		execute: (operation, options) => taskProcessor.enqueue(async (context) => {
+			try {
+				return await operation({ abort: context.abort });
+			} finally {
+				context.ack();
+			}
+		}, options),
+		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
+		stop: (options) => taskProcessor.stop(options)
+	};
+};
+const guardBoundedAccess = (getResource, options) => {
+	let isStopped = false;
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: options.maxResources,
+		maxQueueSize: options.maxQueueSize ?? 1e3
+	});
+	const resourcePool = [];
+	const allResources = /* @__PURE__ */ new Set();
+	const activeResourceContexts = /* @__PURE__ */ new Map();
+	const acquireResource = async (taskContext) => {
+		try {
+			let resource;
+			if (options.reuseResources) resource = resourcePool.pop();
+			if (!resource) {
+				resource = await getResource({ abort: taskContext.abort });
+				allResources.add(resource);
+			}
+			activeResourceContexts.set(resource, {
+				ack: taskContext.ack,
+				taskContext
+			});
+			return resource;
+		} catch (e) {
+			taskContext.ack();
+			throw e;
+		}
+	};
+	const acquire = async (operationOptions) => taskProcessor.enqueue((taskContext) => acquireResource(taskContext), operationOptions);
+	const getActiveResourceContext = (resource) => {
+		const activeResourceContext = activeResourceContexts.get(resource);
+		if (!activeResourceContext) throw new Error("Acquired resource is not active");
+		return activeResourceContext;
+	};
+	const release = (resource) => {
+		const activeResourceContext = activeResourceContexts.get(resource);
+		if (activeResourceContext) {
+			activeResourceContexts.delete(resource);
+			if (options.reuseResources) resourcePool.push(resource);
+			activeResourceContext.ack();
+		}
+	};
+	const execute = async (operation, operationOptions) => {
+		return taskProcessor.enqueue(async (taskContext) => {
+			const resource = await acquireResource(taskContext);
+			const activeResourceContext = getActiveResourceContext(resource);
+			try {
+				return await operation(resource, { abort: activeResourceContext.taskContext.abort });
+			} finally {
+				release(resource);
+			}
+		}, operationOptions);
+	};
+	return {
+		acquire,
+		release,
+		execute,
+		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
+		stop: async (stopOptions) => {
+			if (isStopped) return;
+			isStopped = true;
+			await taskProcessor.stop(stopOptions);
+			if (options?.closeResource) {
+				const resources = [...allResources];
+				allResources.clear();
+				resourcePool.length = 0;
+				await Promise.all(resources.map(async (resource) => await options.closeResource(resource)));
+			}
+		}
+	};
+};
+
 //#endregion
 //#region src/core/execute/execute.ts
 const mapColumnToJSON = (column, serializer, options) => ({ [column]: (value) => {
@@ -250,26 +608,63 @@ 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 sqlExecutorInAmbientConnection = (options) => ({
-	query: (sql, queryOptions) => executeInAmbientConnection((connection) => connection.execute.query(sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInAmbientConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInAmbientConnection((connection) => connection.execute.command(sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInAmbientConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
+	query: (sql, queryOptions) => executeInAmbientConnection((connection) => connection.execute.query(sql, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	batchQuery: (sqls, queryOptions) => executeInAmbientConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	command: (sql, commandOptions) => executeInAmbientConnection((connection) => connection.execute.command(sql, commandOptions), {
+		...options,
+		...commandOptions
+	}),
+	batchCommand: (sqls, commandOptions) => executeInAmbientConnection((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) {
@@ -278,7 +673,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 {
@@ -286,10 +682,8 @@ const executeInNewConnection = async (handle, options) => {
 	}
 };
 const executeInAmbientConnection = async (handle, options) => {
-	const connection = await options.connection();
-	try {
-		return await handle(connection);
-	} finally {}
+	Abort.throwIfAborted(options);
+	return handle(await options.connection({ abort: Abort.from(options) }));
 };
 
 //#endregion
@@ -357,10 +751,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;
@@ -369,18 +763,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) => {
@@ -392,7 +800,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,
@@ -401,14 +810,17 @@ 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));
 	}
 });
 const transactionFactoryWithAmbientConnection = (connect) => ({
 	transaction: (options) => {
-		const transaction = connect().transaction(options);
+		Abort.throwIfAborted(options);
+		const transaction = connect({ abort: Abort.from(options) }).transaction(options);
 		return {
 			...transaction,
 			commit: () => transaction.commit(),
@@ -416,7 +828,9 @@ const transactionFactoryWithAmbientConnection = (connect) => ({
 		};
 	},
 	withTransaction: (handle, options) => {
-		const withTx = connect().withTransaction;
+		const abortRejection = Abort.rejectIfAborted(options);
+		if (abortRejection) return abortRejection;
+		const withTx = connect({ abort: Abort.from(options) }).withTransaction;
 		return withTx(handle, options);
 	}
 });
@@ -424,19 +838,21 @@ const transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close
 	close ??= () => Promise.resolve();
 	return {
 		transaction: (options) => {
+			Abort.throwIfAborted(options);
 			let conn = null;
 			let innerTx = null;
 			let connectingPromise = null;
 			const ensureConnection = async () => {
 				if (conn) return innerTx;
 				if (!connectingPromise) connectingPromise = (async () => {
-					conn = await connect();
+					Abort.throwIfAborted(options);
+					conn = await connect({ abort: Abort.from(options) });
 					innerTx = conn.transaction(options);
 				})();
 				await connectingPromise;
 				return innerTx;
 			};
-			return {
+			const tx = {
 				driverType,
 				get connection() {
 					if (!conn) throw new Error("Transaction not started - call begin() first");
@@ -478,11 +894,14 @@ const transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close
 						if (conn) await close(conn);
 					}
 				},
-				_transactionOptions: void 0
+				withTransaction: (handle, options) => executeInNestedTransaction(tx, handle, options, { abort: Abort.from(options) }),
+				_transactionOptions: options ?? {}
 			};
+			return tx;
 		},
 		withTransaction: async (handle, options) => {
-			const conn = await connect();
+			Abort.throwIfAborted(options);
+			const conn = await connect({ abort: Abort.from(options) });
 			try {
 				const withTx = conn.withTransaction;
 				return await withTx(handle, options);
@@ -499,7 +918,10 @@ const createAmbientConnection = (options) => {
 	const { driverType, client, executor, initTransaction, serializer } = options;
 	const clientPromise = Promise.resolve(client);
 	const closePromise = Promise.resolve();
-	const open = () => clientPromise;
+	const open = (context) => {
+		Abort.throwIfAborted(context);
+		return clientPromise;
+	};
 	const close = () => closePromise;
 	const typedConnection = {
 		driverType,
@@ -515,9 +937,10 @@ const createSingletonConnection = (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;
 		});
@@ -535,12 +958,16 @@ const createSingletonConnection = (options) => {
 };
 const createTransientConnection = (options) => {
 	const { driverType, open, close, initTransaction, executor, serializer } = options;
+	const openIfNotAborted = (context) => {
+		Abort.throwIfAborted(context);
+		return open(context);
+	};
 	const typedConnection = {
 		driverType,
-		open,
+		open: openIfNotAborted,
 		close,
-		...transactionFactoryWithDbClient(open, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: open }),
+		...transactionFactoryWithDbClient(openIfNotAborted, initTransaction(() => typedConnection)),
+		execute: sqlExecutor(executor({ serializer }), { connect: openIfNotAborted }),
 		_transactionType: void 0
 	};
 	return typedConnection;
@@ -549,9 +976,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;
 		});
@@ -568,174 +996,6 @@ const createConnection = (options) => {
 	return typedConnection;
 };
 
-//#endregion
-//#region src/core/taskProcessing/taskProcessor.ts
-var TaskProcessor = class {
-	queue = [];
-	isProcessing = false;
-	activeTasks = 0;
-	activeGroups = /* @__PURE__ */ new Set();
-	options;
-	stopped = false;
-	constructor(options) {
-		this.options = options;
-	}
-	enqueue(task, options) {
-		if (this.stopped) return Promise.reject(new DumboError("TaskProcessor has been stopped"));
-		if (this.queue.length >= this.options.maxQueueSize) return Promise.reject(new TransientDatabaseError("Too many pending connections. Please try again later."));
-		return this.schedule(task, options);
-	}
-	waitForEndOfProcessing() {
-		return this.schedule(({ ack }) => Promise.resolve(ack()));
-	}
-	async stop(options) {
-		if (this.stopped) return;
-		this.stopped = true;
-		this.queue.length = 0;
-		this.activeGroups.clear();
-		if (!options?.force) await this.waitForEndOfProcessing();
-	}
-	schedule(task, options) {
-		return promiseWithDeadline((resolve, reject) => {
-			const taskWithContext = () => {
-				return new Promise((resolveTask, failTask) => {
-					task({ ack: resolveTask }).then(resolve).catch((err) => {
-						failTask(err);
-						reject(err);
-					});
-				});
-			};
-			this.queue.push({
-				task: taskWithContext,
-				options
-			});
-			if (!this.isProcessing) this.ensureProcessing();
-		}, { deadline: this.options.maxTaskIdleTime });
-	}
-	ensureProcessing() {
-		if (this.isProcessing) return;
-		this.isProcessing = true;
-		this.processQueue();
-	}
-	processQueue() {
-		try {
-			while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
-				const item = this.takeFirstAvailableItem();
-				if (item === null) return;
-				const groupId = item.options?.taskGroupId;
-				if (groupId) this.activeGroups.add(groupId);
-				this.activeTasks++;
-				this.executeItem(item);
-			}
-		} catch (error) {
-			console.error(error);
-			throw error;
-		} finally {
-			this.isProcessing = false;
-			if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) this.ensureProcessing();
-		}
-	}
-	async executeItem({ task, options }) {
-		try {
-			await task();
-		} finally {
-			this.activeTasks--;
-			if (options && options.taskGroupId) this.activeGroups.delete(options.taskGroupId);
-			this.ensureProcessing();
-		}
-	}
-	takeFirstAvailableItem = () => {
-		const taskIndex = this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId));
-		if (taskIndex === -1) return null;
-		const [item] = this.queue.splice(taskIndex, 1);
-		return item ?? null;
-	};
-	hasItemsToProcess = () => this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)) !== -1;
-};
-const DEFAULT_PROMISE_DEADLINE = 2147483647;
-const promiseWithDeadline = (executor, options) => {
-	return new Promise((resolve, reject) => {
-		let taskStarted = false;
-		let timeoutId = null;
-		const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
-		timeoutId = setTimeout(() => {
-			if (!taskStarted) reject(/* @__PURE__ */ new Error("Task was not started within the maximum waiting time"));
-		}, deadline);
-		timeoutId.unref();
-		executor((value) => {
-			taskStarted = true;
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = null;
-			resolve(value);
-		}, (reason) => {
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = null;
-			reject(reason);
-		});
-	});
-};
-
-//#endregion
-//#region src/core/taskProcessing/executionGuards.ts
-const guardBoundedAccess = (getResource, options) => {
-	let isStopped = false;
-	const taskProcessor = new TaskProcessor({
-		maxActiveTasks: options.maxResources,
-		maxQueueSize: options.maxQueueSize ?? 1e3
-	});
-	const resourcePool = [];
-	const allResources = /* @__PURE__ */ new Set();
-	const ackCallbacks = /* @__PURE__ */ new Map();
-	const acquire = async () => taskProcessor.enqueue(async ({ ack }) => {
-		try {
-			let resource;
-			if (options.reuseResources) resource = resourcePool.pop();
-			if (!resource) {
-				resource = await getResource();
-				allResources.add(resource);
-			}
-			ackCallbacks.set(resource, ack);
-			return resource;
-		} catch (e) {
-			ack();
-			throw e;
-		}
-	});
-	const release = (resource) => {
-		const ack = ackCallbacks.get(resource);
-		if (ack) {
-			ackCallbacks.delete(resource);
-			if (options.reuseResources) resourcePool.push(resource);
-			ack();
-		}
-	};
-	const execute = async (operation) => {
-		const resource = await acquire();
-		try {
-			return await operation(resource);
-		} finally {
-			release(resource);
-		}
-	};
-	return {
-		acquire,
-		release,
-		execute,
-		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
-		stop: async (stopOptions) => {
-			if (isStopped) return;
-			isStopped = true;
-			if (options?.closeResource) {
-				const resources = [...allResources];
-				allResources.clear();
-				resourcePool.length = 0;
-				await Promise.all(resources.map(async (resource) => await options.closeResource(resource)));
-			}
-			await taskProcessor.stop(stopOptions);
-		}
-	};
-};
-
 //#endregion
 //#region src/core/connections/pool.ts
 const wrapPooledConnection = (conn, onClose) => ({
@@ -749,7 +1009,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);
@@ -760,48 +1023,45 @@ const createSingletonConnectionPool = (options) => {
 	const { driverType, getConnection } = options;
 	let connectionPromise = null;
 	let closed = false;
-	const activeOperations = /* @__PURE__ */ new Set();
+	const operationGuard = guardConcurrentAccess();
 	const closedError = () => /* @__PURE__ */ new Error("Singleton connection pool has been closed");
-	const run = async (operation) => {
+	const executeIfOpen = async (operation, operationOptions) => {
 		if (closed) throw closedError();
-		const activeOperation = operation();
-		activeOperations.add(activeOperation);
-		try {
-			return await activeOperation;
-		} finally {
-			activeOperations.delete(activeOperation);
-		}
+		return operationGuard.execute(operation, operationOptions);
 	};
-	const getExistingOrNewConnection = () => {
-		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
+	const getExistingOrNewConnection = (context) => {
+		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection(context));
 		return connectionPromise;
 	};
 	const innerTransactionFactory = transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection);
 	return {
 		driverType,
-		connection: () => run(() => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve()))),
+		connection: (connectionOptions) => executeIfOpen((context) => getExistingOrNewConnection(context).then((conn) => wrapPooledConnection(conn, () => Promise.resolve())), connectionOptions),
 		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))
+				query: (sql, opts) => executeIfOpen(() => ambientExecutor.query(sql, opts), opts),
+				batchQuery: (sqls, opts) => executeIfOpen(() => ambientExecutor.batchQuery(sqls, opts), opts),
+				command: (sql, opts) => executeIfOpen(() => ambientExecutor.command(sql, opts), opts),
+				batchCommand: (sqls, opts) => executeIfOpen(() => ambientExecutor.batchCommand(sqls, opts), opts)
 			};
 		})(),
-		withConnection: (handle, _options) => run(() => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection })),
+		withConnection: (handle, options) => executeIfOpen((context) => executeInAmbientConnection((connection) => handle(connection, context), {
+			connection: getExistingOrNewConnection,
+			...options
+		}), options),
 		transaction: (transactionOptions) => {
 			if (closed) throw closedError();
 			return innerTransactionFactory.transaction(transactionOptions);
 		},
-		withTransaction: (handle, transactionOptions) => run(() => innerTransactionFactory.withTransaction(handle, transactionOptions)),
+		withTransaction: (handle, transactionOptions) => executeIfOpen((context) => innerTransactionFactory.withTransaction((tx) => handle(tx, context), transactionOptions), transactionOptions),
 		close: async (closeOptions) => {
 			if (closed) return;
 			closed = true;
-			if (!closeOptions?.force) await Promise.allSettled([...activeOperations]);
+			await operationGuard.stop(closeOptions);
 			if (!connectionPromise) return;
 			const connection = await connectionPromise;
 			connectionPromise = null;
@@ -811,63 +1071,49 @@ const createSingletonConnectionPool = (options) => {
 };
 const createBoundedConnectionPool = (options) => {
 	const { driverType, maxConnections } = options;
-	const allConnections = /* @__PURE__ */ new Set();
-	const getTrackedConnection = async () => {
-		const connection = await options.getConnection();
-		allConnections.add(connection);
-		return connection;
-	};
-	const guardMaxConnections = guardBoundedAccess(getTrackedConnection, {
+	const guardMaxConnections = guardBoundedAccess(options.getConnection, {
 		maxResources: maxConnections,
-		reuseResources: true
+		reuseResources: true,
+		closeResource: (connection) => connection.close()
 	});
 	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) => {
+	const executeWithPooledConnection = async (operation, operationOptions) => {
 		ensureOpen();
-		const conn = await guardMaxConnections.acquire();
-		try {
-			return await operation(conn);
-		} finally {
-			guardMaxConnections.release(conn);
-		}
+		return guardMaxConnections.execute(operation, operationOptions);
 	};
 	return {
 		driverType,
-		connection: async () => {
+		connection: async (connectionOptions) => {
 			ensureOpen();
-			const conn = await guardMaxConnections.acquire();
+			const conn = await guardMaxConnections.acquire(connectionOptions);
 			return wrapPooledConnection(conn, () => Promise.resolve(guardMaxConnections.release(conn)));
 		},
 		execute: {
-			query: (sql, opts) => executeWithPooling((c) => c.execute.query(sql, opts)),
-			batchQuery: (sqls, opts) => executeWithPooling((c) => c.execute.batchQuery(sqls, opts)),
-			command: (sql, opts) => executeWithPooling((c) => c.execute.command(sql, opts)),
-			batchCommand: (sqls, opts) => executeWithPooling((c) => c.execute.batchCommand(sqls, opts))
+			query: (sql, opts) => executeWithPooledConnection((c) => c.execute.query(sql, opts), opts),
+			batchQuery: (sqls, opts) => executeWithPooledConnection((c) => c.execute.batchQuery(sqls, opts), opts),
+			command: (sql, opts) => executeWithPooledConnection((c) => c.execute.command(sql, opts), opts),
+			batchCommand: (sqls, opts) => executeWithPooledConnection((c) => c.execute.batchCommand(sqls, opts), opts)
 		},
-		withConnection: executeWithPooling,
+		withConnection: executeWithPooledConnection,
 		transaction: (transactionOptions) => {
 			ensureOpen();
-			return transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release).transaction(transactionOptions);
+			return transactionFactoryWithAsyncAmbientConnection(driverType, (context) => guardMaxConnections.acquire({
+				...transactionOptions,
+				abort: context.abort
+			}), guardMaxConnections.release).transaction(transactionOptions);
 		},
-		withTransaction: (handle, transactionOptions) => executeWithPooling((conn) => {
+		withTransaction: (handle, transactionOptions) => executeWithPooledConnection((conn, context) => {
 			const withTx = conn.withTransaction;
-			return withTx(handle, transactionOptions);
-		}),
+			return withTx((tx) => handle(tx, context), transactionOptions);
+		}, transactionOptions),
 		close: async (closeOptions) => {
 			if (closed) return;
 			closed = true;
-			if (!closeOptions?.force) await guardMaxConnections.waitForIdle();
-			await guardMaxConnections.stop({ force: true });
-			await closeAllConnections();
+			await guardMaxConnections.stop(closeOptions);
 		}
 	};
 };
@@ -882,16 +1128,22 @@ const createAlwaysNewConnectionPool = (options) => {
 	const { driverType, getConnection, connectionOptions } = options;
 	return createConnectionPool({
 		driverType,
-		getConnection: () => connectionOptions ? getConnection(connectionOptions) : getConnection()
+		getConnection: (context) => connectionOptions ? getConnection(connectionOptions, context) : getConnection(context)
 	});
 };
 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,
@@ -2498,5 +2750,5 @@ function dumbo(options) {
 }
 
 //#endregion
-export { ANSISQLIdentifierQuote, ANSISQLParamPlaceholder, AdminShutdownError, AutoIncrementSQLColumnToken, BatchCommandNoChangesError, BigIntegerToken, BigSerialToken, CheckViolationError, ColumnTypeToken, ColumnURN, ColumnURNType, ConcurrencyError, ConnectionError, DataError, DatabaseSchemaURN, DatabaseSchemaURNType, DatabaseURN, DatabaseURNType, DeadlockError, DefaultMapSQLParamValueOptions, DumboDatabaseDriverRegistry, DumboDatabaseMetadataRegistry, DumboError, ExclusionViolationError, ExpandArrayProcessor, ExpandSQLInProcessor, ForeignKeyViolationError, FormatIdentifierProcessor, IndexURN, IndexURNType, InsufficientResourcesError, IntegerToken, IntegrityConstraintViolationError, InvalidOperationError, JSONBToken, JSONCodec, JSONParam, JSONReplacer, JSONReplacers, JSONReviver, JSONRevivers, JSONSerializer, LockNotAvailableError, LogLevel, LogStyle, MIGRATIONS_LOCK_ID, MapLiteralProcessor, NoDatabaseLock, NotNullViolationError, ParametrizedSQLBuilder, QueryCanceledError, RawSQL, SQL, SQLArray, SQLColumnToken, SQLColumnTypeTokens, SQLColumnTypeTokensFactory, SQLFormatter, SQLIdentifier, SQLIn, SQLLiteral, SQLPlain, SQLProcessor, SQLProcessorsRegistry, SQLToken, SQLValueMapper, SchemaComponentMigrator, SerialToken, SerializationError, SystemError, TableURN, TableURNType, TimestampToken, TimestamptzToken, TokenizedSQL, TransientDatabaseError, UniqueConstraintError, VarcharToken, ansiSqlReservedMap, canHandleDriverWithConnectionString, color, columnSchemaComponent, combineMigrations, composeJSONReplacers, composeJSONRevivers, count, createAlwaysNewConnectionPool, createAmbientConnection, createAmbientConnectionPool, createBoundedConnectionPool, createConnection, createConnectionPool, createSingletonClientConnectionPool, createSingletonConnection, createSingletonConnectionPool, createTransientConnection, databaseSchemaComponent, databaseSchemaSchemaComponent, databaseTransaction, defaultDatabaseLockOptions, defaultProcessorsRegistry, describeSQL, dumbo, dumboDatabaseDriverRegistry, dumboDatabaseMetadataRegistry$1 as dumboDatabaseMetadataRegistry, dumboSchema, executeInAmbientConnection, executeInNewConnection, executeInNewDbClient, executeInTransaction, exists, filterSchemaComponentsOfType, findSchemaComponentsOfType, first, firstOrNull, formatSQL, fromDatabaseDriverType, getDatabaseDriverName, getDatabaseMetadata, getDatabaseType, getDefaultDatabase, getDefaultDatabaseAsync, getDefaultMigratorOptionsFromRegistry, getFormatter, indexSchemaComponent, isSQL, isSchemaComponentOfType, isTokenizedSQL, jsonSerializer, mapANSISQLParamPlaceholder, mapColumnToBigint, mapColumnToDate, mapColumnToJSON, mapDefaultSQLColumnProcessors, mapRows, mapSQLIdentifier, mapSQLParamValue, mapSQLQueryResult, mapSchemaComponentsOfType, mapToCamelCase, migrationTableSchemaComponent, parseConnectionString, prettyJson, registerDefaultMigratorOptions, registerFormatter, relationship, resolveDatabaseMetadata, runSQLMigrations, schemaComponent, schemaComponentURN, single, singleOrNull, sqlExecutor, sqlExecutorInAmbientConnection, sqlExecutorInNewConnection, sqlMigration, tableSchemaComponent, toCamelCase, toDatabaseDriverType, tracer, transactionFactoryWithAmbientConnection, transactionFactoryWithAsyncAmbientConnection, transactionFactoryWithDbClient, transactionFactoryWithNewConnection, transactionNestingCounter };
+export { ANSISQLIdentifierQuote, ANSISQLParamPlaceholder, Abort, AdminShutdownError, AutoIncrementSQLColumnToken, BatchCommandNoChangesError, BigIntegerToken, BigSerialToken, CheckViolationError, ColumnTypeToken, ColumnURN, ColumnURNType, ConcurrencyError, ConnectionError, DataError, DatabaseSchemaURN, DatabaseSchemaURNType, DatabaseURN, DatabaseURNType, DeadlockError, DefaultMapSQLParamValueOptions, DumboDatabaseDriverRegistry, DumboDatabaseMetadataRegistry, DumboError, ExclusionViolationError, ExpandArrayProcessor, ExpandSQLInProcessor, ForeignKeyViolationError, FormatIdentifierProcessor, IndexURN, IndexURNType, InsufficientResourcesError, IntegerToken, IntegrityConstraintViolationError, InvalidOperationError, JSONBToken, JSONCodec, JSONParam, JSONReplacer, JSONReplacers, JSONReviver, JSONRevivers, JSONSerializer, LockNotAvailableError, LogLevel, LogStyle, MIGRATIONS_LOCK_ID, MapLiteralProcessor, NoDatabaseLock, NotNullViolationError, ParametrizedSQLBuilder, QueryCanceledError, RawSQL, SQL, SQLArray, SQLColumnToken, SQLColumnTypeTokens, SQLColumnTypeTokensFactory, SQLFormatter, SQLIdentifier, SQLIn, SQLLiteral, SQLPlain, SQLProcessor, SQLProcessorsRegistry, SQLToken, SQLValueMapper, SchemaComponentMigrator, SerialToken, SerializationError, SystemError, TableURN, TableURNType, TimestampToken, TimestamptzToken, TokenizedSQL, TransientDatabaseError, UniqueConstraintError, VarcharToken, ansiSqlReservedMap, canHandleDriverWithConnectionString, color, columnSchemaComponent, combineMigrations, composeJSONReplacers, composeJSONRevivers, count, createAlwaysNewConnectionPool, createAmbientConnection, createAmbientConnectionPool, createBoundedConnectionPool, createConnection, createConnectionPool, createSingletonClientConnectionPool, createSingletonConnection, createSingletonConnectionPool, createTransientConnection, databaseSchemaComponent, databaseSchemaSchemaComponent, databaseTransaction, defaultDatabaseLockOptions, defaultProcessorsRegistry, describeSQL, dumbo, dumboDatabaseDriverRegistry, dumboDatabaseMetadataRegistry$1 as dumboDatabaseMetadataRegistry, dumboSchema, executeInAmbientConnection, executeInNestedTransaction, executeInNewConnection, executeInNewDbClient, executeInTransaction, exists, filterSchemaComponentsOfType, findSchemaComponentsOfType, first, firstOrNull, formatSQL, fromDatabaseDriverType, getDatabaseDriverName, getDatabaseMetadata, getDatabaseType, getDefaultDatabase, getDefaultDatabaseAsync, getDefaultMigratorOptionsFromRegistry, getFormatter, indexSchemaComponent, isSQL, isSchemaComponentOfType, isTokenizedSQL, jsonSerializer, mapANSISQLParamPlaceholder, mapColumnToBigint, mapColumnToDate, mapColumnToJSON, mapDefaultSQLColumnProcessors, mapRows, mapSQLIdentifier, mapSQLParamValue, mapSQLQueryResult, mapSchemaComponentsOfType, mapToCamelCase, migrationTableSchemaComponent, parseConnectionString, prettyJson, registerDefaultMigratorOptions, registerFormatter, relationship, resolveDatabaseMetadata, runSQLMigrations, schemaComponent, schemaComponentURN, single, singleOrNull, sqlExecutor, sqlExecutorInAmbientConnection, sqlExecutorInNewConnection, sqlMigration, tableSchemaComponent, toCamelCase, toDatabaseDriverType, tracer, transactionFactoryWithAmbientConnection, transactionFactoryWithAsyncAmbientConnection, transactionFactoryWithDbClient, transactionFactoryWithNewConnection, transactionNestingCounter };
 //# sourceMappingURL=index.js.map