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

package/dist/pg.d.ts

@@ -1,171 +1,158 @@
-import { dv as DatabaseConnectionString, as as SQLExecutor, aC as AcquireDatabaseLockOptions, aD as ReleaseDatabaseLockOptions, aF as DatabaseLock, aA as DatabaseLockOptions, aB as AcquireDatabaseLockMode, M as MigratorOptions, cU as SQL, b as ConnectionPool, S as SQLFormatter, q as DatabaseDriverType, C as Connection, cy as JSONSerializer, D as DatabaseTransaction, v as AnyConnection, a as DatabaseTransactionOptions, c as DbSQLExecutor, d as DumboDatabaseDriver } from './connectionString-B1wm0TFc.js';
-import pg from 'pg';
-import { D as DefaultSQLColumnProcessors } from './columnProcessors-DMPpTPqM.js';
+import { D as Connection, E as AnyConnection, Gt as DbSQLExecutor, K as DatabaseTransaction, co as JSONSerializer, ft as DumboDatabaseDriver, oo as JSONSerializationOptions, p as ConnectionPool, q as DatabaseTransactionOptions, r as postgreSQLMetadata } from "./index-CRbkvVjT.js";
+import { _ as tryAcquireAdvisoryLock, a as PostgreSQLExpandSQLInProcessor, b as defaultPostgreSQLConnectionString, c as functionExists, d as tableExistsSQL, f as DefaultPostgreSQLMigratorOptions, g as releaseAdvisoryLock, h as advisoryLock, i as PostgreSQLArrayProcessor, l as functionExistsSQL, m as acquireAdvisoryLock, n as PostgreSQLDriverType, o as pgFormatter, p as AdvisoryLock, r as postgreSQLColumnProcessors, s as defaultPostgreSqlDatabase, t as PostgreSQLDatabaseName, u as tableExists, v as mapPostgresError, x as parseDatabaseName, y as PostgreSQLConnectionString } from "./index-BJJAkyuJ.js";
+import pg from "pg";
 
