@event-driven-io/dumbo 0.13.0-beta.2 → 0.13.0-beta.21

package/dist/pg.js

@@ -1,93 +1,466 @@
 import {
   AdvisoryLock,
   DefaultPostgreSQLMigratorOptions,
-  NodePostgresDriverType,
-  PostgreSQLConnectionString,
+  PostgreSQLArrayProcessor,
   PostgreSQLDatabaseName,
+  PostgreSQLExpandSQLInProcessor,
   acquireAdvisoryLock,
   advisoryLock,
-  checkConnection,
-  connectionPool,
+  mapPostgresError,
+  pgFormatter,
+  postgreSQLColumnProcessors,
+  releaseAdvisoryLock,
+  tryAcquireAdvisoryLock
+} from "./chunk-65DKXURG.js";
+import {
+  PostgreSQLConnectionString,
   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,
+  parseDatabaseName,
+  postgreSQLMetadata,
   tableExists,
-  tableExistsSQL,
-  tryAcquireAdvisoryLock,
-  usePgDatabaseDriver
-} from "./chunk-I34X53VL.js";
-import "./chunk-N7RWT46K.js";
+  tableExistsSQL
+} from "./chunk-FC4JR2R3.js";
+import {
+  BatchCommandNoChangesError,
+  JSONSerializer,
+  canHandleDriverWithConnectionString,
+  createAmbientConnectionPool,
+  createConnection,
+  createConnectionPool,
+  dumboDatabaseDriverRegistry,
+  mapSQLQueryResult,
+  sqlExecutor,
+  tracer
+} from "./chunk-XO5T5N5S.js";
+
+// src/storage/postgresql/pg/connections/connection.ts
+import pg2 from "pg";
+
+// src/storage/postgresql/pg/execute/execute.ts
+import pg from "pg";
+var isPgNativePool = (poolOrClient) => {
+  return poolOrClient instanceof pg.Pool;
+};
+var isPgClient = (poolOrClient) => poolOrClient instanceof pg.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();
+  }
+};
+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: pgFormatter
+});
+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 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
+  })
+});
+
+// src/storage/postgresql/pg/connections/connection.ts
+var PgDriverType = "PostgreSQL:pg";
+var pgClientConnection = (options) => {
+  const { connect, close } = options;
+  return createConnection({
+    driverType: PgDriverType,
+    connect,
+    close,
+    initTransaction: (connection) => pgTransaction(connection, options.serializer),
+    executor: pgSQLExecutor,
+    serializer: options.serializer
+  });
+};
+var pgPoolClientConnection = (options) => {
+  const { connect, close } = options;
+  return 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);
+}
+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();
+  }
+};
+
+// src/storage/postgresql/pg/connections/pool.ts
+import pg3 from "pg";
+
+// src/storage/postgresql/pg/serialization/index.ts
+var 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 createConnectionPool({
+    driverType: PgDriverType,
+    connection: open,
+    close,
+    getConnection
+  });
+};
+var 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 pgAmbientConnectionPool = (options) => {
+  const { connection } = options;
+  return createAmbientConnectionPool({
+    driverType: PgDriverType,
+    connection
+  });
+};
+var pgClientPool = (options) => {
+  const { connectionString, database } = options;
+  return createConnectionPool({
+    driverType: PgDriverType,
+    getConnection: () => {
+      const connect = async () => {
+        const client = new pg3.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 createConnectionPool({
+    driverType: PgDriverType,
+    connection: open,
+    close,
+    getConnection
+  });
+};
+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 getPgPool = (connectionStringOrOptions) => {
+  const connectionString = typeof connectionStringOrOptions === "string" ? connectionStringOrOptions : connectionStringOrOptions.connectionString;
+  const poolOptions = typeof connectionStringOrOptions === "string" ? { connectionString } : connectionStringOrOptions;
+  const database = poolOptions.database ?? (poolOptions.connectionString ? parseDatabaseName(poolOptions.connectionString) ?? defaultPostgreSqlDatabase : void 0);
+  const lookupKey = key(connectionString, database);
+  updatePoolUsageCounter(lookupKey, 1);
+  return pools.get(lookupKey) ?? pools.set(lookupKey, new pg3.Pool(poolOptions)).get(lookupKey);
+};
+var 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);
+};
+var endAllPgPools = () => 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;
+};
+
+// src/storage/postgresql/pg/index.ts
+var tryParseConnectionString = (connectionString) => {
+  try {
+    return PostgreSQLConnectionString(connectionString);
+  } catch {
+    return null;
+  }
+};
+var pgDumboDriver = {
+  driverType: PgDriverType,
+  createPool: (options) => pgPool(options),
+  sqlFormatter: pgFormatter,
+  defaultMigratorOptions: DefaultPostgreSQLMigratorOptions,
+  canHandle: canHandleDriverWithConnectionString(
+    PgDriverType,
+    tryParseConnectionString
+  ),
+  databaseMetadata: postgreSQLMetadata
+};
+var usePgDumboDriver = () => {
+  dumboDatabaseDriverRegistry.register(PgDriverType, pgDumboDriver);
+};
+usePgDumboDriver();
 export {
   AdvisoryLock,
   DefaultPostgreSQLMigratorOptions,
-  NodePostgresDriverType,
+  PgDriverType,
+  PostgreSQLArrayProcessor,
   PostgreSQLConnectionString,
   PostgreSQLDatabaseName,
+  PostgreSQLExpandSQLInProcessor,
   acquireAdvisoryLock,
   advisoryLock,
   checkConnection,
-  connectionPool,
-  pgDatabaseDriver as databaseDriver,
   defaultPostgreSQLConnectionString,
   defaultPostgreSqlDatabase,
-  endAllPools,
-  endPool,
+  endAllPgPools,
+  endPgPool,
   functionExists,
   functionExistsSQL,
-  getDatabaseNameOrDefault,
-  getPool,
-  isNodePostgresClient,
-  isNodePostgresNativePool,
-  isNodePostgresPoolClient,
-  nodePostgresAmbientClientPool,
-  nodePostgresAmbientConnectionPool,
-  nodePostgresAmbientNativePool,
-  nodePostgresClientConnection,
-  nodePostgresClientPool,
-  nodePostgresConnection,
-  nodePostgresExecute,
-  nodePostgresNativePool,
-  nodePostgresPool,
-  nodePostgresPoolClientConnection,
-  nodePostgresSQLExecutor,
-  nodePostgresTransaction,
+  getPgPool,
+  isPgClient,
+  isPgNativePool,
+  isPgPoolClient,
+  mapPostgresError,
   onEndPool,
-  pgDatabaseDriver,
+  parseDatabaseName,
+  pgAmbientClientPool,
+  pgAmbientConnectionPool,
+  pgAmbientNativePool,
+  pgClientConnection,
+  pgClientPool,
+  pgConnection,
+  pgDumboDriver,
+  pgExecute,
   pgFormatter,
+  pgNativePool,
+  pgPool,
+  pgPoolClientConnection,
+  pgSQLExecutor,
+  pgTransaction,
   postgreSQLColumnProcessors,
-  postgresPool,
+  postgreSQLMetadata,
   releaseAdvisoryLock,
-  setNodePostgresTypeParser,
+  setPgTypeParser,
   tableExists,
   tableExistsSQL,
   tryAcquireAdvisoryLock,
-  usePgDatabaseDriver
+  usePgDumboDriver
 };
 //# sourceMappingURL=pg.js.map

package/dist/pg.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../src/storage/postgresql/pg/connections/connection.ts","../src/storage/postgresql/pg/execute/execute.ts","../src/storage/postgresql/pg/connections/transaction.ts","../src/storage/postgresql/pg/connections/pool.ts","../src/storage/postgresql/pg/serialization/index.ts","../src/storage/postgresql/pg/index.ts"],"sourcesContent":["import pg from 'pg';\nimport type { JSONSerializer } from '../../../../core';\nimport {\n  createConnection,\n  type Connection,\n  type DatabaseTransaction,\n} from '../../../../core';\nimport type { PostgreSQLDriverType } from '../../core';\nimport { pgSQLExecutor } from '../execute';\nimport { pgTransaction, type PgTransactionOptions } from './transaction';\n\nexport type PgDriverType = PostgreSQLDriverType<'pg'>;\nexport const PgDriverType: PgDriverType = 'PostgreSQL:pg';\n\nexport type PgPoolClient = pg.PoolClient;\nexport type PgClient = pg.Client;\n\nexport type PgClientOrPoolClient = PgPoolClient | PgClient;\n\nexport type PgPoolOrClient = pg.Pool | PgPoolClient | PgClient;\n\nexport type PgClientConnection = Connection<\n  PgClientConnection,\n  PgDriverType,\n  PgClient,\n  DatabaseTransaction<PgClientConnection>,\n  PgTransactionOptions\n>;\n\nexport type PgPoolClientConnection = Connection<\n  PgPoolClientConnection,\n  PgDriverType,\n  PgPoolClient,\n  DatabaseTransaction<PgPoolClientConnection>,\n  PgTransactionOptions\n>;\n\nexport type PgConnection = PgPoolClientConnection | PgClientConnection;\n\nexport type PgPoolClientOptions = {\n  type: 'PoolClient';\n  connect: () => Promise<PgPoolClient>;\n  close: (client: PgPoolClient) => Promise<void>;\n};\n\nexport type PgClientOptions = {\n  type: 'Client';\n  connect: () => Promise<PgClient>;\n  close: (client: PgClient) => Promise<void>;\n};\n\nexport type PgClientConnectionOptions = PgClientOptions & {\n  serializer: JSONSerializer;\n};\n\nexport type PgPoolClientConnectionOptions = PgPoolClientOptions & {\n  serializer: JSONSerializer;\n};\n\nexport const pgClientConnection = (\n  options: PgClientConnectionOptions,\n): PgClientConnection => {\n  const { connect, close } = options;\n\n  return createConnection({\n    driverType: PgDriverType,\n    connect,\n    close,\n    initTransaction: (connection) =>\n      pgTransaction(connection, options.serializer),\n    executor: pgSQLExecutor,\n    serializer: options.serializer,\n  });\n};\n\nexport const pgPoolClientConnection = (\n  options: PgPoolClientConnectionOptions,\n): PgPoolClientConnection => {\n  const { connect, close } = options;\n\n  return createConnection({\n    driverType: PgDriverType,\n    connect,\n    close,\n    initTransaction: (connection) =>\n      pgTransaction(connection, options.serializer),\n    executor: pgSQLExecutor,\n    serializer: options.serializer,\n  });\n};\n\nexport type PgConnectionOptions =\n  | PgPoolClientConnectionOptions\n  | PgClientConnectionOptions;\n\nexport function pgConnection(\n  options: PgPoolClientConnectionOptions,\n): PgPoolClientConnection;\nexport function pgConnection(\n  options: PgClientConnectionOptions,\n): PgClientConnection;\nexport function pgConnection(\n  options: PgPoolClientConnectionOptions | PgClientConnectionOptions,\n): PgPoolClientConnection | PgClientConnection {\n  return options.type === 'Client'\n    ? pgClientConnection(options)\n    : pgPoolClientConnection(options);\n}\n\nexport type ConnectionCheckResult =\n  | { successful: true }\n  | {\n      successful: false;\n      code: string | undefined;\n      errorType: 'ConnectionRefused' | 'Authentication' | 'Unknown';\n      error: unknown;\n    };\n\nexport const checkConnection = async (\n  connectionString: string,\n): Promise<ConnectionCheckResult> => {\n  const client = new pg.Client({\n    connectionString,\n  });\n\n  try {\n    await client.connect();\n    return { successful: true };\n  } catch (error) {\n    const code =\n      error instanceof Error &&\n      'code' in error &&\n      typeof error.code === 'string'\n        ? error.code\n        : undefined;\n\n    return {\n      successful: false,\n      errorType:\n        code === 'ECONNREFUSED'\n          ? 'ConnectionRefused'\n          : code === '28P01'\n            ? 'Authentication'\n            : 'Unknown',\n      code,\n      error,\n    };\n  } finally {\n    // Ensure the client is closed properly if connected\n    await client.end();\n  }\n};\n","import pg from 'pg';\nimport type { JSONSerializer } from '../../../../core';\nimport {\n  BatchCommandNoChangesError,\n  mapSQLQueryResult,\n  tracer,\n  type BatchSQLCommandOptions,\n  type DbSQLExecutor,\n  type QueryResult,\n  type QueryResultRow,\n  type SQL,\n  type SQLQueryOptions,\n} from '../../../../core';\nimport { pgFormatter } from '../../core';\nimport { mapPostgresError } from '../../core/errors/errorMapper';\nimport { PgDriverType, type PgClientOrPoolClient } from '../connections';\n\nexport const isPgNativePool = (\n  poolOrClient: pg.Pool | pg.PoolClient | pg.Client,\n): poolOrClient is pg.Pool => {\n  return poolOrClient instanceof pg.Pool;\n};\n\nexport const isPgClient = (\n  poolOrClient: pg.Pool | pg.PoolClient | pg.Client,\n): poolOrClient is pg.Client => poolOrClient instanceof pg.Client;\n\nexport const isPgPoolClient = (\n  poolOrClient: pg.Pool | pg.PoolClient | pg.Client,\n): poolOrClient is pg.PoolClient =>\n  'release' in poolOrClient && typeof poolOrClient.release === 'function';\n\nexport const pgExecute = async <Result = void>(\n  poolOrClient: pg.Pool | pg.PoolClient | pg.Client,\n  handle: (client: pg.PoolClient | pg.Client) => Promise<Result>,\n) => {\n  const client = isPgNativePool(poolOrClient)\n    ? await poolOrClient.connect()\n    : poolOrClient;\n\n  try {\n    return await handle(client);\n  } finally {\n    // release only if client wasn't injected externally\n    if (isPgNativePool(poolOrClient) && isPgPoolClient(client))\n      client.release();\n  }\n};\n\nexport type PgSQLExecutor = DbSQLExecutor<PgDriverType, PgClientOrPoolClient>;\n\nexport const pgSQLExecutor = ({\n  serializer,\n}: {\n  serializer: JSONSerializer;\n}): PgSQLExecutor => ({\n  driverType: PgDriverType,\n  query: async <Result extends QueryResultRow = QueryResultRow>(\n    client: PgClientOrPoolClient,\n    sql: SQL,\n    options: SQLQueryOptions | undefined,\n  ) => {\n    const results = await batchQuery<Result>(\n      client,\n      [sql],\n      serializer,\n      options,\n    );\n    return results[0]!;\n  },\n  batchQuery: <Result extends QueryResultRow = QueryResultRow>(\n    client: PgClientOrPoolClient,\n    sqls: SQL[],\n    options: SQLQueryOptions | undefined,\n  ) => batchQuery<Result>(client, sqls, serializer, options),\n  command: async <Result extends QueryResultRow = QueryResultRow>(\n    client: PgClientOrPoolClient,\n    sql: SQL,\n    options: BatchSQLCommandOptions | undefined,\n  ) => {\n    const results = await batchCommand<Result>(\n      client,\n      [sql],\n      serializer,\n      options,\n    );\n    return results[0]!;\n  },\n  batchCommand: <Result extends QueryResultRow = QueryResultRow>(\n    client: PgClientOrPoolClient,\n    sqls: SQL[],\n    options: BatchSQLCommandOptions | undefined,\n  ) => batchCommand<Result>(client, sqls, serializer, options),\n  formatter: pgFormatter,\n});\n\nasync function batchQuery<Result extends QueryResultRow = QueryResultRow>(\n  client: PgClientOrPoolClient,\n  sqls: SQL[],\n  serializer: JSONSerializer,\n  options?: SQLQueryOptions,\n): Promise<QueryResult<Result>[]> {\n  const results: QueryResult<Result>[] = Array<QueryResult<Result>>(\n    sqls.length,\n  );\n\n  if (options?.timeoutMs) {\n    await client.query(`SET statement_timeout = ${options.timeoutMs}`);\n  }\n\n  //TODO: make it smarter at some point\n  for (let i = 0; i < sqls.length; i++) {\n    const { query, params } = pgFormatter.format(sqls[i]!, { serializer });\n    tracer.info('db:sql:query', {\n      query,\n      params,\n      debugSQL: pgFormatter.describe(sqls[i]!, { serializer }),\n    });\n    try {\n      let result =\n        params.length > 0\n          ? await client.query<Result>(query, params)\n          : await client.query<Result>(query);\n\n      if (options?.mapping) {\n        result = {\n          ...result,\n          rows: result.rows.map((row) =>\n            mapSQLQueryResult(row, options.mapping!),\n          ),\n        };\n      }\n\n      results[i] = { rowCount: result.rowCount, rows: result.rows };\n    } catch (error) {\n      tracer.error('db:sql:batch_query:execute:error', { error });\n      throw mapPostgresError(error);\n    }\n  }\n\n  return results;\n}\n\nasync function batchCommand<Result extends QueryResultRow = QueryResultRow>(\n  client: PgClientOrPoolClient,\n  sqls: SQL[],\n  serializer: JSONSerializer,\n  options?: BatchSQLCommandOptions,\n): Promise<QueryResult<Result>[]> {\n  const results: QueryResult<Result>[] = Array<QueryResult<Result>>(\n    sqls.length,\n  );\n\n  if (options?.timeoutMs) {\n    await client.query(`SET statement_timeout = ${options.timeoutMs}`);\n  }\n\n  //TODO: make it smarter at some point\n  for (let i = 0; i < sqls.length; i++) {\n    const { query, params } = pgFormatter.format(sqls[i]!, { serializer });\n    tracer.info('db:sql:command', {\n      query,\n      params,\n      debugSQL: pgFormatter.describe(sqls[i]!, { serializer }),\n    });\n    try {\n      let result =\n        params.length > 0\n          ? await client.query<Result>(query, params)\n          : await client.query<Result>(query);\n\n      if (options?.mapping) {\n        result = {\n          ...result,\n          rows: result.rows.map((row) =>\n            mapSQLQueryResult(row, options.mapping!),\n          ),\n        };\n      }\n\n      results[i] = { rowCount: result.rowCount, rows: result.rows };\n\n      if (options?.assertChanges && (results[i]!.rowCount ?? 0) === 0) {\n        throw new BatchCommandNoChangesError(i);\n      }\n    } catch (error) {\n      tracer.error('db:sql:batch_command:execute:error', { error });\n      throw mapPostgresError(error);\n    }\n  }\n\n  return results;\n}\n","import type { JSONSerializer } from '../../../../core';\nimport {\n  sqlExecutor,\n  type AnyConnection,\n  type DatabaseTransaction,\n  type DatabaseTransactionOptions,\n} from '../../../../core';\nimport { pgSQLExecutor } from '../execute';\nimport {\n  PgDriverType,\n  type PgConnection,\n  type PgPoolOrClient,\n} from './connection';\n\nexport type PgTransaction = DatabaseTransaction<PgConnection>;\n\nexport type PgIsolationLevel =\n  | 'READ UNCOMMITTED'\n  | 'READ COMMITTED'\n  | 'REPEATABLE READ'\n  | 'SERIALIZABLE';\n\nexport type PgTransactionOptions = DatabaseTransactionOptions & {\n  isolationLevel?: PgIsolationLevel;\n};\n\nexport const pgTransaction =\n  <ConnectionType extends AnyConnection = AnyConnection>(\n    connection: () => ConnectionType,\n    serializer: JSONSerializer,\n  ) =>\n  <DbClient extends PgPoolOrClient = PgPoolOrClient>(\n    getClient: Promise<DbClient>,\n    options?: {\n      close: (client: DbClient, error?: unknown) => Promise<void>;\n    } & PgTransactionOptions,\n  ): DatabaseTransaction<ConnectionType> => ({\n    connection: connection(),\n    driverType: PgDriverType,\n    begin: async () => {\n      const client = await getClient;\n      const parts = ['BEGIN'];\n      if (options?.isolationLevel) {\n        parts.push(`ISOLATION LEVEL ${options.isolationLevel}`);\n      }\n      if (options?.readonly) {\n        parts.push('READ ONLY');\n      }\n      await client.query(parts.join(' '));\n    },\n    commit: async () => {\n      const client = await getClient;\n\n      try {\n        await client.query('COMMIT');\n      } finally {\n        if (options?.close) await options?.close(client);\n      }\n    },\n    rollback: async (error?: unknown) => {\n      const client = await getClient;\n      try {\n        await client.query('ROLLBACK');\n      } finally {\n        if (options?.close) await options?.close(client, error);\n      }\n    },\n    execute: sqlExecutor(pgSQLExecutor({ serializer }), {\n      connect: () => getClient,\n    }),\n  });\n","import pg from 'pg';\nimport {\n  createAmbientConnectionPool,\n  createConnectionPool,\n  JSONSerializer,\n  tracer,\n  type ConnectionPool,\n  type InferTransactionFromConnection,\n  type InferTransactionOptionsFromConnection,\n  type JSONSerializationOptions,\n} from '../../../../core';\nimport { defaultPostgreSqlDatabase, parseDatabaseName } from '../../core';\nimport { setPgTypeParser } from '../serialization';\nimport {\n  pgConnection,\n  PgDriverType,\n  type PgClientConnection,\n  type PgPoolClientConnection,\n} from './connection';\n\nexport type PgNativePool = ConnectionPool<\n  PgPoolClientConnection,\n  InferTransactionFromConnection<PgPoolClientConnection>,\n  InferTransactionOptionsFromConnection<PgPoolClientConnection>\n>;\n\nexport type PgAmbientClientPool = ConnectionPool<\n  PgClientConnection,\n  InferTransactionFromConnection<PgClientConnection>,\n  InferTransactionOptionsFromConnection<PgClientConnection>\n>;\n\nexport type PgAmbientConnectionPool = ConnectionPool<\n  PgPoolClientConnection | PgClientConnection\n>;\n\nexport type PgPool =\n  | PgNativePool\n  | PgAmbientClientPool\n  | PgAmbientConnectionPool;\n\nexport const pgNativePool = (options: {\n  connectionString: string;\n  database?: string | undefined;\n  serializer: JSONSerializer;\n}): PgNativePool => {\n  const { connectionString, database } = options;\n  const pool = getPgPool({ connectionString, database });\n\n  const getConnection = () =>\n    pgConnection({\n      type: 'PoolClient',\n      connect: async () => {\n        const client = await pool.connect();\n\n        setPgTypeParser(client, {\n          parseBigInts: true,\n          serializer: options.serializer,\n        });\n\n        return client;\n      },\n      close: (client) => Promise.resolve(client.release()),\n      serializer: options.serializer,\n    });\n\n  const open = () => Promise.resolve(getConnection());\n  const close = () => endPgPool({ connectionString, database });\n\n  return createConnectionPool({\n    driverType: PgDriverType,\n    connection: open,\n    close,\n    getConnection,\n  });\n};\n\nexport const pgAmbientNativePool = (options: {\n  pool: pg.Pool;\n  serializer: JSONSerializer;\n}): PgNativePool => {\n  const { pool } = options;\n\n  return createConnectionPool({\n    driverType: PgDriverType,\n    getConnection: () =>\n      pgConnection({\n        type: 'PoolClient',\n        connect: () => pool.connect(),\n        close: (client) => Promise.resolve(client.release()),\n        serializer: options.serializer,\n      }),\n  });\n};\n\nexport const pgAmbientConnectionPool = (options: {\n  connection: PgPoolClientConnection | PgClientConnection;\n}): PgAmbientConnectionPool => {\n  const { connection } = options;\n\n  return createAmbientConnectionPool({\n    driverType: PgDriverType,\n    connection,\n  });\n};\n\nexport const pgClientPool = (options: {\n  connectionString: string;\n  database?: string | undefined;\n  serializer: JSONSerializer;\n}): PgAmbientClientPool => {\n  const { connectionString, database } = options;\n\n  return createConnectionPool({\n    driverType: PgDriverType,\n    getConnection: () => {\n      const connect = async () => {\n        const client = new pg.Client({ connectionString, database });\n\n        setPgTypeParser(client, {\n          parseBigInts: true,\n          serializer: options.serializer,\n        });\n\n        await client.connect();\n        return client;\n      };\n\n      return pgConnection({\n        type: 'Client',\n        connect,\n        close: (client) => client.end(),\n        serializer: options.serializer,\n      });\n    },\n  });\n};\n\nexport const pgAmbientClientPool = (options: {\n  client: pg.Client;\n  serializer: JSONSerializer;\n}): PgAmbientClientPool => {\n  const { client } = options;\n\n  const getConnection = () => {\n    const connect = () => Promise.resolve(client);\n\n    return pgConnection({\n      type: 'Client',\n      connect,\n      close: () => Promise.resolve(),\n      serializer: options.serializer,\n    });\n  };\n\n  const open = () => Promise.resolve(getConnection());\n  const close = () => Promise.resolve();\n\n  return createConnectionPool({\n    driverType: PgDriverType,\n    connection: open,\n    close,\n    getConnection,\n  });\n};\n\nexport type PgPoolPooledOptions =\n  | {\n      connectionString: string;\n      database?: string;\n      pooled: true;\n      pool: pg.Pool;\n    }\n  | {\n      connectionString: string;\n      database?: string;\n      pool: pg.Pool;\n    }\n  | {\n      connectionString: string;\n      database?: string;\n      pooled: true;\n    }\n  | {\n      connectionString: string;\n      database?: string;\n    };\n\nexport type PgPoolNotPooledOptions =\n  | {\n      connectionString: string;\n      database?: string;\n      pooled: false;\n      client: pg.Client;\n    }\n  | {\n      connectionString: string;\n      database?: string;\n      client: pg.Client;\n    }\n  | {\n      connectionString: string;\n      database?: string;\n      pooled: false;\n    }\n  | {\n      connectionString: string;\n      database?: string;\n      connection: PgPoolClientConnection | PgClientConnection;\n      pooled?: false;\n    };\n\nexport type PgPoolOptions = (PgPoolPooledOptions | PgPoolNotPooledOptions) &\n  JSONSerializationOptions;\n\nexport function pgPool(options: PgPoolPooledOptions): PgNativePool;\nexport function pgPool(options: PgPoolNotPooledOptions): PgAmbientClientPool;\nexport function pgPool(\n  options: PgPoolOptions,\n): PgNativePool | PgAmbientClientPool | PgAmbientConnectionPool {\n  const { connectionString, database } = options;\n\n  const serializer = options.serialization?.serializer ?? JSONSerializer;\n\n  if ('client' in options && options.client)\n    return pgAmbientClientPool({ client: options.client, serializer });\n\n  if ('connection' in options && options.connection)\n    return pgAmbientConnectionPool({\n      connection: options.connection,\n    });\n\n  if ('pooled' in options && options.pooled === false)\n    return pgClientPool({ connectionString, database, serializer });\n\n  if ('pool' in options && options.pool)\n    return pgAmbientNativePool({ pool: options.pool, serializer });\n\n  return pgNativePool({\n    connectionString,\n    database,\n    serializer,\n  });\n}\n\nconst pools: Map<string, pg.Pool> = new Map();\nconst usageCounter: Map<string, number> = new Map();\n\nexport const getPgPool = (\n  connectionStringOrOptions: string | pg.PoolConfig,\n): pg.Pool => {\n  const connectionString =\n    typeof connectionStringOrOptions === 'string'\n      ? connectionStringOrOptions\n      : connectionStringOrOptions.connectionString!;\n\n  const poolOptions =\n    typeof connectionStringOrOptions === 'string'\n      ? { connectionString }\n      : connectionStringOrOptions;\n\n  const database =\n    poolOptions.database ??\n    (poolOptions.connectionString\n      ? (parseDatabaseName(poolOptions.connectionString) ??\n        defaultPostgreSqlDatabase)\n      : undefined);\n\n  const lookupKey = key(connectionString, database);\n\n  updatePoolUsageCounter(lookupKey, 1);\n\n  return (\n    pools.get(lookupKey) ??\n    pools.set(lookupKey, new pg.Pool(poolOptions)).get(lookupKey)!\n  );\n};\n\nexport const endPgPool = async ({\n  connectionString,\n  database,\n  force,\n}: {\n  connectionString: string;\n  database?: string | undefined;\n  force?: boolean;\n}): Promise<void> => {\n  database = database ?? parseDatabaseName(connectionString) ?? undefined;\n  const lookupKey = key(connectionString, database);\n\n  const pool = pools.get(lookupKey);\n  if (pool && (updatePoolUsageCounter(lookupKey, -1) <= 0 || force === true)) {\n    await onEndPool(lookupKey, pool);\n  }\n};\n\nexport const onEndPool = async (lookupKey: string, pool: pg.Pool) => {\n  try {\n    await pool.end();\n  } catch (error) {\n    tracer.error('connection-closing-error', { lookupKey, error });\n  }\n  pools.delete(lookupKey);\n};\n\nexport const endAllPgPools = () =>\n  Promise.all(\n    [...pools.entries()].map(([lookupKey, pool]) => onEndPool(lookupKey, pool)),\n  );\n\nconst key = (connectionString: string, database: string | undefined) =>\n  `${connectionString}|${database ?? defaultPostgreSqlDatabase}`;\n\nconst updatePoolUsageCounter = (lookupKey: string, by: 1 | -1): number => {\n  const currentCounter = usageCounter.get(lookupKey) ?? 0;\n  const newCounter = currentCounter + by;\n\n  usageCounter.set(lookupKey, currentCounter + by);\n\n  return newCounter;\n};\n","import type pg from 'pg';\nimport type { JSONSerializer } from '../../../../core/serializer';\n\nexport const setPgTypeParser = (\n  client: pg.Client | pg.PoolClient,\n  options?: {\n    parseBigInts?: boolean;\n    serializer: JSONSerializer;\n  },\n) => {\n  // BigInt\n  if (options?.parseBigInts === true)\n    client.setTypeParser(20, (val) => BigInt(val));\n\n  if (options?.serializer) {\n    // JSONB\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    client.setTypeParser(3802, (val) => options.serializer.deserialize(val));\n\n    // JSON\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    client.setTypeParser(114, (val) => options.serializer.deserialize(val));\n  }\n};\n","import {\n  canHandleDriverWithConnectionString,\n  type DumboDatabaseDriver,\n  dumboDatabaseDriverRegistry,\n} from '../../../core';\nimport {\n  DefaultPostgreSQLMigratorOptions,\n  pgFormatter,\n  PostgreSQLConnectionString,\n  postgreSQLMetadata,\n} from '../core';\nimport {\n  type PgConnection,\n  PgDriverType,\n  pgPool,\n  type PgPool,\n  type PgPoolOptions,\n} from './connections';\n\nconst tryParseConnectionString = (connectionString: string) => {\n  try {\n    return PostgreSQLConnectionString(connectionString);\n  } catch {\n    return null;\n  }\n};\n\nexport const pgDumboDriver: DumboDatabaseDriver<\n  PgConnection,\n  PgPoolOptions,\n  PgPool\n> = {\n  driverType: PgDriverType,\n  createPool: (options) => pgPool(options as PgPoolOptions),\n  sqlFormatter: pgFormatter,\n  defaultMigratorOptions: DefaultPostgreSQLMigratorOptions,\n  canHandle: canHandleDriverWithConnectionString(\n    PgDriverType,\n    tryParseConnectionString,\n  ),\n  databaseMetadata: postgreSQLMetadata,\n};\n\nexport const usePgDumboDriver = () => {\n  dumboDatabaseDriverRegistry.register(PgDriverType, pgDumboDriver);\n};\n\nusePgDumboDriver();\n\nexport type PgDumboOptions = PgPoolOptions;\nexport * from './connections';\nexport * from './execute';\nexport * from './serialization';\n"],"mappings":"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","names":["pg","pg","pg","pg"]}

package/dist/postgresql.cjs

@@ -0,0 +1,50 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk7WEBHXZDcjs = require('./chunk-7WEBHXZD.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkH7ZKIJHBcjs = require('./chunk-H7ZKIJHB.cjs');
+require('./chunk-XOQHZABK.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AdvisoryLock = _chunk7WEBHXZDcjs.AdvisoryLock; exports.DefaultPostgreSQLMigratorOptions = _chunk7WEBHXZDcjs.DefaultPostgreSQLMigratorOptions; exports.PostgreSQLArrayProcessor = _chunk7WEBHXZDcjs.PostgreSQLArrayProcessor; exports.PostgreSQLConnectionString = _chunkH7ZKIJHBcjs.PostgreSQLConnectionString; exports.PostgreSQLDatabaseName = _chunk7WEBHXZDcjs.PostgreSQLDatabaseName; exports.PostgreSQLExpandSQLInProcessor = _chunk7WEBHXZDcjs.PostgreSQLExpandSQLInProcessor; exports.acquireAdvisoryLock = _chunk7WEBHXZDcjs.acquireAdvisoryLock; exports.advisoryLock = _chunk7WEBHXZDcjs.advisoryLock; exports.defaultPostgreSQLConnectionString = _chunkH7ZKIJHBcjs.defaultPostgreSQLConnectionString; exports.defaultPostgreSqlDatabase = _chunkH7ZKIJHBcjs.defaultPostgreSqlDatabase; exports.functionExists = _chunkH7ZKIJHBcjs.functionExists; exports.functionExistsSQL = _chunkH7ZKIJHBcjs.functionExistsSQL; exports.mapPostgresError = _chunk7WEBHXZDcjs.mapPostgresError; exports.parseDatabaseName = _chunkH7ZKIJHBcjs.parseDatabaseName; exports.pgFormatter = _chunk7WEBHXZDcjs.pgFormatter; exports.postgreSQLColumnProcessors = _chunk7WEBHXZDcjs.postgreSQLColumnProcessors; exports.postgreSQLMetadata = _chunkH7ZKIJHBcjs.postgreSQLMetadata; exports.releaseAdvisoryLock = _chunk7WEBHXZDcjs.releaseAdvisoryLock; exports.tableExists = _chunkH7ZKIJHBcjs.tableExists; exports.tableExistsSQL = _chunkH7ZKIJHBcjs.tableExistsSQL; exports.tryAcquireAdvisoryLock = _chunk7WEBHXZDcjs.tryAcquireAdvisoryLock;
+//# sourceMappingURL=postgresql.cjs.map

package/dist/postgresql.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/Pongo/Pongo/src/packages/dumbo/dist/postgresql.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,k9CAAC","file":"/home/runner/work/Pongo/Pongo/src/packages/dumbo/dist/postgresql.cjs"}