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

package/dist/sqlite3.d.cts

@@ -895,9 +895,12 @@ type InitTransaction<ConnectionType extends AnyConnection = AnyConnection> = (co
 }) => InferTransactionFromConnection<ConnectionType>;
 //#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
@@ -988,13 +991,6 @@ type SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLit
 };
 type SQLiteConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ClientOptions = SQLiteClientOptions> = SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions> | SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>;
 type SQLiteConnectionFactory<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (options: ConnectionOptions) => SQLiteConnectionType;
-type TransactionNestingCounter = {
-  increment: () => void;
-  decrement: () => void;
-  reset: () => void;
-  level: number;
-};
-declare const transactionNestingCounter: () => TransactionNestingCounter;
 type SqliteAmbientClientConnectionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection> = {
   driverType: SQLiteConnectionType['driverType'];
   client: InferDbClientFromConnection<SQLiteConnectionType>;
@@ -1204,5 +1200,5 @@ type SQLite3DumboConnectionOptions = DumboConnectionOptions<typeof sqlite3DumboD
   connectionString: string | SQLiteConnectionString;
 };
 //#endregion
-export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, ConnectionCheckResult, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLite3Client, SQLite3ClientOptions, SQLite3Connection, SQLite3ConnectionOptions, SQLite3DriverType, SQLite3DumboConnectionOptions, SQLite3DumboOptions, SQLite3PoolOptions, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, Sqlite3Pool, SqliteAmbientClientConnectionOptions, TransactionNestingCounter, checkConnection, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqlite3Client, sqlite3Connection, sqlite3DumboDriver, sqlite3Pool, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter, useSqlite3DumboDriver };
+export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, ConnectionCheckResult, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLite3Client, SQLite3ClientOptions, SQLite3Connection, SQLite3ConnectionOptions, SQLite3DriverType, SQLite3DumboConnectionOptions, SQLite3DumboOptions, SQLite3PoolOptions, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, Sqlite3Pool, SqliteAmbientClientConnectionOptions, checkConnection, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqlite3Client, sqlite3Connection, sqlite3DumboDriver, sqlite3Pool, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, useSqlite3DumboDriver };
 //# sourceMappingURL=sqlite3.d.cts.map

package/dist/sqlite3.d.ts

@@ -895,9 +895,12 @@ type InitTransaction<ConnectionType extends AnyConnection = AnyConnection> = (co
 }) => InferTransactionFromConnection<ConnectionType>;
 //#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
@@ -988,13 +991,6 @@ type SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLit
 };
 type SQLiteConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ClientOptions = SQLiteClientOptions> = SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions> | SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>;
 type SQLiteConnectionFactory<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (options: ConnectionOptions) => SQLiteConnectionType;
-type TransactionNestingCounter = {
-  increment: () => void;
-  decrement: () => void;
-  reset: () => void;
-  level: number;
-};
-declare const transactionNestingCounter: () => TransactionNestingCounter;
 type SqliteAmbientClientConnectionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection> = {
   driverType: SQLiteConnectionType['driverType'];
   client: InferDbClientFromConnection<SQLiteConnectionType>;
@@ -1204,5 +1200,5 @@ type SQLite3DumboConnectionOptions = DumboConnectionOptions<typeof sqlite3DumboD
   connectionString: string | SQLiteConnectionString;
 };
 //#endregion
-export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, ConnectionCheckResult, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLite3Client, SQLite3ClientOptions, SQLite3Connection, SQLite3ConnectionOptions, SQLite3DriverType, SQLite3DumboConnectionOptions, SQLite3DumboOptions, SQLite3PoolOptions, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, Sqlite3Pool, SqliteAmbientClientConnectionOptions, TransactionNestingCounter, checkConnection, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqlite3Client, sqlite3Connection, sqlite3DumboDriver, sqlite3Pool, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter, useSqlite3DumboDriver };
+export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, ConnectionCheckResult, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLite3Client, SQLite3ClientOptions, SQLite3Connection, SQLite3ConnectionOptions, SQLite3DriverType, SQLite3DumboConnectionOptions, SQLite3DumboOptions, SQLite3PoolOptions, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, Sqlite3Pool, SqliteAmbientClientConnectionOptions, checkConnection, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqlite3Client, sqlite3Connection, sqlite3DumboDriver, sqlite3Pool, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, useSqlite3DumboDriver };
 //# sourceMappingURL=sqlite3.d.ts.map

