@event-driven-io/dumbo 0.13.0-beta.4 → 0.13.0-beta.41

package/dist/pg.js

@@ -1,688 +1,356 @@
-import {
-  JSONSerializer,
-  SQL,
-  SQLFormatter,
-  SQLProcessorsRegistry,
-  canHandleDriverWithConnectionString,
-  createAmbientConnectionPool,
-  createConnection,
-  createConnectionPool,
-  defaultDatabaseLockOptions,
-  defaultProcessorsRegistry,
-  dumboDatabaseDriverRegistry,
-  exists,
-  mapDefaultSQLColumnProcessors,
-  mapSQLIdentifier,
-  registerDefaultMigratorOptions,
-  registerFormatter,
-  single,
-  sqlExecutor,
-  tracer
-} from "./chunk-N7RWT46K.js";
-
-// src/storage/postgresql/core/connections/connectionString.ts
-import pgcs from "pg-connection-string";
-
-// src/storage/postgresql/core/locks/advisoryLocks.ts
-var tryAcquireAdvisoryLock = async (execute, options) => {
-  const timeoutMs = options.timeoutMs ?? defaultDatabaseLockOptions.timeoutMs;
-  const advisoryLock2 = options.mode === "Permanent" ? "pg_advisory_lock" : "pg_advisory_xact_lock";
-  try {
-    await single(
-      execute.query(
-        SQL`SELECT ${SQL.plain(advisoryLock2)}(${options.lockId}) AS locked`,
-        { timeoutMs }
-      )
-    );
-    return true;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "57014")
-      return false;
-    throw error;
-  }
-};
-var releaseAdvisoryLock = async (execute, options) => {
-  const timeoutMs = options.timeoutMs ?? defaultDatabaseLockOptions.timeoutMs;
-  try {
-    await single(
-      execute.query(
-        SQL`SELECT pg_advisory_unlock(${options.lockId}) AS locked`,
-        { timeoutMs }
-      )
-    );
-    return true;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "57014")
-      return false;
-    throw error;
-  }
-};
-var acquireAdvisoryLock = async (execute, options) => {
-  const lockAcquired = await tryAcquireAdvisoryLock(execute, options);
-  if (!lockAcquired) {
-    throw new Error(
-      "Failed to acquire advisory lock within the specified timeout. Migration aborted."
-    );
-  }
-};
-var AdvisoryLock = {
-  acquire: acquireAdvisoryLock,
-  tryAcquire: tryAcquireAdvisoryLock,
-  release: releaseAdvisoryLock,
-  withAcquire: async (execute, handle, options) => {
-    await acquireAdvisoryLock(execute, options);
-    try {
-      return await handle();
-    } finally {
-      if (options.mode === "Permanent")
-        await releaseAdvisoryLock(execute, options);
-    }
-  }
-};
-var advisoryLock = (execute, options) => ({
-  acquire: (acquireOptions) => acquireAdvisoryLock(execute, {
-    ...options,
-    ...acquireOptions ?? {}
-  }),
-  tryAcquire: (acquireOptions) => tryAcquireAdvisoryLock(execute, {
-    ...options,
-    ...acquireOptions ?? {}
-  }),
-  release: () => releaseAdvisoryLock(execute, options),
-  withAcquire: async (handle, acquireOptions) => {
-    await acquireAdvisoryLock(execute, {
-      ...options,
-      ...acquireOptions ?? {}
-    });
-    try {
-      return await handle();
-    } finally {
-      await releaseAdvisoryLock(execute, options);
-    }
-  }
-});
-
-// src/storage/postgresql/core/schema/migrations.ts
-var DefaultPostgreSQLMigratorOptions = {
-  lock: {
-    databaseLock: AdvisoryLock
-  }
-};
-registerDefaultMigratorOptions("PostgreSQL", DefaultPostgreSQLMigratorOptions);
-
-// src/storage/postgresql/core/schema/schema.ts
-var defaultPostgreSqlDatabase = "postgres";
-var tableExistsSQL = (tableName) => SQL`
-  SELECT EXISTS (
-    SELECT FROM pg_tables
-    WHERE tablename = ${tableName}
-  ) AS exists;`;
-var tableExists = async (pool, tableName) => exists(pool.execute.query(tableExistsSQL(tableName)));
-var functionExistsSQL = (functionName) => SQL`
-      SELECT EXISTS (
-        SELECT FROM pg_proc
-        WHERE
-        proname = ${functionName}
-      ) AS exists;`;
-var functionExists = async (pool, tableName) => exists(pool.execute.query(functionExistsSQL(tableName)));
-
-// src/storage/postgresql/core/connections/connectionString.ts
-var defaultPostgreSQLConnectionString = "postgresql://postgres@localhost:5432/postgres";
-var getDatabaseNameOrDefault = (connectionString) => pgcs.parse(connectionString).database ?? defaultPostgreSqlDatabase;
-var PostgreSQLConnectionString = (connectionString) => {
-  if (!connectionString.startsWith("postgresql://") && !connectionString.startsWith("postgres://")) {
-    throw new Error(
-      `Invalid PostgreSQL connection string: ${connectionString}. It should start with "postgresql://".`
-    );
-  }
-  return connectionString;
-};
-
-// src/storage/postgresql/core/sql/processors/columProcessors.ts
-var mapColumnType = (token, { builder }) => {
-  let columnSQL;
-  const { sqlTokenType } = token;
-  switch (sqlTokenType) {
-    case "SQL_COLUMN_AUTO_INCREMENT":
-      columnSQL = `${token.bigint ? "BIGSERIAL" : "SERIAL"} ${token.primaryKey ? "PRIMARY KEY" : ""}`;
-      break;
-    case "SQL_COLUMN_BIGINT":
-      columnSQL = "BIGINT";
-      break;
-    case "SQL_COLUMN_SERIAL":
-      columnSQL = "SERIAL";
-      break;
-    case "SQL_COLUMN_INTEGER":
-      columnSQL = "INTEGER";
-      break;
-    case "SQL_COLUMN_JSONB":
-      columnSQL = "JSONB";
-      break;
-    case "SQL_COLUMN_BIGSERIAL":
-      columnSQL = "BIGSERIAL";
-      break;
-    case "SQL_COLUMN_TIMESTAMP":
-      columnSQL = "TIMESTAMP";
-      break;
-    case "SQL_COLUMN_TIMESTAMPTZ":
-      columnSQL = "TIMESTAMPTZ";
-      break;
-    case "SQL_COLUMN_VARCHAR":
-      columnSQL = `VARCHAR ${Number.isNaN(token.length) ? "" : `(${token.length})`}`;
-      break;
-    default: {
-      const exhaustiveCheck = sqlTokenType;
-      throw new Error(`Unknown column type: ${exhaustiveCheck}`);
-    }
-  }
-  builder.addSQL(columnSQL);
-};
-var postgreSQLColumnProcessors = mapDefaultSQLColumnProcessors(mapColumnType);
-
-// src/storage/postgresql/core/sql/formatter/reserved.ts
-var reservedMap = {
-  AES128: true,
-  AES256: true,
-  ALL: true,
-  ALLOWOVERWRITE: true,
-  ANALYSE: true,
-  ANALYZE: true,
-  AND: true,
-  ANY: true,
-  ARRAY: true,
-  AS: true,
-  ASC: true,
-  AUTHORIZATION: true,
-  BACKUP: true,
-  BETWEEN: true,
-  BINARY: true,
-  BLANKSASNULL: true,
-  BOTH: true,
-  BYTEDICT: true,
-  CASE: true,
-  CAST: true,
-  CHECK: true,
-  COLLATE: true,
-  COLUMN: true,
-  CONSTRAINT: true,
-  CREATE: true,
-  CREDENTIALS: true,
-  CROSS: true,
-  CURRENT_DATE: true,
-  CURRENT_TIME: true,
-  CURRENT_TIMESTAMP: true,
-  CURRENT_USER: true,
-  CURRENT_USER_ID: true,
-  DEFAULT: true,
-  DEFERRABLE: true,
-  DEFLATE: true,
-  DEFRAG: true,
-  DELTA: true,
-  DELTA32K: true,
-  DESC: true,
-  DISABLE: true,
-  DISTINCT: true,
-  DO: true,
-  ELSE: true,
-  EMPTYASNULL: true,
-  ENABLE: true,
-  ENCODE: true,
-  ENCRYPT: true,
-  ENCRYPTION: true,
-  END: true,
-  EXCEPT: true,
-  EXPLICIT: true,
-  FALSE: true,
-  FOR: true,
-  FOREIGN: true,
-  FREEZE: true,
-  FROM: true,
-  FULL: true,
-  GLOBALDICT256: true,
-  GLOBALDICT64K: true,
-  GRANT: true,
-  GROUP: true,
-  GZIP: true,
-  HAVING: true,
-  IDENTITY: true,
-  IGNORE: true,
-  ILIKE: true,
-  IN: true,
-  INITIALLY: true,
-  INNER: true,
-  INTERSECT: true,
-  INTO: true,
-  IS: true,
-  ISNULL: true,
-  JOIN: true,
-  LEADING: true,
-  LEFT: true,
-  LIKE: true,
-  LIMIT: true,
-  LOCALTIME: true,
-  LOCALTIMESTAMP: true,
-  LUN: true,
-  LUNS: true,
-  LZO: true,
-  LZOP: true,
-  MINUS: true,
-  MOSTLY13: true,
-  MOSTLY32: true,
-  MOSTLY8: true,
-  NATURAL: true,
-  NEW: true,
-  NOT: true,
-  NOTNULL: true,
-  NULL: true,
-  NULLS: true,
-  OFF: true,
-  OFFLINE: true,
-  OFFSET: true,
-  OLD: true,
-  ON: true,
-  ONLY: true,
-  OPEN: true,
-  OR: true,
-  ORDER: true,
-  OUTER: true,
-  OVERLAPS: true,
-  PARALLEL: true,
-  PARTITION: true,
-  PERCENT: true,
-  PLACING: true,
-  PRIMARY: true,
-  RAW: true,
-  READRATIO: true,
-  RECOVER: true,
-  REFERENCES: true,
-  REJECTLOG: true,
-  RESORT: true,
-  RESTORE: true,
-  RIGHT: true,
-  SELECT: true,
-  SESSION_USER: true,
-  SIMILAR: true,
-  SOME: true,
-  SYSDATE: true,
-  SYSTEM: true,
-  TABLE: true,
-  TAG: true,
-  TDES: true,
-  TEXT255: true,
-  TEXT32K: true,
-  THEN: true,
-  TO: true,
-  TOP: true,
-  TRAILING: true,
-  TRUE: true,
-  TRUNCATECOLUMNS: true,
-  UNION: true,
-  UNIQUE: true,
-  USER: true,
-  USING: true,
-  VERBOSE: true,
-  WALLET: true,
-  WHEN: true,
-  WHERE: true,
-  WITH: true,
-  WITHOUT: true
-};
-var reserved_default = reservedMap;
-
-// src/storage/postgresql/core/sql/formatter/index.ts
-var postgreSQLProcessorsRegistry = SQLProcessorsRegistry({
-  from: defaultProcessorsRegistry
-}).register(postgreSQLColumnProcessors);
-var pgFormatter = SQLFormatter({
-  processorsRegistry: postgreSQLProcessorsRegistry,
-  valueMapper: {
-    mapDate: (value) => value.toISOString().replace("T", " ").replace("Z", "+00"),
-    mapPlaceholder: (index) => `$${index + 1}`,
-    mapIdentifier: (value) => mapSQLIdentifier(value, { reservedWords: reserved_default })
-  }
-});
-registerFormatter("PostgreSQL", pgFormatter);
-
-// src/storage/postgresql/core/index.ts
-var PostgreSQLDatabaseName = "PostgreSQL";
-
-// src/storage/postgresql/pg/connections/connection.ts
-import pg2 from "pg";
-
-// src/storage/postgresql/pg/execute/execute.ts
+import { E as sqlExecutor, On as canHandleDriverWithConnectionString, T as mapSQLQueryResult, i as createConnectionPool, in as JSONSerializer, it as tracer, kn as dumboDatabaseDriverRegistry, n as createAmbientConnectionPool, u as createConnection, v as BatchCommandNoChangesError } from "./core-BMeDuqBQ.js";
+import { a as tableExists, c as defaultPostgreSQLConnectionString, i as functionExistsSQL, l as parseDatabaseName, n as defaultPostgreSqlDatabase, o as tableExistsSQL, r as functionExists, s as PostgreSQLConnectionString, t as postgreSQLMetadata } from "./postgreSQLMetadata-Khf1e9CT.js";
+import { a as PostgreSQLExpandSQLInProcessor, c as acquireAdvisoryLock, d as tryAcquireAdvisoryLock, f as mapPostgresError, i as PostgreSQLArrayProcessor, l as advisoryLock, n as pgFormatter, o as DefaultPostgreSQLMigratorOptions, r as postgreSQLColumnProcessors, s as AdvisoryLock, t as PostgreSQLDatabaseName, u as releaseAdvisoryLock } from "./core-BPNgo5b6.js";
 import pg from "pg";