-declare const defaultPostgreSQLConnectionString: PostgreSQLConnectionString;
-declare const getDatabaseNameOrDefault: (connectionString: string) => string;
-type PostgreSQLConnectionString = DatabaseConnectionString<'PostgreSQL', `postgresql://${string}` | `postgres://${string}`>;
-declare const PostgreSQLConnectionString: (connectionString: string) => PostgreSQLConnectionString;
-
-declare const tryAcquireAdvisoryLock: (execute: SQLExecutor, options: AcquireDatabaseLockOptions) => Promise<boolean>;
-declare const releaseAdvisoryLock: (execute: SQLExecutor, options: ReleaseDatabaseLockOptions) => Promise<boolean>;
-declare const acquireAdvisoryLock: (execute: SQLExecutor, options: AcquireDatabaseLockOptions) => Promise<void>;
-declare const AdvisoryLock: DatabaseLock;
-declare const advisoryLock: (execute: SQLExecutor, options: DatabaseLockOptions) => {
-    acquire: (acquireOptions?: {
-        mode: AcquireDatabaseLockMode;
-    }) => Promise<void>;
-    tryAcquire: (acquireOptions?: {
-        mode: AcquireDatabaseLockMode;
-    }) => Promise<boolean>;
-    release: () => Promise<boolean>;
-    withAcquire: <Result>(handle: () => Promise<Result>, acquireOptions?: {
-        mode: AcquireDatabaseLockMode;
-    }) => Promise<Result>;
+//#region src/storage/postgresql/pg/connections/transaction.d.ts
+type PgTransaction = DatabaseTransaction<PgConnection, PgTransactionOptions>;
+type PgIsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SERIALIZABLE';
+type PgTransactionOptions = DatabaseTransactionOptions & {
+  isolationLevel?: PgIsolationLevel;
 };
-
-declare const DefaultPostgreSQLMigratorOptions: MigratorOptions;
-
-declare const defaultPostgreSqlDatabase = "postgres";
-declare const tableExistsSQL: (tableName: string) => SQL;
-declare const tableExists: (pool: ConnectionPool, tableName: string) => Promise<boolean>;
-declare const functionExistsSQL: (functionName: string) => SQL;
-declare const functionExists: (pool: ConnectionPool, tableName: string) => Promise<boolean>;
-
-declare const pgFormatter: SQLFormatter;
-
-declare const postgreSQLColumnProcessors: DefaultSQLColumnProcessors;
-
-type PostgreSQLDatabaseName = 'PostgreSQL';
-declare const PostgreSQLDatabaseName = "PostgreSQL";
-type PostgreSQLDriverType<DriverName extends string = string> = DatabaseDriverType<PostgreSQLDatabaseName, DriverName>;
-
-type NodePostgresDriverType = PostgreSQLDriverType<'pg'>;
-declare const NodePostgresDriverType: NodePostgresDriverType;
-type NodePostgresPoolClient = pg.PoolClient;
-type NodePostgresClient = pg.Client;
-type NodePostgresClientOrPoolClient = NodePostgresPoolClient | NodePostgresClient;
-type NodePostgresPoolOrClient = pg.Pool | NodePostgresPoolClient | NodePostgresClient;
-type NodePostgresClientConnection = Connection<NodePostgresClientConnection, NodePostgresDriverType, NodePostgresClient>;
-type NodePostgresPoolClientConnection = Connection<NodePostgresPoolClientConnection, NodePostgresDriverType, NodePostgresPoolClient>;
-type NodePostgresConnection = NodePostgresPoolClientConnection | NodePostgresClientConnection;
-type NodePostgresPoolClientOptions = {
-    type: 'PoolClient';
-    connect: () => Promise<NodePostgresPoolClient>;
-    close: (client: NodePostgresPoolClient) => Promise<void>;
+declare const pgTransaction: <ConnectionType extends AnyConnection = AnyConnection>(connection: () => ConnectionType, serializer: JSONSerializer) => <DbClient extends PgPoolOrClient = PgPoolOrClient>(getClient: Promise<DbClient>, options?: {
+  close: (client: DbClient, error?: unknown) => Promise<void>;
+} & PgTransactionOptions) => DatabaseTransaction<ConnectionType>;
+//#endregion
+//#region src/storage/postgresql/pg/connections/connection.d.ts
+type PgDriverType = PostgreSQLDriverType<'pg'>;
+declare const PgDriverType: PgDriverType;
+type PgPoolClient = pg.PoolClient;
+type PgClient = pg.Client;
+type PgClientOrPoolClient = PgPoolClient | PgClient;
+type PgPoolOrClient = pg.Pool | PgPoolClient | PgClient;
+type PgClientConnection = Connection<PgClientConnection, PgDriverType, PgClient, DatabaseTransaction<PgClientConnection, PgTransactionOptions>>;
+type PgPoolClientConnection = Connection<PgPoolClientConnection, PgDriverType, PgPoolClient, DatabaseTransaction<PgPoolClientConnection, PgTransactionOptions>>;
+type PgConnection = PgPoolClientConnection | PgClientConnection;
+type PgPoolClientOptions = {
+  type: 'PoolClient';
+  connect: () => Promise<PgPoolClient>;
+  close: (client: PgPoolClient) => Promise<void>;
+};
+type PgClientOptions = {
+  type: 'Client';
+  connect: () => Promise<PgClient>;
+  close: (client: PgClient) => Promise<void>;
+};
+type PgClientConnectionOptions = PgClientOptions & {
+  serializer: JSONSerializer;
 };
-type NodePostgresClientOptions = {
-    type: 'Client';
-    connect: () => Promise<NodePostgresClient>;
-    close: (client: NodePostgresClient) => Promise<void>;
+type PgPoolClientConnectionOptions = PgPoolClientOptions & {
+  serializer: JSONSerializer;
 };
-declare const nodePostgresClientConnection: (options: NodePostgresClientOptions) => NodePostgresClientConnection;
-declare const nodePostgresPoolClientConnection: (options: NodePostgresPoolClientOptions) => NodePostgresPoolClientConnection;
-declare function nodePostgresConnection(options: NodePostgresPoolClientOptions): NodePostgresPoolClientConnection;
-declare function nodePostgresConnection(options: NodePostgresClientOptions): NodePostgresClientConnection;
+declare const pgClientConnection: (options: PgClientConnectionOptions) => PgClientConnection;
+declare const pgPoolClientConnection: (options: PgPoolClientConnectionOptions) => PgPoolClientConnection;
+type PgConnectionOptions = PgPoolClientConnectionOptions | PgClientConnectionOptions;
+declare function pgConnection(options: PgPoolClientConnectionOptions): PgPoolClientConnection;
+declare function pgConnection(options: PgClientConnectionOptions): PgClientConnection;
 type ConnectionCheckResult = {
-    successful: true;
+  successful: true;
 } | {
-    successful: false;
-    code: string | undefined;
-    errorType: 'ConnectionRefused' | 'Authentication' | 'Unknown';
-    error: unknown;
+  successful: false;
+  code: string | undefined;
+  errorType: 'ConnectionRefused' | 'Authentication' | 'Unknown';
+  error: unknown;
 };
 declare const checkConnection: (connectionString: string) => Promise<ConnectionCheckResult>;
-
-type NodePostgresNativePool = ConnectionPool<NodePostgresPoolClientConnection>;
-type NodePostgresAmbientClientPool = ConnectionPool<NodePostgresClientConnection>;
-type NodePostgresAmbientConnectionPool = ConnectionPool<NodePostgresPoolClientConnection | NodePostgresClientConnection>;
-type NodePostgresPool = NodePostgresNativePool | NodePostgresAmbientClientPool | NodePostgresAmbientConnectionPool;
-declare const nodePostgresNativePool: (options: {
-    connectionString: string;
-    database?: string | undefined;
-}) => NodePostgresNativePool;
-declare const nodePostgresAmbientNativePool: (options: {
-    pool: pg.Pool;
-}) => NodePostgresNativePool;
-declare const nodePostgresAmbientConnectionPool: (options: {
-    connection: NodePostgresPoolClientConnection | NodePostgresClientConnection;
-}) => NodePostgresAmbientConnectionPool;
-declare const nodePostgresClientPool: (options: {
-    connectionString: string;
-    database?: string | undefined;
-}) => NodePostgresAmbientClientPool;
-declare const nodePostgresAmbientClientPool: (options: {
-    client: pg.Client;
-}) => NodePostgresAmbientClientPool;
-type NodePostgresPoolPooledOptions = {
-    connectionString: string;
-    database?: string;
-    pooled: true;
-    pool: pg.Pool;
+//#endregion
+//#region src/storage/postgresql/pg/connections/pool.d.ts
+type PgNativePool = ConnectionPool<PgPoolClientConnection>;
+type PgAmbientClientPool = ConnectionPool<PgClientConnection>;
+type PgAmbientConnectionPool = ConnectionPool<PgPoolClientConnection | PgClientConnection>;
+type PgPool = PgNativePool | PgAmbientClientPool | PgAmbientConnectionPool;
+declare const pgNativePool: (options: {
+  connectionString: string;
+  database?: string | undefined;
+  serializer: JSONSerializer;
+}) => PgNativePool;
+declare const pgAmbientNativePool: (options: {
+  pool: pg.Pool;
+  serializer: JSONSerializer;
+}) => PgNativePool;
+declare const pgAmbientConnectionPool: (options: {
+  connection: PgPoolClientConnection | PgClientConnection;
+}) => PgAmbientConnectionPool;
+declare const pgClientPool: (options: {
+  connectionString: string;
+  database?: string | undefined;
+  serializer: JSONSerializer;
+}) => PgAmbientClientPool;
+declare const pgAmbientClientPool: (options: {
+  client: pg.Client;
+  serializer: JSONSerializer;
+}) => PgAmbientClientPool;
+type PgPoolPooledOptions = {
+  connectionString: string;
+  database?: string;
+  pooled: true;
+  pool: pg.Pool;
 } | {
-    connectionString: string;
-    database?: string;
-    pool: pg.Pool;
+  connectionString: string;
+  database?: string;
+  pool: pg.Pool;
 } | {
-    connectionString: string;
-    database?: string;
-    pooled: true;
+  connectionString: string;
+  database?: string;
+  pooled: true;
 } | {
-    connectionString: string;
-    database?: string;
+  connectionString: string;
+  database?: string;
 };
-type NodePostgresPoolNotPooledOptions = {
-    connectionString: string;
-    database?: string;
-    pooled: false;
-    client: pg.Client;
+type PgPoolNotPooledOptions = {
+  connectionString: string;
+  database?: string;
+  pooled: false;
+  client: pg.Client;
 } | {
-    connectionString: string;
-    database?: string;
-    client: pg.Client;
+  connectionString: string;
+  database?: string;
+  client: pg.Client;
 } | {
-    connectionString: string;
-    database?: string;
-    pooled: false;
+  connectionString: string;
+  database?: string;
+  pooled: false;
 } | {
-    connectionString: string;
-    database?: string;
-    connection: NodePostgresPoolClientConnection | NodePostgresClientConnection;
-    pooled?: false;
-};
-type NodePostgresPoolOptions = (NodePostgresPoolPooledOptions | NodePostgresPoolNotPooledOptions) & {
-    serializer?: JSONSerializer;
+  connectionString: string;
+  database?: string;
+  connection: PgPoolClientConnection | PgClientConnection;
+  pooled?: false;
 };
-declare function nodePostgresPool(options: NodePostgresPoolPooledOptions): NodePostgresNativePool;
-declare function nodePostgresPool(options: NodePostgresPoolNotPooledOptions): NodePostgresAmbientClientPool;
-declare const getPool: (connectionStringOrOptions: string | pg.PoolConfig) => pg.Pool;
-declare const endPool: ({ connectionString, database, force, }: {
-    connectionString: string;
-    database?: string | undefined;
-    force?: boolean;
+type PgPoolOptions = (PgPoolPooledOptions | PgPoolNotPooledOptions) & JSONSerializationOptions;
+declare function pgPool(options: PgPoolPooledOptions): PgNativePool;
+declare function pgPool(options: PgPoolNotPooledOptions): PgAmbientClientPool;
+declare const getPgPool: (connectionStringOrOptions: string | pg.PoolConfig) => pg.Pool;
+declare const endPgPool: ({
+  connectionString,
+  database,
+  force
+}: {
+  connectionString: string;
+  database?: string | undefined;
+  force?: boolean;
 }) => Promise<void>;
 declare const onEndPool: (lookupKey: string, pool: pg.Pool) => Promise<void>;
-declare const endAllPools: () => Promise<void[]>;
-
-type NodePostgresTransaction = DatabaseTransaction<NodePostgresConnection>;
-declare const nodePostgresTransaction: <ConnectionType extends AnyConnection = AnyConnection>(connection: () => ConnectionType) => <DbClient extends NodePostgresPoolOrClient = NodePostgresPoolOrClient>(getClient: Promise<DbClient>, options?: {
-    close: (client: DbClient, error?: unknown) => Promise<void>;
-} & DatabaseTransactionOptions) => DatabaseTransaction<ConnectionType>;
-
-declare const isNodePostgresNativePool: (poolOrClient: pg.Pool | pg.PoolClient | pg.Client) => poolOrClient is pg.Pool;
-declare const isNodePostgresClient: (poolOrClient: pg.Pool | pg.PoolClient | pg.Client) => poolOrClient is pg.Client;
-declare const isNodePostgresPoolClient: (poolOrClient: pg.Pool | pg.PoolClient | pg.Client) => poolOrClient is pg.PoolClient;
-declare const nodePostgresExecute: <Result = void>(poolOrClient: pg.Pool | pg.PoolClient | pg.Client, handle: (client: pg.PoolClient | pg.Client) => Promise<Result>) => Promise<Result>;
-type NodePostgresSQLExecutor = DbSQLExecutor<NodePostgresDriverType, NodePostgresClientOrPoolClient>;
-declare const nodePostgresSQLExecutor: () => NodePostgresSQLExecutor;
-
-declare const setNodePostgresTypeParser: (jsonSerializer: JSONSerializer) => void;
-
-declare const pgDatabaseDriver: DumboDatabaseDriver<NodePostgresConnection, NodePostgresPoolOptions>;
-declare const usePgDatabaseDriver: () => void;
-
-type PostgresDriverType = NodePostgresDriverType;
-type PostgresPool = NodePostgresPool;
-type PostgresConnection = NodePostgresConnection;
-type PostgresPoolOptions = NodePostgresPoolOptions;
-declare const postgresPool: typeof nodePostgresPool;
-declare const connectionPool: typeof nodePostgresPool;
-
-export { AdvisoryLock, type ConnectionCheckResult, DefaultPostgreSQLMigratorOptions, type NodePostgresAmbientClientPool, type NodePostgresAmbientConnectionPool, type NodePostgresClient, type NodePostgresClientConnection, type NodePostgresClientOptions, type NodePostgresClientOrPoolClient, type NodePostgresConnection, NodePostgresDriverType, type NodePostgresNativePool, type NodePostgresPool, type NodePostgresPoolClient, type NodePostgresPoolClientConnection, type NodePostgresPoolClientOptions, type NodePostgresPoolNotPooledOptions, type NodePostgresPoolOptions, type NodePostgresPoolOrClient, type NodePostgresPoolPooledOptions, type NodePostgresSQLExecutor, type NodePostgresTransaction, PostgreSQLConnectionString, PostgreSQLDatabaseName, type PostgreSQLDriverType, type PostgresConnection, type PostgresDriverType, type PostgresPool, type PostgresPoolOptions, 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 };
+declare const endAllPgPools: () => Promise<void[]>;
+//#endregion
+//#region src/storage/postgresql/pg/execute/execute.d.ts
+declare const isPgNativePool: (poolOrClient: pg.Pool | pg.PoolClient | pg.Client) => poolOrClient is pg.Pool;
+declare const isPgClient: (poolOrClient: pg.Pool | pg.PoolClient | pg.Client) => poolOrClient is pg.Client;
+declare const isPgPoolClient: (poolOrClient: pg.Pool | pg.PoolClient | pg.Client) => poolOrClient is pg.PoolClient;
+declare const pgExecute: <Result = void>(poolOrClient: pg.Pool | pg.PoolClient | pg.Client, handle: (client: pg.PoolClient | pg.Client) => Promise<Result>) => Promise<Result>;
+type PgSQLExecutor = DbSQLExecutor<PgDriverType, PgClientOrPoolClient>;
+declare const pgSQLExecutor: ({
+  serializer
+}: {
+  serializer: JSONSerializer;
+}) => PgSQLExecutor;
+//#endregion
+//#region src/storage/postgresql/pg/serialization/index.d.ts
+declare const setPgTypeParser: (client: pg.Client | pg.PoolClient, options?: {
+  parseBigInts?: boolean;
+  serializer: JSONSerializer;
+}) => void;
+//#endregion
+//#region src/storage/postgresql/pg/index.d.ts
+declare const pgDumboDriver: DumboDatabaseDriver<PgConnection, PgPoolOptions, PgPool>;
+declare const usePgDumboDriver: () => void;
+type PgDumboOptions = PgPoolOptions;
+//#endregion
+export { AdvisoryLock, ConnectionCheckResult, DefaultPostgreSQLMigratorOptions, PgAmbientClientPool, PgAmbientConnectionPool, PgClient, PgClientConnection, PgClientConnectionOptions, PgClientOptions, PgClientOrPoolClient, PgConnection, PgConnectionOptions, PgDriverType, PgDumboOptions, PgIsolationLevel, PgNativePool, PgPool, PgPoolClient, PgPoolClientConnection, PgPoolClientConnectionOptions, PgPoolClientOptions, PgPoolNotPooledOptions, PgPoolOptions, PgPoolOrClient, PgPoolPooledOptions, PgSQLExecutor, PgTransaction, PgTransactionOptions, PostgreSQLArrayProcessor, PostgreSQLConnectionString, PostgreSQLDatabaseName, PostgreSQLDriverType, 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.d.ts.map