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

package/dist/index-kYttgYkC.d.cts

@@ -0,0 +1,74 @@
+import { Bt as DatabaseLockOptions, Ea as SQLProcessor, Ht as ReleaseDatabaseLockOptions, In as DumboError, Ji as SQL, Lt as AcquireDatabaseLockMode, Rt as AcquireDatabaseLockOptions, Vi as SQLFormatter, go as SQLPlain, i as DatabaseConnectionString, jt as MigratorOptions, lo as SQLArray, mo as SQLIn, pt as DatabaseDriverType, rn as SQLExecutor, xa as DefaultSQLColumnProcessors, zt as DatabaseLock } from "./index-_dj3upBo.cjs";
+
+//#region src/storage/postgresql/core/connections/connectionString.d.ts
+declare const defaultPostgreSQLConnectionString: PostgreSQLConnectionString;
+type PostgreSQLConnectionString = DatabaseConnectionString<'PostgreSQL', `postgresql://${string}` | `postgres://${string}`>;
+declare const PostgreSQLConnectionString: (connectionString: string) => PostgreSQLConnectionString;
+/**
+ * Parse database name from a PostgreSQL connection string
+ */
+declare function parseDatabaseName(str: string): string | null;
+//#endregion
+//#region src/storage/postgresql/core/errors/errorMapper.d.ts
+/**
+ * Maps a PostgreSQL error (from the `pg` driver) to a typed DumboError
+ * based on the SQLSTATE code.
+ *
+ * SQLSTATE reference: https://www.postgresql.org/docs/current/errcodes-appendix.html
+ * Transient classification based on Npgsql's PostgresException.IsTransient.
+ *
+ * Falls back to a generic DumboError (500) if the error is not a recognized PostgreSQL error.
+ */
+declare const mapPostgresError: (error: unknown) => DumboError;
+//#endregion
+//#region src/storage/postgresql/core/locks/advisoryLocks.d.ts
+declare const tryAcquireAdvisoryLock: (execute: SQLExecutor, options: AcquireDatabaseLockOptions) => Promise<boolean>;
+declare const releaseAdvisoryLock: (execute: SQLExecutor, options: ReleaseDatabaseLockOptions) => Promise<boolean>;
+declare const acquireAdvisoryLock: (execute: SQLExecutor, options: AcquireDatabaseLockOptions) => Promise<void>;
+declare const AdvisoryLock: DatabaseLock;
+declare const advisoryLock: (execute: SQLExecutor, options: DatabaseLockOptions) => {
+  acquire: (acquireOptions?: {
+    mode: AcquireDatabaseLockMode;
+  }) => Promise<void>;
+  tryAcquire: (acquireOptions?: {
+    mode: AcquireDatabaseLockMode;
+  }) => Promise<boolean>;
+  release: () => Promise<boolean>;
+  withAcquire: <Result>(handle: () => Promise<Result>, acquireOptions?: {
+    mode: AcquireDatabaseLockMode;
+  }) => Promise<Result>;
+};
+//#endregion
+//#region src/storage/postgresql/core/schema/migrations.d.ts
+declare const DefaultPostgreSQLMigratorOptions: MigratorOptions;
+//#endregion
+//#region src/storage/postgresql/core/schema/schema.d.ts
+declare const defaultPostgreSqlDatabase = "postgres";
+declare const tableExistsSQL: (tableName: string) => SQL;
+declare const tableExists: (execute: SQLExecutor, tableName: string) => Promise<boolean>;
+declare const functionExistsSQL: (functionName: string) => SQL;
+declare const functionExists: (execute: SQLExecutor, functionName: string) => Promise<boolean>;
+//#endregion
+//#region src/storage/postgresql/core/sql/formatter/index.d.ts
+declare const pgFormatter: SQLFormatter;
+//#endregion
+//#region src/storage/postgresql/core/sql/json.d.ts
+declare const PostgreSQLJSON: {
+  readonly field: (source: SQL, path: string) => SQL;
+  readonly path: (path: string) => SQLPlain;
+  readonly textField: (source: SQL, path: string) => SQL;
+};
+//#endregion
+//#region src/storage/postgresql/core/sql/processors/arrayProcessors.d.ts
+declare const PostgreSQLArrayProcessor: SQLProcessor<SQLArray>;
+declare const PostgreSQLExpandSQLInProcessor: SQLProcessor<SQLIn>;
+//#endregion
+//#region src/storage/postgresql/core/sql/processors/columProcessors.d.ts
+declare const postgreSQLColumnProcessors: DefaultSQLColumnProcessors;
+//#endregion
+//#region src/storage/postgresql/core/index.d.ts
+type PostgreSQLDatabaseName = 'PostgreSQL';
+declare const PostgreSQLDatabaseName = "PostgreSQL";
+type PostgreSQLDriverType<DriverName extends string = string> = DatabaseDriverType<PostgreSQLDatabaseName, DriverName>;
+//#endregion
+export { parseDatabaseName as S, releaseAdvisoryLock as _, PostgreSQLExpandSQLInProcessor as a, PostgreSQLConnectionString as b, defaultPostgreSqlDatabase as c, tableExists as d, tableExistsSQL as f, advisoryLock as g, acquireAdvisoryLock as h, PostgreSQLArrayProcessor as i, functionExists as l, AdvisoryLock as m, PostgreSQLDriverType as n, PostgreSQLJSON as o, DefaultPostgreSQLMigratorOptions as p, postgreSQLColumnProcessors as r, pgFormatter as s, PostgreSQLDatabaseName as t, functionExistsSQL as u, tryAcquireAdvisoryLock as v, defaultPostgreSQLConnectionString as x, mapPostgresError as y };

package/dist/index.cjs

@@ -323,6 +323,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
@@ -729,33 +788,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);
@@ -766,6 +872,7 @@ const createBoundedConnectionPool = (options) => {
 	return {
 		driverType,
 		connection: async () => {
+			ensureOpen();
 			const conn = await guardMaxConnections.acquire();
 			return wrapPooledConnection(conn, () => Promise.resolve(guardMaxConnections.release(conn)));
 		},
@@ -776,11 +883,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();
 		}
 	};
 };
@@ -2509,6 +2625,7 @@ exports.createSingletonConnectionPool = createSingletonConnectionPool;
 exports.createTransientConnection = createTransientConnection;
 exports.databaseSchemaComponent = databaseSchemaComponent;
 exports.databaseSchemaSchemaComponent = databaseSchemaSchemaComponent;
+exports.databaseTransaction = databaseTransaction;
 exports.defaultDatabaseLockOptions = defaultDatabaseLockOptions;
 exports.defaultProcessorsRegistry = defaultProcessorsRegistry;
 exports.describeSQL = describeSQL;
@@ -2574,4 +2691,5 @@ exports.transactionFactoryWithAmbientConnection = transactionFactoryWithAmbientC
 exports.transactionFactoryWithAsyncAmbientConnection = transactionFactoryWithAsyncAmbientConnection;
 exports.transactionFactoryWithDbClient = transactionFactoryWithDbClient;
 exports.transactionFactoryWithNewConnection = transactionFactoryWithNewConnection;
+exports.transactionNestingCounter = transactionNestingCounter;
 //# sourceMappingURL=index.cjs.map