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

package/dist/index.js

@@ -1,41 +1,57 @@
-import {
-  dumbo,
-  parseConnectionString
-} from "./chunk-TXSETOGH.js";
+import "./chunk-U445U32Q.js";
+import "./chunk-3B24ORM3.js";
 import {
   ANSISQLIdentifierQuote,
   ANSISQLParamPlaceholder,
+  AdminShutdownError,
   AutoIncrementSQLColumnToken,
+  BatchCommandNoChangesError,
   BigIntegerToken,
   BigSerialToken,
+  CheckViolationError,
   ColumnTypeToken,
   ColumnURN,
   ColumnURNType,
+  ConcurrencyError,
+  ConnectionError,
+  DataError,
   DatabaseSchemaURN,
   DatabaseSchemaURNType,
   DatabaseURN,
   DatabaseURNType,
+  DeadlockError,
   DefaultMapSQLParamValueOptions,
   DumboDatabaseDriverRegistry,
+  DumboDatabaseMetadataRegistry,
+  DumboError,
+  ExclusionViolationError,
   ExpandArrayProcessor,
   ExpandSQLInProcessor,
+  ForeignKeyViolationError,
   FormatIdentifierProcessor,
   IndexURN,
   IndexURNType,
+  InsufficientResourcesError,
   IntegerToken,
+  IntegrityConstraintViolationError,
+  InvalidOperationError,
   JSONBToken,
+  JSONCodec,
   JSONReplacer,
   JSONReplacers,
   JSONReviver,
   JSONRevivers,
   JSONSerializer,
+  LockNotAvailableError,
   LogLevel,
   LogStyle,
   MIGRATIONS_LOCK_ID,
   MapLiteralProcessor,
   NoDatabaseLock,
+  NotNullViolationError,
   ParametrizedSQLBuilder,
-  RawJSONSerializer,
+  QueryCanceledError,
+  RawSQL,
   SQL,
   SQLArray,
   SQLColumnToken,
@@ -52,11 +68,15 @@ import {
   SQLValueMapper,
   SchemaComponentMigrator,
   SerialToken,
+  SerializationError,
+  SystemError,
   TableURN,
   TableURNType,
   TimestampToken,
   TimestamptzToken,
   TokenizedSQL,
+  TransientDatabaseError,
+  UniqueConstraintError,
   VarcharToken,
   ansiSqlReservedMap,
   canHandleDriverWithConnectionString,
@@ -81,6 +101,7 @@ import {
   defaultProcessorsRegistry,
   describeSQL,
   dumboDatabaseDriverRegistry,
+  dumboDatabaseMetadataRegistry,
   dumboSchema,
   executeInAmbientConnection,
   executeInNewConnection,
@@ -94,7 +115,10 @@ import {
   formatSQL,
   fromDatabaseDriverType,
   getDatabaseDriverName,
+  getDatabaseMetadata,
   getDatabaseType,
+  getDefaultDatabase,
+  getDefaultDatabaseAsync,
   getDefaultMigratorOptionsFromRegistry,
   getFormatter,
   indexSchemaComponent,
@@ -104,6 +128,7 @@ import {
   jsonSerializer,
   mapANSISQLParamPlaceholder,
   mapColumnToBigint,
+  mapColumnToDate,
   mapColumnToJSON,
   mapDefaultSQLColumnProcessors,
   mapRows,
@@ -117,6 +142,7 @@ import {
   registerDefaultMigratorOptions,
   registerFormatter,
   relationship,
+  resolveDatabaseMetadata,
   runSQLMigrations,
   schemaComponent,
   schemaComponentURN,
@@ -133,41 +159,97 @@ import {
   transactionFactoryWithAmbientConnection,
   transactionFactoryWithDbClient,
   transactionFactoryWithNewConnection
-} from "./chunk-N7RWT46K.js";
+} from "./chunk-ZH6YVE3B.js";
+
+// src/storage/all/connections/connectionString.ts
+var parseConnectionString = (connectionString) => {
+  if (connectionString.startsWith("postgresql://") || connectionString.startsWith("postgres://")) {
+    return {
+      databaseType: "PostgreSQL",
+      driverName: "pg"
+    };
+  }
+  if (connectionString.startsWith("file:") || connectionString === ":memory:" || connectionString.startsWith("/") || connectionString.startsWith("./")) {
+    return {
+      databaseType: "SQLite",
+      driverName: "sqlite3"
+    };
+  }
+  if (connectionString.startsWith("d1:")) {
+    return {
+      databaseType: "SQLite",
+      driverName: "d1"
+    };
+  }
+  throw new Error(
+    `Unsupported database connection string: ${connectionString}`
+  );
+};
+
+// src/storage/all/index.ts
+function dumbo(options) {
+  const { driverType } = options;
+  const driver = options.driver ?? dumboDatabaseDriverRegistry.tryGet(options);
+  if (driver === null) {
+    throw new Error(`No plugin found for driver type: ${driverType}`);
+  }
+  return driver.createPool({
+    ...options,
+    driverType: driver.driverType
+  });
+}
 export {
   ANSISQLIdentifierQuote,
   ANSISQLParamPlaceholder,
+  AdminShutdownError,
   AutoIncrementSQLColumnToken,
+  BatchCommandNoChangesError,
   BigIntegerToken,
   BigSerialToken,
+  CheckViolationError,
   ColumnTypeToken,
   ColumnURN,
   ColumnURNType,
+  ConcurrencyError,
+  ConnectionError,
+  DataError,
   DatabaseSchemaURN,
   DatabaseSchemaURNType,
   DatabaseURN,
   DatabaseURNType,
+  DeadlockError,
   DefaultMapSQLParamValueOptions,
   DumboDatabaseDriverRegistry,
+  DumboDatabaseMetadataRegistry,
+  DumboError,
+  ExclusionViolationError,
   ExpandArrayProcessor,
   ExpandSQLInProcessor,
+  ForeignKeyViolationError,
   FormatIdentifierProcessor,
   IndexURN,
   IndexURNType,
+  InsufficientResourcesError,
   IntegerToken,
+  IntegrityConstraintViolationError,
+  InvalidOperationError,
   JSONBToken,
+  JSONCodec,
   JSONReplacer,
   JSONReplacers,
   JSONReviver,
   JSONRevivers,
   JSONSerializer,
+  LockNotAvailableError,
   LogLevel,
   LogStyle,
   MIGRATIONS_LOCK_ID,
   MapLiteralProcessor,
   NoDatabaseLock,
+  NotNullViolationError,
   ParametrizedSQLBuilder,
-  RawJSONSerializer,
+  QueryCanceledError,
+  RawSQL,
   SQL,
   SQLArray,
   SQLColumnToken,
@@ -184,11 +266,15 @@ export {
   SQLValueMapper,
   SchemaComponentMigrator,
   SerialToken,
+  SerializationError,
+  SystemError,
   TableURN,
   TableURNType,
   TimestampToken,
   TimestamptzToken,
   TokenizedSQL,
+  TransientDatabaseError,
+  UniqueConstraintError,
   VarcharToken,
   ansiSqlReservedMap,
   canHandleDriverWithConnectionString,
@@ -214,6 +300,7 @@ export {
   describeSQL,
   dumbo,
   dumboDatabaseDriverRegistry,
+  dumboDatabaseMetadataRegistry,
   dumboSchema,
   executeInAmbientConnection,
   executeInNewConnection,
@@ -227,7 +314,10 @@ export {
   formatSQL,
   fromDatabaseDriverType,
   getDatabaseDriverName,
+  getDatabaseMetadata,
   getDatabaseType,
+  getDefaultDatabase,
+  getDefaultDatabaseAsync,
   getDefaultMigratorOptionsFromRegistry,
   getFormatter,
   indexSchemaComponent,
@@ -237,6 +327,7 @@ export {
   jsonSerializer,
   mapANSISQLParamPlaceholder,
   mapColumnToBigint,
+  mapColumnToDate,
   mapColumnToJSON,
   mapDefaultSQLColumnProcessors,
   mapRows,
@@ -251,6 +342,7 @@ export {
   registerDefaultMigratorOptions,
   registerFormatter,
   relationship,
+  resolveDatabaseMetadata,
   runSQLMigrations,
   schemaComponent,
   schemaComponentURN,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../src/storage/all/connections/connectionString.ts","../src/storage/all/index.ts"],"sourcesContent":["import type { DatabaseDriverTypeParts, DatabaseType } from '../../../core';\n\nexport type DatabaseConnectionString<\n  DatabaseTypeName extends DatabaseType = DatabaseType,\n  Format extends string = string,\n> = Format & {\n  _databaseType: DatabaseTypeName;\n};\n\nexport const parseConnectionString = (\n  connectionString: DatabaseConnectionString | string,\n): DatabaseDriverTypeParts => {\n  if (\n    connectionString.startsWith('postgresql://') ||\n    connectionString.startsWith('postgres://')\n  ) {\n    return {\n      databaseType: 'PostgreSQL',\n      driverName: 'pg',\n    };\n  }\n\n  if (\n    connectionString.startsWith('file:') ||\n    connectionString === ':memory:' ||\n    connectionString.startsWith('/') ||\n    connectionString.startsWith('./')\n  ) {\n    return {\n      databaseType: 'SQLite',\n      driverName: 'sqlite3',\n    };\n  }\n\n  if (connectionString.startsWith('d1:')) {\n    return {\n      databaseType: 'SQLite',\n      driverName: 'd1',\n    };\n  }\n\n  throw new Error(\n    `Unsupported database connection string: ${connectionString}`,\n  );\n};\n","import {\n  dumboDatabaseDriverRegistry,\n  type AnyDumboDatabaseDriver,\n  type DumboConnectionOptions,\n  type ExtractDumboDatabaseDriverOptions,\n  type ExtractDumboTypeFromDriver,\n  type JSONSerializationOptions,\n} from '../../core';\n\nexport * from './connections';\n\nexport function dumbo<Driver extends AnyDumboDatabaseDriver>(\n  options: ExtractDumboDatabaseDriverOptions<Driver> & {\n    driver: Driver;\n  } & JSONSerializationOptions,\n): ExtractDumboTypeFromDriver<Driver>;\n\nexport function dumbo<\n  DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver,\n  ConnectionOptions extends DumboConnectionOptions<DatabaseDriver> =\n    DumboConnectionOptions<DatabaseDriver>,\n>(\n  options: ConnectionOptions & { driver?: never },\n): ExtractDumboTypeFromDriver<DatabaseDriver>;\n\nexport function dumbo<\n  DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver,\n>(\n  options: DumboConnectionOptions<DatabaseDriver>,\n): ExtractDumboTypeFromDriver<DatabaseDriver> {\n  const { driverType } = options;\n\n  const driver =\n    options.driver ??\n    dumboDatabaseDriverRegistry.tryGet<DatabaseDriver>(options);\n\n  if (driver === null) {\n    throw new Error(`No plugin found for driver type: ${driverType}`);\n  }\n\n  return driver.createPool({\n    ...options,\n    driverType: driver.driverType,\n  }) as ExtractDumboTypeFromDriver<DatabaseDriver>;\n}\n\nimport '../postgresql/core/schema/postgreSQLMetadata';\nimport '../sqlite/core/schema/sqliteMetadata';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASO,IAAM,wBAAwB,CACnC,qBAC4B;AAC5B,MACE,iBAAiB,WAAW,eAAe,KAC3C,iBAAiB,WAAW,aAAa,GACzC;AACA,WAAO;AAAA,MACL,cAAc;AAAA,MACd,YAAY;AAAA,IACd;AAAA,EACF;AAEA,MACE,iBAAiB,WAAW,OAAO,KACnC,qBAAqB,cACrB,iBAAiB,WAAW,GAAG,KAC/B,iBAAiB,WAAW,IAAI,GAChC;AACA,WAAO;AAAA,MACL,cAAc;AAAA,MACd,YAAY;AAAA,IACd;AAAA,EACF;AAEA,MAAI,iBAAiB,WAAW,KAAK,GAAG;AACtC,WAAO;AAAA,MACL,cAAc;AAAA,MACd,YAAY;AAAA,IACd;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR,2CAA2C,gBAAgB;AAAA,EAC7D;AACF;;;ACnBO,SAAS,MAGd,SAC4C;AAC5C,QAAM,EAAE,WAAW,IAAI;AAEvB,QAAM,SACJ,QAAQ,UACR,4BAA4B,OAAuB,OAAO;AAE5D,MAAI,WAAW,MAAM;AACnB,UAAM,IAAI,MAAM,oCAAoC,UAAU,EAAE;AAAA,EAClE;AAEA,SAAO,OAAO,WAAW;AAAA,IACvB,GAAG;AAAA,IACH,YAAY,OAAO;AAAA,EACrB,CAAC;AACH;","names":[]}

package/dist/pg.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"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; }
 
 
 
@@ -11,6 +11,7 @@
 
 
 
+var _chunkSQXAAA3Ncjs = require('./chunk-SQXAAA3N.cjs');
 
 
 
@@ -21,6 +22,7 @@
 
 
 
+var _chunkVIQJEUVFcjs = require('./chunk-VIQJEUVF.cjs');
 
 
 
@@ -32,18 +34,387 @@
 
 
 
+var _chunkPYTHH6WOcjs = require('./chunk-PYTHH6WO.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;
+};
+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();
+  }
+};
+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: _chunkSQXAAA3Ncjs.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 } = _chunkSQXAAA3Ncjs.pgFormatter.format(sqls[i], { serializer });
+    _chunkPYTHH6WOcjs.tracer.info("db:sql:query", {
+      query,
+      params,
+      debugSQL: _chunkSQXAAA3Ncjs.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) => _chunkPYTHH6WOcjs.mapSQLQueryResult.call(void 0, row, options.mapping)
+          )
+        };
+      }
+      results[i] = { rowCount: result.rowCount, rows: result.rows };
+    } catch (error) {
+      _chunkPYTHH6WOcjs.tracer.error("db:sql:batch_query:execute:error", { error });
+      throw _chunkSQXAAA3Ncjs.mapPostgresError.call(void 0, 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 } = _chunkSQXAAA3Ncjs.pgFormatter.format(sqls[i], { serializer });
+    _chunkPYTHH6WOcjs.tracer.info("db:sql:command", {
+      query,
+      params,
+      debugSQL: _chunkSQXAAA3Ncjs.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) => _chunkPYTHH6WOcjs.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, _chunkPYTHH6WOcjs.BatchCommandNoChangesError)(i);
+      }
+    } catch (error) {
+      _chunkPYTHH6WOcjs.tracer.error("db:sql:batch_command:execute:error", { error });
+      throw _chunkSQXAAA3Ncjs.mapPostgresError.call(void 0, 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;
+    await client.query("BEGIN");
+  },
+  commit: async () => {
+    const client = await getClient;
+    try {
+      await client.query("COMMIT");
+    } finally {
+      if (_optionalChain([options, 'optionalAccess', _6 => _6.close])) await _optionalChain([options, 'optionalAccess', _7 => _7.close, 'call', _8 => _8(client)]);
+    }
+  },
+  rollback: async (error) => {
+    const client = await getClient;
+    try {
+      await client.query("ROLLBACK");
+    } finally {
+      if (_optionalChain([options, 'optionalAccess', _9 => _9.close])) await _optionalChain([options, 'optionalAccess', _10 => _10.close, 'call', _11 => _11(client, error)]);
+    }
+  },
+  execute: _chunkPYTHH6WOcjs.sqlExecutor.call(void 0, pgSQLExecutor({ serializer }), {
+    connect: () => getClient
+  })
+});
+
+// src/storage/postgresql/pg/connections/connection.ts
+var PgDriverType = "PostgreSQL:pg";
+var pgClientConnection = (options) => {
+  const { connect, close } = options;
+  return _chunkPYTHH6WOcjs.createConnection.call(void 0, {
+    driverType: PgDriverType,
+    connect,
+    close,
+    initTransaction: (connection) => pgTransaction(connection, options.serializer),
+    executor: pgSQLExecutor,
+    serializer: options.serializer
+  });
+};
+var pgPoolClientConnection = (options) => {
+  const { connect, close } = options;
+  return _chunkPYTHH6WOcjs.createConnection.call(void 0, {
+    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.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', _12 => _12.parseBigInts]) === true)
+    client.setTypeParser(20, (val) => BigInt(val));
+  if (_optionalChain([options, 'optionalAccess', _13 => _13.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 _chunkPYTHH6WOcjs.createConnectionPool.call(void 0, {
+    driverType: PgDriverType,
+    connection: open,
+    close,
+    getConnection
+  });
+};
+var pgAmbientNativePool = (options) => {
+  const { pool } = options;
+  return _chunkPYTHH6WOcjs.createConnectionPool.call(void 0, {
+    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 _chunkPYTHH6WOcjs.createAmbientConnectionPool.call(void 0, {
+    driverType: PgDriverType,
+    connection
+  });
+};
+var pgClientPool = (options) => {
+  const { connectionString, database } = options;
+  return _chunkPYTHH6WOcjs.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
+      });
+    }
+  });
+};
+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 _chunkPYTHH6WOcjs.createConnectionPool.call(void 0, {
+    driverType: PgDriverType,
+    connection: open,
+    close,
+    getConnection
+  });
+};
+function pgPool(options) {
+  const { connectionString, database } = options;
+  const serializer = _nullishCoalesce(_optionalChain([options, 'access', _14 => _14.serialization, 'optionalAccess', _15 => _15.serializer]), () => ( _chunkPYTHH6WOcjs.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(_chunkVIQJEUVFcjs.parseDatabaseName.call(void 0, poolOptions.connectionString), () => ( _chunkVIQJEUVFcjs.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)));
+};
+var endPgPool = async ({
+  connectionString,
+  database,
+  force
+}) => {
+  database = _nullishCoalesce(_nullishCoalesce(database, () => ( _chunkVIQJEUVFcjs.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);
+  }
+};
+var onEndPool = async (lookupKey, pool) => {
+  try {
+    await pool.end();
+  } catch (error) {
+    _chunkPYTHH6WOcjs.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, () => ( _chunkVIQJEUVFcjs.defaultPostgreSqlDatabase))}`;
+var updatePoolUsageCounter = (lookupKey, by) => {
+  const currentCounter = _nullishCoalesce(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 _chunkVIQJEUVFcjs.PostgreSQLConnectionString.call(void 0, connectionString);
+  } catch (e) {
+    return null;
+  }
+};
+var pgDumboDriver = {
+  driverType: PgDriverType,
+  createPool: (options) => pgPool(options),
+  sqlFormatter: _chunkSQXAAA3Ncjs.pgFormatter,
+  defaultMigratorOptions: _chunkSQXAAA3Ncjs.DefaultPostgreSQLMigratorOptions,
+  canHandle: _chunkPYTHH6WOcjs.canHandleDriverWithConnectionString.call(void 0, 
+    PgDriverType,
+    tryParseConnectionString
+  ),
+  databaseMetadata: _chunkVIQJEUVFcjs.postgreSQLMetadata
+};
+var usePgDumboDriver = () => {
+  _chunkPYTHH6WOcjs.dumboDatabaseDriverRegistry.register(PgDriverType, pgDumboDriver);
+};
+usePgDumboDriver();
 
 
 
 
 
 
-var _chunkISNF6USXcjs = require('./chunk-ISNF6USX.cjs');
-require('./chunk-OJ34O3Q2.cjs');
 
 
 
@@ -84,10 +455,5 @@ require('./chunk-OJ34O3Q2.cjs');
 
 
 
-
-
-
-
-
-exports.AdvisoryLock = _chunkISNF6USXcjs.AdvisoryLock; exports.DefaultPostgreSQLMigratorOptions = _chunkISNF6USXcjs.DefaultPostgreSQLMigratorOptions; exports.NodePostgresDriverType = _chunkISNF6USXcjs.NodePostgresDriverType; exports.PostgreSQLConnectionString = _chunkISNF6USXcjs.PostgreSQLConnectionString; exports.PostgreSQLDatabaseName = _chunkISNF6USXcjs.PostgreSQLDatabaseName; exports.acquireAdvisoryLock = _chunkISNF6USXcjs.acquireAdvisoryLock; exports.advisoryLock = _chunkISNF6USXcjs.advisoryLock; exports.checkConnection = _chunkISNF6USXcjs.checkConnection; exports.connectionPool = _chunkISNF6USXcjs.connectionPool; exports.databaseDriver = _chunkISNF6USXcjs.pgDatabaseDriver; exports.defaultPostgreSQLConnectionString = _chunkISNF6USXcjs.defaultPostgreSQLConnectionString; exports.defaultPostgreSqlDatabase = _chunkISNF6USXcjs.defaultPostgreSqlDatabase; exports.endAllPools = _chunkISNF6USXcjs.endAllPools; exports.endPool = _chunkISNF6USXcjs.endPool; exports.functionExists = _chunkISNF6USXcjs.functionExists; exports.functionExistsSQL = _chunkISNF6USXcjs.functionExistsSQL; exports.getDatabaseNameOrDefault = _chunkISNF6USXcjs.getDatabaseNameOrDefault; exports.getPool = _chunkISNF6USXcjs.getPool; exports.isNodePostgresClient = _chunkISNF6USXcjs.isNodePostgresClient; exports.isNodePostgresNativePool = _chunkISNF6USXcjs.isNodePostgresNativePool; exports.isNodePostgresPoolClient = _chunkISNF6USXcjs.isNodePostgresPoolClient; exports.nodePostgresAmbientClientPool = _chunkISNF6USXcjs.nodePostgresAmbientClientPool; exports.nodePostgresAmbientConnectionPool = _chunkISNF6USXcjs.nodePostgresAmbientConnectionPool; exports.nodePostgresAmbientNativePool = _chunkISNF6USXcjs.nodePostgresAmbientNativePool; exports.nodePostgresClientConnection = _chunkISNF6USXcjs.nodePostgresClientConnection; exports.nodePostgresClientPool = _chunkISNF6USXcjs.nodePostgresClientPool; exports.nodePostgresConnection = _chunkISNF6USXcjs.nodePostgresConnection; exports.nodePostgresExecute = _chunkISNF6USXcjs.nodePostgresExecute; exports.nodePostgresNativePool = _chunkISNF6USXcjs.nodePostgresNativePool; exports.nodePostgresPool = _chunkISNF6USXcjs.nodePostgresPool; exports.nodePostgresPoolClientConnection = _chunkISNF6USXcjs.nodePostgresPoolClientConnection; exports.nodePostgresSQLExecutor = _chunkISNF6USXcjs.nodePostgresSQLExecutor; exports.nodePostgresTransaction = _chunkISNF6USXcjs.nodePostgresTransaction; exports.onEndPool = _chunkISNF6USXcjs.onEndPool; exports.pgDatabaseDriver = _chunkISNF6USXcjs.pgDatabaseDriver; exports.pgFormatter = _chunkISNF6USXcjs.pgFormatter; exports.postgreSQLColumnProcessors = _chunkISNF6USXcjs.postgreSQLColumnProcessors; exports.postgresPool = _chunkISNF6USXcjs.postgresPool; exports.releaseAdvisoryLock = _chunkISNF6USXcjs.releaseAdvisoryLock; exports.setNodePostgresTypeParser = _chunkISNF6USXcjs.setNodePostgresTypeParser; exports.tableExists = _chunkISNF6USXcjs.tableExists; exports.tableExistsSQL = _chunkISNF6USXcjs.tableExistsSQL; exports.tryAcquireAdvisoryLock = _chunkISNF6USXcjs.tryAcquireAdvisoryLock; exports.usePgDatabaseDriver = _chunkISNF6USXcjs.usePgDatabaseDriver;
+exports.AdvisoryLock = _chunkSQXAAA3Ncjs.AdvisoryLock; exports.DefaultPostgreSQLMigratorOptions = _chunkSQXAAA3Ncjs.DefaultPostgreSQLMigratorOptions; exports.PgDriverType = PgDriverType; exports.PostgreSQLArrayProcessor = _chunkSQXAAA3Ncjs.PostgreSQLArrayProcessor; exports.PostgreSQLConnectionString = _chunkVIQJEUVFcjs.PostgreSQLConnectionString; exports.PostgreSQLDatabaseName = _chunkSQXAAA3Ncjs.PostgreSQLDatabaseName; exports.PostgreSQLExpandSQLInProcessor = _chunkSQXAAA3Ncjs.PostgreSQLExpandSQLInProcessor; exports.acquireAdvisoryLock = _chunkSQXAAA3Ncjs.acquireAdvisoryLock; exports.advisoryLock = _chunkSQXAAA3Ncjs.advisoryLock; exports.checkConnection = checkConnection; exports.defaultPostgreSQLConnectionString = _chunkVIQJEUVFcjs.defaultPostgreSQLConnectionString; exports.defaultPostgreSqlDatabase = _chunkVIQJEUVFcjs.defaultPostgreSqlDatabase; exports.endAllPgPools = endAllPgPools; exports.endPgPool = endPgPool; exports.functionExists = _chunkVIQJEUVFcjs.functionExists; exports.functionExistsSQL = _chunkVIQJEUVFcjs.functionExistsSQL; exports.getPgPool = getPgPool; exports.isPgClient = isPgClient; exports.isPgNativePool = isPgNativePool; exports.isPgPoolClient = isPgPoolClient; exports.mapPostgresError = _chunkSQXAAA3Ncjs.mapPostgresError; exports.onEndPool = onEndPool; exports.parseDatabaseName = _chunkVIQJEUVFcjs.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 = _chunkSQXAAA3Ncjs.pgFormatter; exports.pgNativePool = pgNativePool; exports.pgPool = pgPool; exports.pgPoolClientConnection = pgPoolClientConnection; exports.pgSQLExecutor = pgSQLExecutor; exports.pgTransaction = pgTransaction; exports.postgreSQLColumnProcessors = _chunkSQXAAA3Ncjs.postgreSQLColumnProcessors; exports.postgreSQLMetadata = _chunkVIQJEUVFcjs.postgreSQLMetadata; exports.releaseAdvisoryLock = _chunkSQXAAA3Ncjs.releaseAdvisoryLock; exports.setPgTypeParser = setPgTypeParser; exports.tableExists = _chunkVIQJEUVFcjs.tableExists; exports.tableExistsSQL = _chunkVIQJEUVFcjs.tableExistsSQL; exports.tryAcquireAdvisoryLock = _chunkSQXAAA3Ncjs.tryAcquireAdvisoryLock; exports.usePgDumboDriver = usePgDumboDriver;
 //# sourceMappingURL=pg.cjs.map