-var isNodePostgresNativePool = (poolOrClient) => {
-  return poolOrClient instanceof pg.Pool;
+
+//#region src/storage/postgresql/pg/execute/execute.ts
+const isPgNativePool = (poolOrClient) => {
+	return poolOrClient instanceof pg.Pool;
 };
-var isNodePostgresClient = (poolOrClient) => poolOrClient instanceof pg.Client;
-var isNodePostgresPoolClient = (poolOrClient) => "release" in poolOrClient && typeof poolOrClient.release === "function";
-var nodePostgresExecute = async (poolOrClient, handle) => {
-  const client = isNodePostgresNativePool(poolOrClient) ? await poolOrClient.connect() : poolOrClient;
-  try {
-    return await handle(client);
-  } finally {
-    if (isNodePostgresNativePool(poolOrClient) && isNodePostgresPoolClient(client))
-      client.release();
-  }
+const isPgClient = (poolOrClient) => poolOrClient instanceof pg.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 nodePostgresSQLExecutor = () => ({
-  driverType: NodePostgresDriverType,
-  query: batch,
-  batchQuery: batch,
-  command: batch,
-  batchCommand: batch,
-  formatter: 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: pgFormatter
 });
-async function batch(client, sqlOrSqls, options) {
-  const sqls = Array.isArray(sqlOrSqls) ? sqlOrSqls : [sqlOrSqls];
-  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 } = pgFormatter.format(sqls[i]);
-    tracer.info("db:sql:query", {
-      query,
-      params,
-      debugSQL: pgFormatter.describe(sqls[i])
-    });
-    const result = await client.query(query, params);
-    results[i] = { rowCount: result.rowCount, rows: result.rows };
-  }
-  return Array.isArray(sqlOrSqls) ? results : results[0];
+async function batchQuery(client, sqls, serializer, options) {
+	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 } = pgFormatter.format(sqls[i], { serializer });
+		tracer.info("db:sql:query", {
+			query,
+			params,
+			debugSQL: 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) => mapSQLQueryResult(row, options.mapping))
+			};
+			results[i] = {
+				rowCount: result.rowCount,
+				rows: result.rows
+			};
+		} catch (error) {
+			tracer.error("db:sql:batch_query:execute:error", { error });
+			throw mapPostgresError(error);
+		}
+	}
+	return results;
+}
+async function batchCommand(client, sqls, serializer, options) {
+	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 } = pgFormatter.format(sqls[i], { serializer });
+		tracer.info("db:sql:command", {
+			query,
+			params,
+			debugSQL: 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) => mapSQLQueryResult(row, options.mapping))
+			};
+			results[i] = {
+				rowCount: result.rowCount,
+				rows: result.rows
+			};
+			if (options?.assertChanges && (results[i].rowCount ?? 0) === 0) throw new BatchCommandNoChangesError(i);
+		} catch (error) {
+			tracer.error("db:sql:batch_command:execute:error", { error });
+			throw mapPostgresError(error);
+		}
+	}
+	return results;
 }
 
