@event-driven-io/dumbo 0.13.0-beta.35 → 0.13.0-beta.36

package/dist/pg.cjs

@@ -1,467 +1,402 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkGNH5XC6Dcjs = require('./chunk-GNH5XC6D.cjs');
-
-
-
-
-
-
-
-
-
-
-var _chunkNJI6PJFZcjs = require('./chunk-NJI6PJFZ.cjs');
-
-
-
-
-
-
-
-
-
-
-
-var _chunk4MMMEDQ7cjs = require('./chunk-4MMMEDQ7.cjs');
-
-// src/storage/postgresql/pg/connections/connection.ts
-var _pg = require('pg'); var _pg2 = _interopRequireDefault(_pg);
-
-// src/storage/postgresql/pg/execute/execute.ts
-
-var isPgNativePool = (poolOrClient) => {
-  return poolOrClient instanceof _pg2.default.Pool;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core = require('./core-BgYtAxCm.cjs');
+const require_postgreSQLMetadata = require('./postgreSQLMetadata-LqX-Z_wo.cjs');
+const require_core$1 = require('./core-Go_IA78L.cjs');
+let pg = require("pg");
+pg = require_core.__toESM(pg, 1);
+
+//#region src/storage/postgresql/pg/execute/execute.ts
+const isPgNativePool = (poolOrClient) => {
+	return poolOrClient instanceof pg.default.Pool;
 };
-var isPgClient = (poolOrClient) => poolOrClient instanceof _pg2.default.Client;
-var isPgPoolClient = (poolOrClient) => "release" in poolOrClient && typeof poolOrClient.release === "function";
-var pgExecute = async (poolOrClient, handle) => {
-  const client = isPgNativePool(poolOrClient) ? await poolOrClient.connect() : poolOrClient;
-  try {
-    return await handle(client);
-  } finally {
-    if (isPgNativePool(poolOrClient) && isPgPoolClient(client))
-      client.release();
-  }
+const isPgClient = (poolOrClient) => poolOrClient instanceof pg.default.Client;
+const isPgPoolClient = (poolOrClient) => "release" in poolOrClient && typeof poolOrClient.release === "function";
+const pgExecute = async (poolOrClient, handle) => {
+	const client = isPgNativePool(poolOrClient) ? await poolOrClient.connect() : poolOrClient;
+	try {
+		return await handle(client);
+	} finally {
+		if (isPgNativePool(poolOrClient) && isPgPoolClient(client)) client.release();
+	}
 };
-var pgSQLExecutor = ({
-  serializer
-}) => ({
-  driverType: PgDriverType,
-  query: async (client, sql, options) => {
-    const results = await batchQuery(
-      client,
-      [sql],
-      serializer,
-      options
-    );
-    return results[0];
-  },
-  batchQuery: (client, sqls, options) => batchQuery(client, sqls, serializer, options),
-  command: async (client, sql, options) => {
-    const results = await batchCommand(
-      client,
-      [sql],
-      serializer,
-      options
-    );
-    return results[0];
-  },
-  batchCommand: (client, sqls, options) => batchCommand(client, sqls, serializer, options),
-  formatter: _chunkGNH5XC6Dcjs.pgFormatter
+const pgSQLExecutor = ({ serializer }) => ({
+	driverType: PgDriverType,
+	query: async (client, sql, options) => {
+		return (await batchQuery(client, [sql], serializer, options))[0];
+	},
+	batchQuery: (client, sqls, options) => batchQuery(client, sqls, serializer, options),
+	command: async (client, sql, options) => {
+		return (await batchCommand(client, [sql], serializer, options))[0];
+	},
+	batchCommand: (client, sqls, options) => batchCommand(client, sqls, serializer, options),
+	formatter: require_core$1.pgFormatter
 });
 async function batchQuery(client, sqls, serializer, options) {
-  const results = Array(
-    sqls.length
-  );
-  if (_optionalChain([options, 'optionalAccess', _ => _.timeoutMs])) {
-    await client.query(`SET statement_timeout = ${options.timeoutMs}`);
-  }
-  for (let i = 0; i < sqls.length; i++) {
-    const { query, params } = _chunkGNH5XC6Dcjs.pgFormatter.format(sqls[i], { serializer });
-    _chunk4MMMEDQ7cjs.tracer.info("db:sql:query", {
-      query,
-      params,
-      debugSQL: _chunkGNH5XC6Dcjs.pgFormatter.describe(sqls[i], { serializer })
-    });
-    try {
-      let result = params.length > 0 ? await client.query(query, params) : await client.query(query);
-      if (_optionalChain([options, 'optionalAccess', _2 => _2.mapping])) {
-        result = {
-          ...result,
-          rows: result.rows.map(
-            (row) => _chunk4MMMEDQ7cjs.mapSQLQueryResult.call(void 0, row, options.mapping)
-          )
-        };
-      }
-      results[i] = { rowCount: result.rowCount, rows: result.rows };
-    } catch (error) {
-      _chunk4MMMEDQ7cjs.tracer.error("db:sql:batch_query:execute:error", { error });
-      throw _chunkGNH5XC6Dcjs.mapPostgresError.call(void 0, error);
-    }
-  }
-  return results;
+	const results = Array(sqls.length);
+	if (options?.timeoutMs) await client.query(`SET statement_timeout = ${options.timeoutMs}`);
+	for (let i = 0; i < sqls.length; i++) {
+		const { query, params } = require_core$1.pgFormatter.format(sqls[i], { serializer });
+		require_core.tracer.info("db:sql:query", {
+			query,
+			params,
+			debugSQL: require_core$1.pgFormatter.describe(sqls[i], { serializer })
+		});
+		try {
+			let result = params.length > 0 ? await client.query(query, params) : await client.query(query);
+			if (options?.mapping) result = {
+				...result,
+				rows: result.rows.map((row) => require_core.mapSQLQueryResult(row, options.mapping))
+			};
+			results[i] = {
+				rowCount: result.rowCount,
+				rows: result.rows
+			};
+		} catch (error) {
+			require_core.tracer.error("db:sql:batch_query:execute:error", { error });
+			throw require_core$1.mapPostgresError(error);
+		}
+	}
+	return results;
 }
 async function batchCommand(client, sqls, serializer, options) {
-  const results = Array(
-    sqls.length
-  );
-  if (_optionalChain([options, 'optionalAccess', _3 => _3.timeoutMs])) {
-    await client.query(`SET statement_timeout = ${options.timeoutMs}`);
-  }
-  for (let i = 0; i < sqls.length; i++) {
-    const { query, params } = _chunkGNH5XC6Dcjs.pgFormatter.format(sqls[i], { serializer });
-    _chunk4MMMEDQ7cjs.tracer.info("db:sql:command", {
-      query,
-      params,
-      debugSQL: _chunkGNH5XC6Dcjs.pgFormatter.describe(sqls[i], { serializer })
-    });
-    try {
-      let result = params.length > 0 ? await client.query(query, params) : await client.query(query);
-      if (_optionalChain([options, 'optionalAccess', _4 => _4.mapping])) {
-        result = {
-          ...result,
-          rows: result.rows.map(
-            (row) => _chunk4MMMEDQ7cjs.mapSQLQueryResult.call(void 0, row, options.mapping)
-          )
-        };
-      }
-      results[i] = { rowCount: result.rowCount, rows: result.rows };
-      if (_optionalChain([options, 'optionalAccess', _5 => _5.assertChanges]) && (_nullishCoalesce(results[i].rowCount, () => ( 0))) === 0) {
-        throw new (0, _chunk4MMMEDQ7cjs.BatchCommandNoChangesError)(i);
-      }
-    } catch (error) {
-      _chunk4MMMEDQ7cjs.tracer.error("db:sql:batch_command:execute:error", { error });
-      throw _chunkGNH5XC6Dcjs.mapPostgresError.call(void 0, error);
-    }
-  }
-  return results;
+	const results = Array(sqls.length);
+	if (options?.timeoutMs) await client.query(`SET statement_timeout = ${options.timeoutMs}`);
+	for (let i = 0; i < sqls.length; i++) {
+		const { query, params } = require_core$1.pgFormatter.format(sqls[i], { serializer });
+		require_core.tracer.info("db:sql:command", {
+			query,
+			params,
+			debugSQL: require_core$1.pgFormatter.describe(sqls[i], { serializer })
+		});
+		try {
+			let result = params.length > 0 ? await client.query(query, params) : await client.query(query);
+			if (options?.mapping) result = {
+				...result,
+				rows: result.rows.map((row) => require_core.mapSQLQueryResult(row, options.mapping))
+			};
+			results[i] = {
+				rowCount: result.rowCount,
+				rows: result.rows
+			};
+			if (options?.assertChanges && (results[i].rowCount ?? 0) === 0) throw new require_core.BatchCommandNoChangesError(i);
+		} catch (error) {
+			require_core.tracer.error("db:sql:batch_command:execute:error", { error });
+			throw require_core$1.mapPostgresError(error);
+		}
+	}
+	return results;
 }
 
-// src/storage/postgresql/pg/connections/transaction.ts
-var pgTransaction = (connection, serializer) => (getClient, options) => ({
-  connection: connection(),
-  driverType: PgDriverType,
-  begin: async () => {
-    const client = await getClient;
-    const parts = ["BEGIN"];
-    if (_optionalChain([options, 'optionalAccess', _6 => _6.isolationLevel])) {
-      parts.push(`ISOLATION LEVEL ${options.isolationLevel}`);
-    }
-    if (_optionalChain([options, 'optionalAccess', _7 => _7.readonly])) {
-      parts.push("READ ONLY");
-    }
-    await client.query(parts.join(" "));
-  },
-  commit: async () => {
-    const client = await getClient;
-    try {
-      await client.query("COMMIT");
-    } finally {
-      if (_optionalChain([options, 'optionalAccess', _8 => _8.close])) await _optionalChain([options, 'optionalAccess', _9 => _9.close, 'call', _10 => _10(client)]);
-    }
-  },
-  rollback: async (error) => {
-    const client = await getClient;
-    try {
-      await client.query("ROLLBACK");
-    } finally {
-      if (_optionalChain([options, 'optionalAccess', _11 => _11.close])) await _optionalChain([options, 'optionalAccess', _12 => _12.close, 'call', _13 => _13(client, error)]);
-    }
-  },
-  execute: _chunk4MMMEDQ7cjs.sqlExecutor.call(void 0, pgSQLExecutor({ serializer }), {
-    connect: () => getClient
-  }),
-  _transactionOptions: _nullishCoalesce(options, () => ( {}))
+//#endregion
+//#region src/storage/postgresql/pg/connections/transaction.ts
+const pgTransaction = (connection, serializer) => (getClient, options) => ({
+	connection: connection(),
+	driverType: PgDriverType,
+	begin: async () => {
+		const client = await getClient;
+		const parts = ["BEGIN"];
+		if (options?.isolationLevel) parts.push(`ISOLATION LEVEL ${options.isolationLevel}`);
+		if (options?.readonly) parts.push("READ ONLY");
+		await client.query(parts.join(" "));
+	},
+	commit: async () => {
+		const client = await getClient;
+		try {
+			await client.query("COMMIT");
+		} finally {
+			if (options?.close) await options?.close(client);
+		}
+	},
+	rollback: async (error) => {
+		const client = await getClient;
+		try {
+			await client.query("ROLLBACK");
+		} finally {
+			if (options?.close) await options?.close(client, error);
+		}
+	},
+	execute: require_core.sqlExecutor(pgSQLExecutor({ serializer }), { connect: () => getClient }),
+	_transactionOptions: options ?? {}
 });
 
-// src/storage/postgresql/pg/connections/connection.ts
-var PgDriverType = "PostgreSQL:pg";
-var pgClientConnection = (options) => {
-  const { connect, close } = options;
-  return _chunk4MMMEDQ7cjs.createConnection.call(void 0, {
-    driverType: PgDriverType,
-    connect,
-    close,
-    initTransaction: (connection) => pgTransaction(connection, options.serializer),
-    executor: pgSQLExecutor,
-    serializer: options.serializer
-  });
+//#endregion
+//#region src/storage/postgresql/pg/connections/connection.ts
+const PgDriverType = "PostgreSQL:pg";
+const pgClientConnection = (options) => {
+	const { connect, close } = options;
+	return require_core.createConnection({
+		driverType: PgDriverType,
+		connect,
+		close,
+		initTransaction: (connection) => pgTransaction(connection, options.serializer),
+		executor: pgSQLExecutor,
+		serializer: options.serializer
+	});
 };
-var pgPoolClientConnection = (options) => {
-  const { connect, close } = options;
-  return _chunk4MMMEDQ7cjs.createConnection.call(void 0, {
-    driverType: PgDriverType,
-    connect,
-    close,
-    initTransaction: (connection) => pgTransaction(connection, options.serializer),
-    executor: pgSQLExecutor,
-    serializer: options.serializer
-  });
+const pgPoolClientConnection = (options) => {
+	const { connect, close } = options;
+	return require_core.createConnection({
+		driverType: PgDriverType,
+		connect,
+		close,
+		initTransaction: (connection) => pgTransaction(connection, options.serializer),
+		executor: pgSQLExecutor,
+		serializer: options.serializer
+	});
 };
 function pgConnection(options) {
-  return options.type === "Client" ? pgClientConnection(options) : pgPoolClientConnection(options);
+	return options.type === "Client" ? pgClientConnection(options) : pgPoolClientConnection(options);
 }
-var checkConnection = async (connectionString) => {
-  const client = new _pg2.default.Client({
-    connectionString
-  });
-  try {
-    await client.connect();
-    return { successful: true };
-  } catch (error) {
-    const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
-    return {
-      successful: false,
-      errorType: code === "ECONNREFUSED" ? "ConnectionRefused" : code === "28P01" ? "Authentication" : "Unknown",
-      code,
-      error
-    };
-  } finally {
-    await client.end();
-  }
+const checkConnection = async (connectionString) => {
+	const client = new pg.default.Client({ connectionString });
+	try {
+		await client.connect();
+		return { successful: true };
+	} catch (error) {
+		const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+		return {
+			successful: false,
+			errorType: code === "ECONNREFUSED" ? "ConnectionRefused" : code === "28P01" ? "Authentication" : "Unknown",
+			code,
+			error
+		};
+	} finally {
+		await client.end();
+	}
 };
 
-// src/storage/postgresql/pg/connections/pool.ts
-
-
-// src/storage/postgresql/pg/serialization/index.ts
-var setPgTypeParser = (client, options) => {
-  if (_optionalChain([options, 'optionalAccess', _14 => _14.parseBigInts]) === true)
-    client.setTypeParser(20, (val) => BigInt(val));
-  if (_optionalChain([options, 'optionalAccess', _15 => _15.serializer])) {
-    client.setTypeParser(3802, (val) => options.serializer.deserialize(val));
-    client.setTypeParser(114, (val) => options.serializer.deserialize(val));
-  }
+//#endregion
+//#region src/storage/postgresql/pg/serialization/index.ts
+const setPgTypeParser = (client, options) => {
+	if (options?.parseBigInts === true) client.setTypeParser(20, (val) => BigInt(val));
+	if (options?.serializer) {
+		client.setTypeParser(3802, (val) => options.serializer.deserialize(val));
+		client.setTypeParser(114, (val) => options.serializer.deserialize(val));
+	}
 };
 
-// src/storage/postgresql/pg/connections/pool.ts
-var pgNativePool = (options) => {
-  const { connectionString, database } = options;
-  const pool = getPgPool({ connectionString, database });
-  const getConnection = () => pgConnection({
-    type: "PoolClient",
-    connect: async () => {
-      const client = await pool.connect();
-      setPgTypeParser(client, {
-        parseBigInts: true,
-        serializer: options.serializer
-      });
-      return client;
-    },
-    close: (client) => Promise.resolve(client.release()),
-    serializer: options.serializer
-  });
-  const open = () => Promise.resolve(getConnection());
-  const close = () => endPgPool({ connectionString, database });
-  return _chunk4MMMEDQ7cjs.createConnectionPool.call(void 0, {
-    driverType: PgDriverType,
-    connection: open,
-    close,
-    getConnection
-  });
+//#endregion
+//#region src/storage/postgresql/pg/connections/pool.ts
+const pgNativePool = (options) => {
+	const { connectionString, database } = options;
+	const pool = getPgPool({
+		connectionString,
+		database
+	});
+	const getConnection = () => pgConnection({
+		type: "PoolClient",
+		connect: async () => {
+			const client = await pool.connect();
+			setPgTypeParser(client, {
+				parseBigInts: true,
+				serializer: options.serializer
+			});
+			return client;
+		},
+		close: (client) => Promise.resolve(client.release()),
+		serializer: options.serializer
+	});
+	const open = () => Promise.resolve(getConnection());
+	const close = () => endPgPool({
+		connectionString,
+		database
+	});
+	return require_core.createConnectionPool({
+		driverType: PgDriverType,
+		connection: open,
+		close,
+		getConnection
+	});
 };
-var pgAmbientNativePool = (options) => {
-  const { pool } = options;
-  return _chunk4MMMEDQ7cjs.createConnectionPool.call(void 0, {
-    driverType: PgDriverType,
-    getConnection: () => pgConnection({
-      type: "PoolClient",
-      connect: () => pool.connect(),
-      close: (client) => Promise.resolve(client.release()),
-      serializer: options.serializer
-    })
-  });
+const pgAmbientNativePool = (options) => {
+	const { pool } = options;
+	return require_core.createConnectionPool({
+		driverType: PgDriverType,
+		getConnection: () => pgConnection({
+			type: "PoolClient",
+			connect: () => pool.connect(),
+			close: (client) => Promise.resolve(client.release()),
+			serializer: options.serializer
+		})
+	});
 };
-var pgAmbientConnectionPool = (options) => {
-  const { connection } = options;
-  return _chunk4MMMEDQ7cjs.createAmbientConnectionPool.call(void 0, {
-    driverType: PgDriverType,
-    connection
-  });
+const pgAmbientConnectionPool = (options) => {
+	const { connection } = options;
+	return require_core.createAmbientConnectionPool({
+		driverType: PgDriverType,
+		connection
+	});
 };
-var pgClientPool = (options) => {
-  const { connectionString, database } = options;
-  return _chunk4MMMEDQ7cjs.createConnectionPool.call(void 0, {
-    driverType: PgDriverType,
-    getConnection: () => {
-      const connect = async () => {
-        const client = new _pg2.default.Client({ connectionString, database });
-        setPgTypeParser(client, {
-          parseBigInts: true,
-          serializer: options.serializer
-        });
-        await client.connect();
-        return client;
-      };
-      return pgConnection({
-        type: "Client",
-        connect,
-        close: (client) => client.end(),
-        serializer: options.serializer
-      });
-    }
-  });
+const pgClientPool = (options) => {
+	const { connectionString, database } = options;
+	return require_core.createConnectionPool({
+		driverType: PgDriverType,
+		getConnection: () => {
+			const connect = async () => {
+				const client = new pg.default.Client({
+					connectionString,
+					database
+				});
+				setPgTypeParser(client, {
+					parseBigInts: true,
+					serializer: options.serializer
+				});
+				await client.connect();
+				return client;
+			};
+			return pgConnection({
+				type: "Client",
+				connect,
+				close: (client) => client.end(),
+				serializer: options.serializer
+			});
+		}
+	});
 };
-var pgAmbientClientPool = (options) => {
-  const { client } = options;
-  const getConnection = () => {
-    const connect = () => Promise.resolve(client);
-    return pgConnection({
-      type: "Client",
-      connect,
-      close: () => Promise.resolve(),
-      serializer: options.serializer
-    });
-  };
-  const open = () => Promise.resolve(getConnection());
-  const close = () => Promise.resolve();
-  return _chunk4MMMEDQ7cjs.createConnectionPool.call(void 0, {
-    driverType: PgDriverType,
-    connection: open,
-    close,
-    getConnection
-  });
+const pgAmbientClientPool = (options) => {
+	const { client } = options;
+	const getConnection = () => {
+		const connect = () => Promise.resolve(client);
+		return pgConnection({
+			type: "Client",
+			connect,
+			close: () => Promise.resolve(),
+			serializer: options.serializer
+		});
+	};
+	const open = () => Promise.resolve(getConnection());
+	const close = () => Promise.resolve();
+	return require_core.createConnectionPool({
+		driverType: PgDriverType,
+		connection: open,
+		close,
+		getConnection
+	});
 };
 function pgPool(options) {
-  const { connectionString, database } = options;
-  const serializer = _nullishCoalesce(_optionalChain([options, 'access', _16 => _16.serialization, 'optionalAccess', _17 => _17.serializer]), () => ( _chunk4MMMEDQ7cjs.JSONSerializer));
-  if ("client" in options && options.client)
-    return pgAmbientClientPool({ client: options.client, serializer });
-  if ("connection" in options && options.connection)
-    return pgAmbientConnectionPool({
-      connection: options.connection
-    });
-  if ("pooled" in options && options.pooled === false)
-    return pgClientPool({ connectionString, database, serializer });
-  if ("pool" in options && options.pool)
-    return pgAmbientNativePool({ pool: options.pool, serializer });
-  return pgNativePool({
-    connectionString,
-    database,
-    serializer
-  });
+	const { connectionString, database } = options;
+	const serializer = options.serialization?.serializer ?? require_core.JSONSerializer;
+	if ("client" in options && options.client) return pgAmbientClientPool({
+		client: options.client,
+		serializer
+	});
+	if ("connection" in options && options.connection) return pgAmbientConnectionPool({ connection: options.connection });
+	if ("pooled" in options && options.pooled === false) return pgClientPool({
+		connectionString,
+		database,
+		serializer
+	});
+	if ("pool" in options && options.pool) return pgAmbientNativePool({
+		pool: options.pool,
+		serializer
+	});
+	return pgNativePool({
+		connectionString,
+		database,
+		serializer
+	});
 }
-var pools = /* @__PURE__ */ new Map();
-var usageCounter = /* @__PURE__ */ new Map();
-var getPgPool = (connectionStringOrOptions) => {
-  const connectionString = typeof connectionStringOrOptions === "string" ? connectionStringOrOptions : connectionStringOrOptions.connectionString;
-  const poolOptions = typeof connectionStringOrOptions === "string" ? { connectionString } : connectionStringOrOptions;
-  const database = _nullishCoalesce(poolOptions.database, () => ( (poolOptions.connectionString ? _nullishCoalesce(_chunkNJI6PJFZcjs.parseDatabaseName.call(void 0, poolOptions.connectionString), () => ( _chunkNJI6PJFZcjs.defaultPostgreSqlDatabase)) : void 0)));
-  const lookupKey = key(connectionString, database);
-  updatePoolUsageCounter(lookupKey, 1);
-  return _nullishCoalesce(pools.get(lookupKey), () => ( pools.set(lookupKey, new _pg2.default.Pool(poolOptions)).get(lookupKey)));
+const pools = /* @__PURE__ */ new Map();
+const usageCounter = /* @__PURE__ */ new Map();
+const getPgPool = (connectionStringOrOptions) => {
+	const connectionString = typeof connectionStringOrOptions === "string" ? connectionStringOrOptions : connectionStringOrOptions.connectionString;
+	const poolOptions = typeof connectionStringOrOptions === "string" ? { connectionString } : connectionStringOrOptions;
+	const lookupKey = key(connectionString, poolOptions.database ?? (poolOptions.connectionString ? require_postgreSQLMetadata.parseDatabaseName(poolOptions.connectionString) ?? "postgres" : void 0));
+	updatePoolUsageCounter(lookupKey, 1);
+	return pools.get(lookupKey) ?? pools.set(lookupKey, new pg.default.Pool(poolOptions)).get(lookupKey);
 };
-var endPgPool = async ({
-  connectionString,
-  database,
-  force
-}) => {
-  database = _nullishCoalesce(_nullishCoalesce(database, () => ( _chunkNJI6PJFZcjs.parseDatabaseName.call(void 0, connectionString))), () => ( void 0));
-  const lookupKey = key(connectionString, database);
-  const pool = pools.get(lookupKey);
-  if (pool && (updatePoolUsageCounter(lookupKey, -1) <= 0 || force === true)) {
-    await onEndPool(lookupKey, pool);
-  }
+const endPgPool = async ({ connectionString, database, force }) => {
+	database = database ?? require_postgreSQLMetadata.parseDatabaseName(connectionString) ?? void 0;
+	const lookupKey = key(connectionString, database);
+	const pool = pools.get(lookupKey);
+	if (pool && (updatePoolUsageCounter(lookupKey, -1) <= 0 || force === true)) await onEndPool(lookupKey, pool);
 };
-var onEndPool = async (lookupKey, pool) => {
-  try {
-    await pool.end();
-  } catch (error) {
-    _chunk4MMMEDQ7cjs.tracer.error("connection-closing-error", { lookupKey, error });
-  }
-  pools.delete(lookupKey);
+const onEndPool = async (lookupKey, pool) => {
+	try {
+		await pool.end();
+	} catch (error) {
+		require_core.tracer.error("connection-closing-error", {
+			lookupKey,
+			error
+		});
+	}
+	pools.delete(lookupKey);
 };
-var endAllPgPools = () => Promise.all(
-  [...pools.entries()].map(([lookupKey, pool]) => onEndPool(lookupKey, pool))
-);
-var key = (connectionString, database) => `${connectionString}|${_nullishCoalesce(database, () => ( _chunkNJI6PJFZcjs.defaultPostgreSqlDatabase))}`;
-var updatePoolUsageCounter = (lookupKey, by) => {
-  const currentCounter = _nullishCoalesce(usageCounter.get(lookupKey), () => ( 0));
-  const newCounter = currentCounter + by;
-  usageCounter.set(lookupKey, currentCounter + by);
-  return newCounter;
+const endAllPgPools = () => Promise.all([...pools.entries()].map(([lookupKey, pool]) => onEndPool(lookupKey, pool)));
+const key = (connectionString, database) => `${connectionString}|${database ?? "postgres"}`;
+const updatePoolUsageCounter = (lookupKey, by) => {
+	const currentCounter = usageCounter.get(lookupKey) ?? 0;
+	const newCounter = currentCounter + by;
+	usageCounter.set(lookupKey, currentCounter + by);
+	return newCounter;
 };
 
-// src/storage/postgresql/pg/index.ts
-var tryParseConnectionString = (connectionString) => {
-  try {
-    return _chunkNJI6PJFZcjs.PostgreSQLConnectionString.call(void 0, connectionString);
-  } catch (e) {
-    return null;
-  }
+//#endregion
+//#region src/storage/postgresql/pg/index.ts
+const tryParseConnectionString = (connectionString) => {
+	try {
+		return require_postgreSQLMetadata.PostgreSQLConnectionString(connectionString);
+	} catch {
+		return null;
+	}
 };
-var pgDumboDriver = {
-  driverType: PgDriverType,
-  createPool: (options) => pgPool(options),
-  sqlFormatter: _chunkGNH5XC6Dcjs.pgFormatter,
-  defaultMigratorOptions: _chunkGNH5XC6Dcjs.DefaultPostgreSQLMigratorOptions,
-  canHandle: _chunk4MMMEDQ7cjs.canHandleDriverWithConnectionString.call(void 0, 
-    PgDriverType,
-    tryParseConnectionString
-  ),
-  databaseMetadata: _chunkNJI6PJFZcjs.postgreSQLMetadata
+const pgDumboDriver = {
+	driverType: PgDriverType,
+	createPool: (options) => pgPool(options),
+	sqlFormatter: require_core$1.pgFormatter,
+	defaultMigratorOptions: require_core$1.DefaultPostgreSQLMigratorOptions,
+	canHandle: require_core.canHandleDriverWithConnectionString(PgDriverType, tryParseConnectionString),
+	databaseMetadata: require_postgreSQLMetadata.postgreSQLMetadata
 };
-var usePgDumboDriver = () => {
-  _chunk4MMMEDQ7cjs.dumboDatabaseDriverRegistry.register(PgDriverType, pgDumboDriver);
+const usePgDumboDriver = () => {
+	require_core.dumboDatabaseDriverRegistry.register(PgDriverType, pgDumboDriver);
 };
 usePgDumboDriver();
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.AdvisoryLock = _chunkGNH5XC6Dcjs.AdvisoryLock; exports.DefaultPostgreSQLMigratorOptions = _chunkGNH5XC6Dcjs.DefaultPostgreSQLMigratorOptions; exports.PgDriverType = PgDriverType; exports.PostgreSQLArrayProcessor = _chunkGNH5XC6Dcjs.PostgreSQLArrayProcessor; exports.PostgreSQLConnectionString = _chunkNJI6PJFZcjs.PostgreSQLConnectionString; exports.PostgreSQLDatabaseName = _chunkGNH5XC6Dcjs.PostgreSQLDatabaseName; exports.PostgreSQLExpandSQLInProcessor = _chunkGNH5XC6Dcjs.PostgreSQLExpandSQLInProcessor; exports.acquireAdvisoryLock = _chunkGNH5XC6Dcjs.acquireAdvisoryLock; exports.advisoryLock = _chunkGNH5XC6Dcjs.advisoryLock; exports.checkConnection = checkConnection; exports.defaultPostgreSQLConnectionString = _chunkNJI6PJFZcjs.defaultPostgreSQLConnectionString; exports.defaultPostgreSqlDatabase = _chunkNJI6PJFZcjs.defaultPostgreSqlDatabase; exports.endAllPgPools = endAllPgPools; exports.endPgPool = endPgPool; exports.functionExists = _chunkNJI6PJFZcjs.functionExists; exports.functionExistsSQL = _chunkNJI6PJFZcjs.functionExistsSQL; exports.getPgPool = getPgPool; exports.isPgClient = isPgClient; exports.isPgNativePool = isPgNativePool; exports.isPgPoolClient = isPgPoolClient; exports.mapPostgresError = _chunkGNH5XC6Dcjs.mapPostgresError; exports.onEndPool = onEndPool; exports.parseDatabaseName = _chunkNJI6PJFZcjs.parseDatabaseName; exports.pgAmbientClientPool = pgAmbientClientPool; exports.pgAmbientConnectionPool = pgAmbientConnectionPool; exports.pgAmbientNativePool = pgAmbientNativePool; exports.pgClientConnection = pgClientConnection; exports.pgClientPool = pgClientPool; exports.pgConnection = pgConnection; exports.pgDumboDriver = pgDumboDriver; exports.pgExecute = pgExecute; exports.pgFormatter = _chunkGNH5XC6Dcjs.pgFormatter; exports.pgNativePool = pgNativePool; exports.pgPool = pgPool; exports.pgPoolClientConnection = pgPoolClientConnection; exports.pgSQLExecutor = pgSQLExecutor; exports.pgTransaction = pgTransaction; exports.postgreSQLColumnProcessors = _chunkGNH5XC6Dcjs.postgreSQLColumnProcessors; exports.postgreSQLMetadata = _chunkNJI6PJFZcjs.postgreSQLMetadata; exports.releaseAdvisoryLock = _chunkGNH5XC6Dcjs.releaseAdvisoryLock; exports.setPgTypeParser = setPgTypeParser; exports.tableExists = _chunkNJI6PJFZcjs.tableExists; exports.tableExistsSQL = _chunkNJI6PJFZcjs.tableExistsSQL; exports.tryAcquireAdvisoryLock = _chunkGNH5XC6Dcjs.tryAcquireAdvisoryLock; exports.usePgDumboDriver = usePgDumboDriver;
+//#endregion
+exports.AdvisoryLock = require_core$1.AdvisoryLock;
+exports.DefaultPostgreSQLMigratorOptions = require_core$1.DefaultPostgreSQLMigratorOptions;
+exports.PgDriverType = PgDriverType;
+exports.PostgreSQLArrayProcessor = require_core$1.PostgreSQLArrayProcessor;
+exports.PostgreSQLConnectionString = require_postgreSQLMetadata.PostgreSQLConnectionString;
+exports.PostgreSQLDatabaseName = require_core$1.PostgreSQLDatabaseName;
+exports.PostgreSQLExpandSQLInProcessor = require_core$1.PostgreSQLExpandSQLInProcessor;
+exports.acquireAdvisoryLock = require_core$1.acquireAdvisoryLock;
+exports.advisoryLock = require_core$1.advisoryLock;
+exports.checkConnection = checkConnection;
+exports.defaultPostgreSQLConnectionString = require_postgreSQLMetadata.defaultPostgreSQLConnectionString;
+exports.defaultPostgreSqlDatabase = require_postgreSQLMetadata.defaultPostgreSqlDatabase;
+exports.endAllPgPools = endAllPgPools;
+exports.endPgPool = endPgPool;
+exports.functionExists = require_postgreSQLMetadata.functionExists;
+exports.functionExistsSQL = require_postgreSQLMetadata.functionExistsSQL;
+exports.getPgPool = getPgPool;
+exports.isPgClient = isPgClient;
+exports.isPgNativePool = isPgNativePool;
+exports.isPgPoolClient = isPgPoolClient;
+exports.mapPostgresError = require_core$1.mapPostgresError;
+exports.onEndPool = onEndPool;
+exports.parseDatabaseName = require_postgreSQLMetadata.parseDatabaseName;
+exports.pgAmbientClientPool = pgAmbientClientPool;
+exports.pgAmbientConnectionPool = pgAmbientConnectionPool;
+exports.pgAmbientNativePool = pgAmbientNativePool;
+exports.pgClientConnection = pgClientConnection;
+exports.pgClientPool = pgClientPool;
+exports.pgConnection = pgConnection;
+exports.pgDumboDriver = pgDumboDriver;
+exports.pgExecute = pgExecute;
+exports.pgFormatter = require_core$1.pgFormatter;
+exports.pgNativePool = pgNativePool;
+exports.pgPool = pgPool;
+exports.pgPoolClientConnection = pgPoolClientConnection;
+exports.pgSQLExecutor = pgSQLExecutor;
+exports.pgTransaction = pgTransaction;
+exports.postgreSQLColumnProcessors = require_core$1.postgreSQLColumnProcessors;
+exports.postgreSQLMetadata = require_postgreSQLMetadata.postgreSQLMetadata;
+exports.releaseAdvisoryLock = require_core$1.releaseAdvisoryLock;
+exports.setPgTypeParser = setPgTypeParser;
+exports.tableExists = require_postgreSQLMetadata.tableExists;
+exports.tableExistsSQL = require_postgreSQLMetadata.tableExistsSQL;
+exports.tryAcquireAdvisoryLock = require_core$1.tryAcquireAdvisoryLock;
+exports.usePgDumboDriver = usePgDumboDriver;
 //# sourceMappingURL=pg.cjs.map