package/dist/sqlite3.js

@@ -243,6 +243,65 @@ const executeInAmbientConnection = 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
@@ -636,33 +695,80 @@ const createAmbientConnectionPool = (options) => {
 const createSingletonConnectionPool = (options) => {
 	const { driverType, getConnection } = options;
 	let connectionPromise = null;
+	let closed = false;
+	const activeOperations = /* @__PURE__ */ new Set();
+	const closedError = () => /* @__PURE__ */ new Error("Singleton connection pool has been closed");
+	const run = async (operation) => {
+		if (closed) throw closedError();
+		const activeOperation = operation();
+		activeOperations.add(activeOperation);
+		try {
+			return await activeOperation;
+		} finally {
+			activeOperations.delete(activeOperation);
+		}
+	};
 	const getExistingOrNewConnection = () => {
 		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
 		return connectionPromise;
 	};
+	const innerTransactionFactory = transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection);
 	return {
 		driverType,
-		connection: () => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve())),
-		execute: sqlExecutorInAmbientConnection({
-			driverType,
-			connection: getExistingOrNewConnection
-		}),
-		withConnection: (handle, _options) => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection }),
-		...transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection),
-		close: async () => {
+		connection: () => run(() => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve()))),
+		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))
+			};
+		})(),
+		withConnection: (handle, _options) => run(() => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection })),
+		transaction: (transactionOptions) => {
+			if (closed) throw closedError();
+			return innerTransactionFactory.transaction(transactionOptions);
+		},
+		withTransaction: (handle, transactionOptions) => run(() => innerTransactionFactory.withTransaction(handle, transactionOptions)),
+		close: async (closeOptions) => {
+			if (closed) return;
+			closed = true;
+			if (!closeOptions?.force) await Promise.allSettled([...activeOperations]);
 			if (!connectionPromise) return;
-			await (await connectionPromise).close();
+			const connection = await connectionPromise;
+			connectionPromise = null;
+			await connection.close();
 		}
 	};
 };
 const createBoundedConnectionPool = (options) => {
 	const { driverType, maxConnections } = options;
-	const guardMaxConnections = guardBoundedAccess(options.getConnection, {
+	const allConnections = /* @__PURE__ */ new Set();
+	const getTrackedConnection = async () => {
+		const connection = await options.getConnection();
+		allConnections.add(connection);
+		return connection;
+	};
+	const guardMaxConnections = guardBoundedAccess(getTrackedConnection, {
 		maxResources: maxConnections,
 		reuseResources: true
 	});
 	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) => {
+		ensureOpen();
 		const conn = await guardMaxConnections.acquire();
 		try {
 			return await operation(conn);
@@ -673,6 +779,7 @@ const createBoundedConnectionPool = (options) => {
 	return {
 		driverType,
 		connection: async () => {
+			ensureOpen();
 			const conn = await guardMaxConnections.acquire();
 			return wrapPooledConnection(conn, () => Promise.resolve(guardMaxConnections.release(conn)));
 		},
@@ -683,11 +790,20 @@ const createBoundedConnectionPool = (options) => {
 			batchCommand: (sqls, opts) => executeWithPooling((c) => c.execute.batchCommand(sqls, opts))
 		},
 		withConnection: executeWithPooling,
-		...transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release),
-		close: async () => {
+		transaction: (transactionOptions) => {
+			ensureOpen();
+			return transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release).transaction(transactionOptions);
+		},
+		withTransaction: (handle, transactionOptions) => executeWithPooling((conn) => {
+			const withTx = conn.withTransaction;
+			return withTx(handle, transactionOptions);
+		}),
+		close: async (closeOptions) => {
 			if (closed) return;
 			closed = true;
+			if (!closeOptions?.force) await guardMaxConnections.waitForIdle();
 			await guardMaxConnections.stop({ force: true });
+			await closeAllConnections();
 		}
 	};
 };
@@ -2045,54 +2161,46 @@ const sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
 //#endregion
 //#region src/storage/sqlite/core/transactions/index.ts
 const sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer, defaultTransactionMode) => (getClient, options) => {
-	const transactionCounter = transactionNestingCounter();
 	allowNestedTransactions = options?.allowNestedTransactions ?? allowNestedTransactions;
-	let hasBegun = false;
-	return {
-		connection: connection(),
-		driverType,
-		begin: async function() {
+	const useSavepoints = options?.useSavepoints ?? false;
+	const tx = databaseTransaction({
+		begin: async () => {
 			const client = await getClient;
-			if (allowNestedTransactions) {
-				if (transactionCounter.level >= 1) {
-					transactionCounter.increment();
-					if (options?.useSavepoints) await client.command(SQL`SAVEPOINT transaction${SQL.plain(transactionCounter.level.toString())}`);
-					return;
-				}
-				transactionCounter.increment();
-			} else if (hasBegun) throw new InvalidOperationError("Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.");
-			hasBegun = true;
 			const mode = options?.mode ?? defaultTransactionMode ?? "IMMEDIATE";
 			await client.command(SQL`BEGIN ${SQL.plain(mode)} TRANSACTION`);
 		},
-		commit: async function() {
+		commit: async () => {
 			const client = await getClient;
-			if (allowNestedTransactions && transactionCounter.level > 1) {
-				if (options?.useSavepoints) await client.command(SQL`RELEASE transaction${SQL.plain(transactionCounter.level.toString())}`);
-				transactionCounter.decrement();
-				return;
-			}
 			try {
-				if (allowNestedTransactions) transactionCounter.reset();
-				hasBegun = false;
 				await client.command(SQL`COMMIT`);
 			} finally {
-				if (options?.close) await options?.close(client);
+				if (options?.close) await options.close(client);
 			}
 		},
-		rollback: async function(error) {
+		rollback: async (error) => {
 			const client = await getClient;
-			if (allowNestedTransactions && transactionCounter.level > 1) {
-				transactionCounter.decrement();
-				return;
-			}
 			try {
-				hasBegun = false;
 				await client.command(SQL`ROLLBACK`);
 			} finally {
-				if (options?.close) await options?.close(client, error);
+				if (options?.close) await options.close(client, error);
 			}
 		},
+		savepoint: async (level) => {
+			await (await getClient).command(SQL`SAVEPOINT transaction${SQL.plain(level.toString())}`);
+		},
+		releaseSavepoint: async (level) => {
+			await (await getClient).command(SQL`RELEASE transaction${SQL.plain(level.toString())}`);
+		}
+	}, {
+		allowNestedTransactions,
+		useSavepoints
+	});
+	return {
+		connection: connection(),
+		driverType,
+		begin: tx.begin,
+		commit: tx.commit,
+		rollback: tx.rollback,
 		execute: sqlExecutor(sqliteSQLExecutor(driverType, serializer), { connect: () => getClient }),
 		_transactionOptions: {
 			...options,
@@ -2138,24 +2246,6 @@ const isSQLiteError = (error) => {
 	if (error instanceof Error && "code" in error) return true;
 	return false;
 };
-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 sqliteAmbientClientConnection = (options) => {
 	const { client, driverType, initTransaction, allowNestedTransactions, defaultTransactionMode, serializer, errorMapper } = options;
 	return createAmbientConnection({
@@ -2581,7 +2671,9 @@ const sqlite3Connection = (options) => sqliteConnection({
 
 //#endregion
 //#region src/storage/sqlite/sqlite3/pool/singletonPool.ts
+const DEFAULT_SQLITE_MAX_TASK_IDLE_TIME_MS = 3e4;
 const sqlite3SingletonPool = (options) => {
+	const maxTaskIdleTime = options.maxTaskIdleTime ?? 3e4;
 	const inner = createSingletonConnectionPool({
 		driverType: options.driverType,
 		getConnection: options.getConnection,
@@ -2589,7 +2681,8 @@ const sqlite3SingletonPool = (options) => {
 	});
 	const taskProcessor = new TaskProcessor({
 		maxActiveTasks: 1,
-		maxQueueSize: options.maxQueueSize ?? 1e3
+		maxQueueSize: options.maxQueueSize ?? 1e3,
+		maxTaskIdleTime
 	});
 	const insideWriterTask = new AsyncLocalStorage();
 	const enqueue = (op) => {
@@ -2614,9 +2707,9 @@ const sqlite3SingletonPool = (options) => {
 			command: (sql, commandOptions) => enqueue(() => inner.execute.command(sql, commandOptions)),
 			batchCommand: (sqls, commandOptions) => enqueue(() => inner.execute.batchCommand(sqls, commandOptions))
 		},
-		close: async () => {
-			await taskProcessor.stop();
-			await inner.close();
+		close: async (closeOptions) => {
+			await taskProcessor.stop({ ...closeOptions?.force ? { force: true } : {} });
+			await inner.close(closeOptions);
 		}
 	};
 };
@@ -2661,7 +2754,8 @@ const sqliteDualConnectionPool = (options) => {
 	};
 	const writerPool = sqlite3SingletonPool({
 		driverType: options.driverType,
-		getConnection: () => wrappedConnectionFactory(false, connectionOptions)
+		getConnection: () => wrappedConnectionFactory(false, connectionOptions),
+		...options.maxTaskIdleTime !== void 0 ? { maxTaskIdleTime: options.maxTaskIdleTime } : {}
 	});
 	const readerPool = createBoundedConnectionPool({
 		driverType: options.driverType,
@@ -2698,18 +2792,26 @@ const sqlite3Pool = (options) => {
 		...opts,
 		serializer: options.serializer ?? JSONSerializer
 	});
-	if (isInMemoryDatabase(options) || "client" in options && Boolean(options.client) || options.singleton === true) return sqlite3SingletonPool({
+	const isSingleton = isInMemoryDatabase(options) || "client" in options && Boolean(options.client) || options.singleton === true;
+	const lifecycleOptions = extractLifecycleOptions(options);
+	if (isSingleton) return sqlite3SingletonPool({
 		driverType: SQLite3DriverType,
-		getConnection: () => sqliteConnectionFactory(options)
+		getConnection: () => sqliteConnectionFactory(options),
+		...lifecycleOptions
 	});
 	const readerPoolSize = options.readerPoolSize;
 	return sqliteDualConnectionPool({
 		driverType: SQLite3DriverType,
 		sqliteConnectionFactory,
 		connectionOptions: options,
-		...readerPoolSize !== void 0 ? { readerPoolSize } : {}
+		...readerPoolSize !== void 0 ? { readerPoolSize } : {},
+		...lifecycleOptions
 	});
 };
+const extractLifecycleOptions = (options) => {
+	const lifecycle = options;
+	return { ...lifecycle.maxTaskIdleTime !== void 0 ? { maxTaskIdleTime: lifecycle.maxTaskIdleTime } : {} };
+};
 const tryParseConnectionString = (connectionString) => {
 	try {
 		return SQLiteConnectionString(connectionString);
@@ -2731,5 +2833,5 @@ const useSqlite3DumboDriver = () => {
 useSqlite3DumboDriver();
 
 //#endregion
-export { DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLite3DriverType, SQLiteConnectionString, SQLiteDatabaseName, SQLiteJSON, checkConnection, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqlite3Client, sqlite3Connection, sqlite3DumboDriver, sqlite3Pool, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter, useSqlite3DumboDriver };
+export { DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLite3DriverType, SQLiteConnectionString, SQLiteDatabaseName, SQLiteJSON, checkConnection, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqlite3Client, sqlite3Connection, sqlite3DumboDriver, sqlite3Pool, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, useSqlite3DumboDriver };
 //# sourceMappingURL=sqlite3.js.map