-// src/storage/postgresql/pg/connections/transaction.ts
-var nodePostgresTransaction = (connection) => (getClient, options) => ({
-  connection: connection(),
-  driverType: NodePostgresDriverType,
-  begin: async () => {
-    const client = await getClient;
-    await client.query("BEGIN");
-  },
-  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: sqlExecutor(nodePostgresSQLExecutor(), {
-    connect: () => getClient
-  })
+//#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: sqlExecutor(pgSQLExecutor({ serializer }), { connect: () => getClient }),
+	_transactionOptions: options ?? {}
 });
 
-// src/storage/postgresql/pg/connections/connection.ts
-var NodePostgresDriverType = "PostgreSQL:pg";
-var nodePostgresClientConnection = (options) => {
-  const { connect, close } = options;
-  return createConnection({
-    driverType: NodePostgresDriverType,
-    connect,
-    close,
-    initTransaction: (connection) => nodePostgresTransaction(connection),
-    executor: nodePostgresSQLExecutor
-  });
+//#endregion
+//#region src/storage/postgresql/pg/connections/connection.ts
+const PgDriverType = "PostgreSQL:pg";
+const pgClientConnection = (options) => {
+	const { connect, close } = options;
+	return createConnection({
+		driverType: PgDriverType,
+		connect,
+		close,
+		initTransaction: (connection) => pgTransaction(connection, options.serializer),
+		executor: pgSQLExecutor,
+		serializer: options.serializer
+	});
 };
-var nodePostgresPoolClientConnection = (options) => {
-  const { connect, close } = options;
-  return createConnection({
-    driverType: NodePostgresDriverType,
-    connect,
-    close,
-    initTransaction: (connection) => nodePostgresTransaction(connection),
-    executor: nodePostgresSQLExecutor
-  });
+const pgPoolClientConnection = (options) => {
+	const { connect, close } = options;
+	return createConnection({
+		driverType: PgDriverType,
+		connect,
+		close,
+		initTransaction: (connection) => pgTransaction(connection, options.serializer),
+		executor: pgSQLExecutor,
+		serializer: options.serializer
+	});
 };
-function nodePostgresConnection(options) {
-  return options.type === "Client" ? nodePostgresClientConnection(options) : nodePostgresPoolClientConnection(options);
+function pgConnection(options) {
+	return options.type === "Client" ? pgClientConnection(options) : pgPoolClientConnection(options);
 }
-var checkConnection = async (connectionString) => {
-  const client = new pg2.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.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
-import pg4 from "pg";
-
-// src/storage/postgresql/pg/serialization/index.ts
-import pg3 from "pg";
-var setNodePostgresTypeParser = (jsonSerializer) => {
-  pg3.types.setTypeParser(20, (val) => BigInt(val));
-  pg3.types.setTypeParser(3802, (val) => jsonSerializer.deserialize(val));
-  pg3.types.setTypeParser(114, (val) => jsonSerializer.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 nodePostgresNativePool = (options) => {
-  const { connectionString, database } = options;
-  const pool = getPool({ connectionString, database });
-  const getConnection = () => nodePostgresConnection({
-    type: "PoolClient",
-    connect: () => pool.connect(),
-    close: (client) => Promise.resolve(client.release())
-  });
-  const open = () => Promise.resolve(getConnection());
-  const close = () => endPool({ connectionString, database });
-  return createConnectionPool({
-    driverType: NodePostgresDriverType,
-    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 createConnectionPool({
+		driverType: PgDriverType,
+		connection: open,
+		close,
+		getConnection
+	});
 };
-var nodePostgresAmbientNativePool = (options) => {
-  const { pool } = options;
-  return createConnectionPool({
-    driverType: NodePostgresDriverType,
-    getConnection: () => nodePostgresConnection({
-      type: "PoolClient",
-      connect: () => pool.connect(),
-      close: (client) => Promise.resolve(client.release())
-    })
-  });
+const pgAmbientNativePool = (options) => {
+	const { pool } = options;
+	return createConnectionPool({
+		driverType: PgDriverType,
+		getConnection: () => pgConnection({
+			type: "PoolClient",
+			connect: () => pool.connect(),
+			close: (client) => Promise.resolve(client.release()),
+			serializer: options.serializer
+		})
+	});
 };
-var nodePostgresAmbientConnectionPool = (options) => {
-  const { connection } = options;
-  return createAmbientConnectionPool({
-    driverType: NodePostgresDriverType,
-    connection
-  });
+const pgAmbientConnectionPool = (options) => {
+	const { connection } = options;
+	return createAmbientConnectionPool({
+		driverType: PgDriverType,
+		connection
+	});
 };
-var nodePostgresClientPool = (options) => {
-  const { connectionString, database } = options;
-  return createConnectionPool({
-    driverType: NodePostgresDriverType,
-    getConnection: () => {
-      const connect = async () => {
-        const client = new pg4.Client({ connectionString, database });
-        await client.connect();
-        return client;
-      };
-      return nodePostgresConnection({
-        type: "Client",
-        connect,
-        close: (client) => client.end()
-      });
-    }
-  });
+const pgClientPool = (options) => {
+	const { connectionString, database } = options;
+	return createConnectionPool({
+		driverType: PgDriverType,
+		getConnection: () => {
+			const connect = async () => {
+				const client = new pg.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 nodePostgresAmbientClientPool = (options) => {
-  const { client } = options;
-  const getConnection = () => {
-    const connect = () => Promise.resolve(client);
-    return nodePostgresConnection({
-      type: "Client",
-      connect,
-      close: () => Promise.resolve()
-    });
-  };
-  const open = () => Promise.resolve(getConnection());
-  const close = () => Promise.resolve();
-  return createConnectionPool({
-    driverType: NodePostgresDriverType,
-    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 createConnectionPool({
+		driverType: PgDriverType,
+		connection: open,
+		close,
+		getConnection
+	});
 };
-function nodePostgresPool(options) {
-  const { connectionString, database, serializer } = options;
-  setNodePostgresTypeParser(serializer ?? JSONSerializer);
-  if ("client" in options && options.client)
-    return nodePostgresAmbientClientPool({ client: options.client });
-  if ("connection" in options && options.connection)
-    return nodePostgresAmbientConnectionPool({
-      connection: options.connection
-    });
-  if ("pooled" in options && options.pooled === false)
-    return nodePostgresClientPool({ connectionString, database });
-  if ("pool" in options && options.pool)
-    return nodePostgresAmbientNativePool({ pool: options.pool });
-  return nodePostgresNativePool({
-    connectionString,
-    database
-  });
+function pgPool(options) {
+	const { connectionString, database } = options;
+	const serializer = options.serialization?.serializer ?? 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 getPool = (connectionStringOrOptions) => {
-  const connectionString = typeof connectionStringOrOptions === "string" ? connectionStringOrOptions : connectionStringOrOptions.connectionString;
-  const poolOptions = typeof connectionStringOrOptions === "string" ? { connectionString } : connectionStringOrOptions;
-  const database = poolOptions.database ?? (poolOptions.connectionString ? getDatabaseNameOrDefault(poolOptions.connectionString) : void 0);
-  const lookupKey = key(connectionString, database);
-  updatePoolUsageCounter(lookupKey, 1);
-  return pools.get(lookupKey) ?? pools.set(lookupKey, new pg4.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 ? parseDatabaseName(poolOptions.connectionString) ?? "postgres" : void 0));
+	updatePoolUsageCounter(lookupKey, 1);
+	return pools.get(lookupKey) ?? pools.set(lookupKey, new pg.Pool(poolOptions)).get(lookupKey);
 };
-var endPool = async ({
-  connectionString,
-  database,
-  force
-}) => {
-  database = database ?? getDatabaseNameOrDefault(connectionString);
-  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 ?? 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) {
-    tracer.error("connection-closing-error", { lookupKey, error });
-  }
-  pools.delete(lookupKey);
+const onEndPool = async (lookupKey, pool) => {
+	try {
+		await pool.end();
+	} catch (error) {
+		tracer.error("connection-closing-error", {
+			lookupKey,
+			error
+		});
+	}
+	pools.delete(lookupKey);
 };
-var endAllPools = () => Promise.all(
-  [...pools.entries()].map(([lookupKey, pool]) => onEndPool(lookupKey, pool))
-);
-var key = (connectionString, database) => `${connectionString}|${database ?? defaultPostgreSqlDatabase}`;
-var updatePoolUsageCounter = (lookupKey, by) => {
-  const currentCounter = 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 PostgreSQLConnectionString(connectionString);
-  } catch {
-    return null;
-  }
-};
-var pgDatabaseDriver = {
-  driverType: NodePostgresDriverType,
-  createPool: (options) => nodePostgresPool(options),
-  sqlFormatter: pgFormatter,
-  defaultMigratorOptions: DefaultPostgreSQLMigratorOptions,
-  getDatabaseNameOrDefault,
-  canHandle: canHandleDriverWithConnectionString(
-    NodePostgresDriverType,
-    tryParseConnectionString
-  )
+//#endregion
+//#region src/storage/postgresql/pg/index.ts
+const tryParseConnectionString = (connectionString) => {
+	try {
+		return PostgreSQLConnectionString(connectionString);
+	} catch {
+		return null;
+	}
 };
-var usePgDatabaseDriver = () => {
-  dumboDatabaseDriverRegistry.register(
-    NodePostgresDriverType,
-    pgDatabaseDriver
-  );
+const pgDumboDriver = {
+	driverType: PgDriverType,
+	createPool: (options) => pgPool(options),
+	sqlFormatter: pgFormatter,
+	defaultMigratorOptions: DefaultPostgreSQLMigratorOptions,
+	canHandle: canHandleDriverWithConnectionString(PgDriverType, tryParseConnectionString),
+	databaseMetadata: postgreSQLMetadata
 };
-usePgDatabaseDriver();
-var postgresPool = nodePostgresPool;
-var connectionPool = postgresPool;
-export {
-  AdvisoryLock,
-  DefaultPostgreSQLMigratorOptions,
-  NodePostgresDriverType,
-  PostgreSQLConnectionString,
-  PostgreSQLDatabaseName,
-  acquireAdvisoryLock,
-  advisoryLock,
-  checkConnection,
-  connectionPool,
-  pgDatabaseDriver as databaseDriver,
-  defaultPostgreSQLConnectionString,
-  defaultPostgreSqlDatabase,
-  endAllPools,
-  endPool,
-  functionExists,
-  functionExistsSQL,
-  getDatabaseNameOrDefault,
-  getPool,
-  isNodePostgresClient,
-  isNodePostgresNativePool,
-  isNodePostgresPoolClient,
-  nodePostgresAmbientClientPool,
-  nodePostgresAmbientConnectionPool,
-  nodePostgresAmbientNativePool,
-  nodePostgresClientConnection,
-  nodePostgresClientPool,
-  nodePostgresConnection,
-  nodePostgresExecute,
-  nodePostgresNativePool,
-  nodePostgresPool,
-  nodePostgresPoolClientConnection,
-  nodePostgresSQLExecutor,
-  nodePostgresTransaction,
-  onEndPool,
-  pgDatabaseDriver,
-  pgFormatter,
-  postgreSQLColumnProcessors,
-  postgresPool,
-  releaseAdvisoryLock,
-  setNodePostgresTypeParser,
-  tableExists,
-  tableExistsSQL,
-  tryAcquireAdvisoryLock,
-  usePgDatabaseDriver
+const usePgDumboDriver = () => {
+	dumboDatabaseDriverRegistry.register(PgDriverType, pgDumboDriver);
 };
+usePgDumboDriver();
+
+//#endregion
+export { AdvisoryLock, DefaultPostgreSQLMigratorOptions, PgDriverType, PostgreSQLArrayProcessor, PostgreSQLConnectionString, PostgreSQLDatabaseName, PostgreSQLExpandSQLInProcessor, acquireAdvisoryLock, advisoryLock, checkConnection, defaultPostgreSQLConnectionString, defaultPostgreSqlDatabase, endAllPgPools, endPgPool, functionExists, functionExistsSQL, getPgPool, isPgClient, isPgNativePool, isPgPoolClient, mapPostgresError, onEndPool, parseDatabaseName, pgAmbientClientPool, pgAmbientConnectionPool, pgAmbientNativePool, pgClientConnection, pgClientPool, pgConnection, pgDumboDriver, pgExecute, pgFormatter, pgNativePool, pgPool, pgPoolClientConnection, pgSQLExecutor, pgTransaction, postgreSQLColumnProcessors, postgreSQLMetadata, releaseAdvisoryLock, setPgTypeParser, tableExists, tableExistsSQL, tryAcquireAdvisoryLock, usePgDumboDriver };
 //# sourceMappingURL=pg.js.map