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

package/dist/sqlite.cjs

@@ -201,6 +201,294 @@ 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)
+	};
+};
+
 //#endregion
 //#region src/core/execute/execute.ts
 const mapSQLQueryResult = (result, mapping) => {
@@ -210,26 +498,63 @@ const mapSQLQueryResult = (result, mapping) => {
 	return mappedResult;
 };
 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) {
@@ -238,7 +563,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 {
@@ -246,10 +572,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
@@ -317,10 +641,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;
@@ -329,18 +653,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) => {
@@ -352,7 +690,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,
@@ -361,7 +700,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));
 	}
@@ -370,19 +711,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");
@@ -424,11 +767,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);
@@ -445,7 +791,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,
@@ -461,9 +810,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 +843,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);
@@ -504,48 +857,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;
@@ -557,16 +907,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,
@@ -1901,9 +2257,9 @@ const sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
 
 //#endregion
 //#region src/storage/sqlite/core/transactions/index.ts
-const sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer, defaultTransactionMode) => (getClient, options) => {
-	allowNestedTransactions = options?.allowNestedTransactions ?? allowNestedTransactions;
-	const useSavepoints = options?.useSavepoints ?? false;
+const sqliteTransaction = (driverType, connection, defaultOptions, serializer, defaultTransactionMode) => (getClient, options) => {
+	const defaultTransactionOptions = typeof defaultOptions === "boolean" ? { allowNestedTransactions: defaultOptions } : defaultOptions;
+	const allowNestedTransactions = options?.allowNestedTransactions ?? defaultTransactionOptions.allowNestedTransactions ?? false;
 	const tx = databaseTransaction({
 		begin: async () => {
 			const client = await getClient;
@@ -1931,23 +2287,28 @@ const sqliteTransaction = (driverType, connection, allowNestedTransactions, seri
 		},
 		releaseSavepoint: async (level) => {
 			await (await getClient).command(SQL`RELEASE transaction${SQL.plain(level.toString())}`);
+		},
+		rollbackToSavepoint: async (level) => {
+			await (await getClient).command(SQL`ROLLBACK TO transaction${SQL.plain(level.toString())}`);
 		}
 	}, {
 		allowNestedTransactions,
-		useSavepoints
+		useSavepoints: options?.useSavepoints ?? defaultTransactionOptions.useSavepoints ?? false
 	});
-	return {
+	const transaction = {
 		connection: connection(),
 		driverType,
 		begin: tx.begin,
 		commit: tx.commit,
 		rollback: tx.rollback,
 		execute: sqlExecutor(sqliteSQLExecutor(driverType, serializer), { connect: () => getClient }),
+		withTransaction: (handle, options) => executeInNestedTransaction(transaction, handle, options),
 		_transactionOptions: {
 			...options,
 			allowNestedTransactions
 		}
 	};
+	return transaction;
 };
 
 //#endregion
@@ -1992,7 +2353,7 @@ const sqliteAmbientClientConnection = (options) => {
 	return createAmbientConnection({
 		driverType,
 		client,
-		initTransaction: initTransaction ?? ((connection) => sqliteTransaction(driverType, connection, allowNestedTransactions ?? false, serializer, defaultTransactionMode)),
+		initTransaction: initTransaction ?? ((connection) => sqliteTransaction(driverType, connection, { allowNestedTransactions: allowNestedTransactions ?? false }, serializer, defaultTransactionMode)),
 		executor: ({ serializer }) => sqliteSQLExecutor(driverType, serializer, void 0, errorMapper),
 		serializer
 	});
@@ -2017,7 +2378,7 @@ const sqliteClientConnection = (options) => {
 			if (client && "close" in client && typeof client.close === "function") await client.close();
 			else if (client && "release" in client && typeof client.release === "function") client.release();
 		},
-		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions?.allowNestedTransactions ?? false, serializer, connectionOptions.defaultTransactionMode),
+		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions ?? {}, serializer, connectionOptions.defaultTransactionMode),
 		executor: ({ serializer }) => sqliteSQLExecutor(options.driverType, serializer),
 		serializer
 	});
@@ -2039,7 +2400,7 @@ const sqlitePoolClientConnection = (options) => {
 		driverType: options.driverType,
 		connect,
 		close: () => client !== null ? Promise.resolve(client.release()) : Promise.resolve(),
-		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions?.allowNestedTransactions ?? false, serializer, connectionOptions.defaultTransactionMode),
+		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions ?? {}, serializer, connectionOptions.defaultTransactionMode),
 		executor: ({ serializer }) => sqliteSQLExecutor(options.driverType, serializer),
 		serializer
 	});