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

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