@event-driven-io/dumbo 0.12.1 → 0.13.0-alpha.2

package/dist/index.d.ts

@@ -1,13 +1,7 @@
+import { Q as QueryResultRow, d as QueryResult, S as SQLExecutor, e as SQL, a as ConnectionPool, C as Connection, J as JSONSerializer, b as DatabaseTransaction, D as DbSQLExecutor } from './index-C0xy8dwZ.js';
+export { f as ConnectionFactory, i as ConnectionPoolFactory, c as ConnectorTypeName, p as ConnectorTypeParts, g as CreateConnectionOptions, o as DatabaseDriverName, k as DatabaseTransactionFactory, n as DatabaseType, L as JSONObjectCodec, M as JSONObjectCodecOptions, F as JSONReplacer, G as JSONReplacers, H as JSONReviver, I as JSONRevivers, O as ObjectCodec, R as RawJSONSerializer, v as SQLCommandOptions, u as SQLQueryOptions, A as Serializer, T as TransactionResult, W as WithSQLExecutor, B as composeJSONReplacers, E as composeJSONRevivers, h as createConnection, j as createConnectionPool, z as executeInNewConnection, y as executeInNewDbClient, l as executeInTransaction, r as fromConnectorType, s as getDriverName, N as identifier, P as isSQL, K as jsonSerializer, U as literal, V as plainString, X as rawSql, Y as sql, w as sqlExecutor, x as sqlExecutorInNewConnection, q as toConnectorType, t as transactionFactoryWithDbClient, m as transactionFactoryWithNewConnection } from './index-C0xy8dwZ.js';
 import pg from 'pg';
 
-interface QueryResultRow {
-    [column: string]: any;
-}
-type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
-    rowCount: number | null;
-    rows: Result[];
-};
-
 declare const mapRows: <Result extends QueryResultRow = QueryResultRow, Mapped = unknown>(getResult: Promise<QueryResult<Result>>, map: (row: Result) => Mapped) => Promise<Mapped[]>;
 declare const toCamelCase: (snakeStr: string) => string;
 declare const mapToCamelCase: <T extends Record<string, unknown>>(obj: Record<string, unknown>) => T;
@@ -25,109 +19,6 @@ type ExistsSQLQueryResult = {
 };
 declare const exists: (getResult: Promise<QueryResult<ExistsSQLQueryResult>>) => Promise<boolean>;
 
-declare const sql: (sqlQuery: string, ...params: unknown[]) => SQL;
-declare const rawSql: (sqlQuery: string) => SQL;
-declare const isSQL: (literal: unknown) => literal is SQL;
-declare const literal: (value: unknown) => {
-    type: string;
-    value: unknown;
-};
-declare const identifier: (value: string) => {
-    type: string;
-    value: string;
-};
-declare const plainString: (value: string) => {
-    type: string;
-    value: string;
-};
-type SQL = string & {
-    __brand: 'sql';
-};
-declare function SQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
-
-type SQLQueryOptions = {
-    timeoutMs?: number;
-};
-type SQLCommandOptions = {
-    timeoutMs?: number;
-};
-interface DbSQLExecutor<ConnectorType extends string = string, DbClient = unknown> {
-    type: ConnectorType;
-    query<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sql: SQL, options?: SQLQueryOptions): Promise<QueryResult<Result>>;
-    batchQuery<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sqls: SQL[], options?: SQLQueryOptions): Promise<QueryResult<Result>[]>;
-    command<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sql: SQL, options?: SQLCommandOptions): Promise<QueryResult<Result>>;
-    batchCommand<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sqls: SQL[], options?: SQLCommandOptions): Promise<QueryResult<Result>[]>;
-}
-interface SQLExecutor {
-    query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: SQLQueryOptions): Promise<QueryResult<Result>>;
-    batchQuery<Result extends QueryResultRow = QueryResultRow>(sqls: SQL[], options?: SQLQueryOptions): Promise<QueryResult<Result>[]>;
-    command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: SQLCommandOptions): Promise<QueryResult<Result>>;
-    batchCommand<Result extends QueryResultRow = QueryResultRow>(sqls: SQL[], options?: SQLCommandOptions): Promise<QueryResult<Result>[]>;
-}
-interface WithSQLExecutor {
-    execute: SQLExecutor;
-}
-declare const sqlExecutor: <DbClient = unknown, DbExecutor extends DbSQLExecutor = DbSQLExecutor<string, unknown>>(sqlExecutor: DbExecutor, options: {
-    connect: () => Promise<DbClient>;
-    close?: (client: DbClient, error?: unknown) => Promise<void>;
-}) => SQLExecutor;
-declare const sqlExecutorInNewConnection: <ConnectionType extends Connection>(options: {
-    connection: () => Promise<ConnectionType>;
-}) => SQLExecutor;
-declare const executeInNewDbClient: <DbClient = unknown, Result = unknown>(handle: (client: DbClient) => Promise<Result>, options: {
-    connect: () => Promise<DbClient>;
-    close?: (client: DbClient, error?: unknown) => Promise<void>;
-}) => Promise<Result>;
-declare const executeInNewConnection: <ConnectionType extends Connection, Result>(handle: (connection: ConnectionType) => Promise<Result>, options: {
-    connection: () => Promise<ConnectionType>;
-}) => Promise<Result>;
-
-interface DatabaseTransaction<ConnectorType extends string = string, DbClient = unknown> extends WithSQLExecutor {
-    type: ConnectorType;
-    connection: Connection<ConnectorType, DbClient>;
-    begin: () => Promise<void>;
-    commit: () => Promise<void>;
-    rollback: (error?: unknown) => Promise<void>;
-}
-interface DatabaseTransactionFactory<ConnectorType extends string = string, DbClient = unknown> {
-    transaction: () => DatabaseTransaction<ConnectorType, DbClient>;
-    withTransaction: <Result = never>(handle: (transaction: DatabaseTransaction<ConnectorType, DbClient>) => Promise<TransactionResult<Result> | Result>) => Promise<Result>;
-}
-type TransactionResult<Result> = {
-    success: boolean;
-    result: Result;
-};
-declare const executeInTransaction: <ConnectorType extends string = string, DbClient = unknown, Result = void>(transaction: DatabaseTransaction<ConnectorType, DbClient>, handle: (transaction: DatabaseTransaction<ConnectorType, DbClient>) => Promise<TransactionResult<Result> | Result>) => Promise<Result>;
-declare const transactionFactoryWithDbClient: <ConnectorType extends string = string, DbClient = unknown>(connect: () => Promise<DbClient>, initTransaction: (client: Promise<DbClient>) => DatabaseTransaction<ConnectorType, DbClient>) => DatabaseTransactionFactory<ConnectorType, DbClient>;
-declare const transactionFactoryWithNewConnection: <ConnectionType extends Connection = Connection<string, unknown>>(connect: () => ConnectionType) => DatabaseTransactionFactory<ConnectionType["type"]>;
-
-interface Connection<ConnectorType extends string = string, DbClient = unknown> extends WithSQLExecutor, DatabaseTransactionFactory<ConnectorType> {
-    type: ConnectorType;
-    open: () => Promise<DbClient>;
-    close: () => Promise<void>;
-}
-interface ConnectionFactory<ConnectionType extends Connection = Connection> {
-    connection: () => Promise<ConnectionType>;
-    withConnection: <Result = unknown>(handle: (connection: ConnectionType) => Promise<Result>) => Promise<Result>;
-}
-type CreateConnectionOptions<ConnectorType extends string = string, DbClient = unknown, ConnectionType extends Connection<ConnectorType, DbClient> = Connection<ConnectorType, DbClient>, Executor extends DbSQLExecutor = DbSQLExecutor> = {
-    type: ConnectorType;
-    connect: Promise<DbClient>;
-    close: (client: DbClient) => Promise<void>;
-    initTransaction: (connection: () => ConnectionType) => (client: Promise<DbClient>) => DatabaseTransaction<ConnectorType, DbClient>;
-    executor: () => Executor;
-};
-declare const createConnection: <ConnectorType extends string = string, DbClient = unknown, ConnectionType extends Connection<ConnectorType, DbClient> = Connection<ConnectorType, DbClient>, Executor extends DbSQLExecutor = DbSQLExecutor<string, unknown>>(options: CreateConnectionOptions<ConnectorType, DbClient, ConnectionType, Executor>) => ConnectionType;
-
-interface ConnectionPool<ConnectionType extends Connection = Connection> extends WithSQLExecutor, ConnectionFactory<ConnectionType>, DatabaseTransactionFactory<ConnectionType['type']> {
-    type: ConnectionType['type'];
-    close: () => Promise<void>;
-}
-type ConnectionPoolFactory<ConnectionPoolType extends ConnectionPool = ConnectionPool, ConnectionPoolOptions = unknown> = (options: ConnectionPoolOptions) => ConnectionPoolType;
-declare const createConnectionPool: <ConnectionType extends Connection, ConnectionPoolType extends ConnectionPool<ConnectionType>>(pool: Pick<ConnectionPool<ConnectionType>, "type"> & Partial<ConnectionPool<ConnectionType>> & {
-    getConnection: () => ConnectionType;
-}) => ConnectionPoolType;
-
 type MigrationStyle = 'None' | 'CreateOrUpdate';
 type SQLMigration = {
     name: string;
@@ -172,54 +63,6 @@ declare const schemaComponent: (type: string, migrationsOrComponents: {
     components: ReadonlyArray<SchemaComponent>;
 }) => SchemaComponent;
 
-type JSONSerializerOptions = {
-    disableBigIntSerialization?: boolean;
-};
-type JSONSerializeOptions = {
-    replacer?: JSONReplacer;
-} & JSONSerializerOptions;
-type JSONDeserializeOptions = {
-    reviver?: JSONReviver;
-} & JSONSerializerOptions;
-type JSONObjectCodecOptions<SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> = {
-    serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
-} | {
-    serializerOptions?: JSONSerializerOptions;
-};
-declare const composeJSONReplacers: (...replacers: JSONReplacer[]) => JSONReplacer;
-declare const composeJSONRevivers: (...revivers: JSONReviver[]) => JSONReviver;
-type JSONReplacer = (this: any, key: string, value: any) => any;
-declare const JSONReplacer: (opts?: JSONSerializeOptions) => JSONReplacer | undefined;
-type JSONReviver = (this: any, key: string, value: any) => any;
-declare const JSONReviver: (opts?: JSONDeserializeOptions) => JSONReviver | undefined;
-declare const JSONReplacers: {
-    bigInt: JSONReplacer;
-};
-declare const JSONRevivers: {
-    bigInt: JSONReviver;
-};
-declare const jsonSerializer: (options?: JSONSerializerOptions) => JSONSerializer;
-interface JSONSerializer<SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> extends Serializer<string, SerializeOptions, DeserializeOptions> {
-    serialize<T>(object: T, options?: SerializeOptions): string;
-    deserialize<T>(payload: string, options?: DeserializeOptions): T;
-}
-declare const JSONSerializer: JSONSerializer<JSONSerializeOptions, JSONDeserializeOptions>;
-declare const RawJSONSerializer: JSONSerializer<JSONSerializeOptions, JSONDeserializeOptions>;
-interface JSONObjectCodec<T, SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> extends ObjectCodec<T, string> {
-    encode(object: T, options?: SerializeOptions): string;
-    decode(payload: string, options?: DeserializeOptions): T;
-}
-declare const JSONObjectCodec: <T, SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions>(options: JSONObjectCodecOptions<SerializeOptions, DeserializeOptions>) => JSONObjectCodec<T, SerializeOptions, DeserializeOptions>;
-
-interface Serializer<Payload, SerializeOptions = never, DeserializeOptions = SerializeOptions> {
-    serialize<T>(object: T, options?: SerializeOptions): Payload;
-    deserialize<T>(payload: Payload, options?: DeserializeOptions): T;
-}
-interface ObjectCodec<T, Payload> {
-    encode(object: T): Payload;
-    decode(payload: Payload): T;
-}
-
 declare const color: {
     level: 0 | 1;
     hex: (value: string) => (text: string) => string;
@@ -310,20 +153,22 @@ declare const advisoryLock: (execute: SQLExecutor, options: DatabaseLockOptions)
 
 declare const NodePostgresConnectorType = "PostgreSQL:pg";
 type NodePostgresConnector = 'PostgreSQL:pg';
-type NodePostgresClient = pg.PoolClient | pg.Client;
-type NodePostgresPoolOrClient = pg.Pool | pg.PoolClient | pg.Client;
-type NodePostgresClientConnection = Connection<NodePostgresConnector, pg.Client>;
-type NodePostgresPoolClientConnection = Connection<NodePostgresConnector, pg.PoolClient>;
+type NodePostgresPoolClient = pg.PoolClient;
+type NodePostgresClient = pg.Client;
+type NodePostgresClientOrPoolClient = NodePostgresPoolClient | NodePostgresClient;
+type NodePostgresPoolOrClient = pg.Pool | NodePostgresPoolClient | NodePostgresClient;
+type NodePostgresClientConnection = Connection<NodePostgresConnector, NodePostgresClient>;
+type NodePostgresPoolClientConnection = Connection<NodePostgresConnector, NodePostgresPoolClient>;
 type NodePostgresConnection = NodePostgresPoolClientConnection | NodePostgresClientConnection;
 type NodePostgresPoolClientOptions = {
     type: 'PoolClient';
-    connect: Promise<pg.PoolClient>;
-    close: (client: pg.PoolClient) => Promise<void>;
+    connect: Promise<NodePostgresPoolClient>;
+    close: (client: NodePostgresPoolClient) => Promise<void>;
 };
 type NodePostgresClientOptions = {
     type: 'Client';
-    connect: Promise<pg.Client>;
-    close: (client: pg.Client) => Promise<void>;
+    connect: Promise<NodePostgresClient>;
+    close: (client: NodePostgresClient) => Promise<void>;
 };
 declare const nodePostgresClientConnection: (options: NodePostgresClientOptions) => NodePostgresClientConnection;
 declare const nodePostgresPoolClientConnection: (options: NodePostgresPoolClientOptions) => NodePostgresPoolClientConnection;
@@ -427,7 +272,7 @@ declare const isNodePostgresNativePool: (poolOrClient: pg.Pool | pg.PoolClient |
 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<NodePostgresConnector, NodePostgresClient>;
+type NodePostgresSQLExecutor = DbSQLExecutor<NodePostgresConnector, NodePostgresClientOrPoolClient>;
 declare const nodePostgresSQLExecutor: () => NodePostgresSQLExecutor;
 type BatchQueryOptions = {
     timeoutMs?: number;
@@ -450,4 +295,4 @@ type Dumbo = PostgresPool;
 declare const connectionPool: <PoolOptionsType extends DumboOptions>(options: PoolOptionsType) => NodePostgresNativePool;
 declare const dumbo: <DumboOptionsType extends DumboOptions = DumboOptions>(options: DumboOptionsType) => Dumbo;
 
-export { type AcquireDatabaseLockMode, type AcquireDatabaseLockOptions, AdvisoryLock, type BatchQueryOptions, type Connection, type ConnectionCheckResult, type ConnectionFactory, type ConnectionPool, type ConnectionPoolFactory, type ConnectorType, type CountSQLQueryResult, type CreateConnectionOptions, type DatabaseLock, type DatabaseLockOptions, type DatabaseTransaction, type DatabaseTransactionFactory, type DbSQLExecutor, type Dumbo, type DumboOptions, type ExistsSQLQueryResult, JSONObjectCodec, type JSONObjectCodecOptions, JSONReplacer, JSONReplacers, JSONReviver, JSONRevivers, JSONSerializer, LogLevel, LogStyle, type LogType, MIGRATIONS_LOCK_ID, type MigrationRecord, type MigrationStyle, type MigratorOptions, type NodePostgresAmbientClientPool, type NodePostgresAmbientConnectionPool, type NodePostgresClient, type NodePostgresClientConnection, type NodePostgresClientOptions, type NodePostgresConnection, type NodePostgresConnector, NodePostgresConnectorType, type NodePostgresNativePool, type NodePostgresPool, type NodePostgresPoolClientConnection, type NodePostgresPoolClientOptions, type NodePostgresPoolNotPooledOptions, type NodePostgresPoolOptions, type NodePostgresPoolOrClient, type NodePostgresPoolPooledOptions, type NodePostgresSQLExecutor, type NodePostgresTransaction, type ObjectCodec, type PoolOptions, type PostgreSQLMigratorOptions, type PostgresConnection, type PostgresConnector, type PostgresPool, type PostgresPoolOptions, type QueryResult, type QueryResultRow, RawJSONSerializer, type ReleaseDatabaseLockOptions, SQL, type SQLCommandOptions, type SQLExecutor, type SQLMigration, type SQLQueryOptions, type SchemaComponent, type SchemaComponentMigrationsOptions, type Serializer, type TransactionResult, type WithSQLExecutor, acquireAdvisoryLock, advisoryLock, checkConnection, color, combineMigrations, composeJSONReplacers, composeJSONRevivers, connectionPool, count, createConnection, createConnectionPool, defaultDatabaseLockOptions, defaultPostgreSQLConenctionString, defaultPostgreSqlDatabase, dumbo, endAllPools, endPool, executeInNewConnection, executeInNewDbClient, executeInTransaction, exists, first, firstOrNull, functionExists, functionExistsSQL, getDatabaseNameOrDefault, getPool, identifier, isNodePostgresClient, isNodePostgresNativePool, isNodePostgresPoolClient, isSQL, jsonSerializer, literal, mapRows, mapToCamelCase, migrationTableSchemaComponent, nodePostgresAmbientClientPool, nodePostgresAmbientConnectionPool, nodePostgresAmbientNativePool, nodePostgresClientConnection, nodePostgresClientPool, nodePostgresConnection, nodePostgresExecute, nodePostgresNativePool, nodePostgresPool, nodePostgresPoolClientConnection, nodePostgresSQLExecutor, nodePostgresTransaction, onEndPool, plainString, postgresPool, prettyJson, rawSql, releaseAdvisoryLock, runPostgreSQLMigrations, runSQLMigrations, schemaComponent, setNodePostgresTypeParser, single, singleOrNull, sql, sqlExecutor, sqlExecutorInNewConnection, sqlMigration, tableExists, tableExistsSQL, toCamelCase, tracer, transactionFactoryWithDbClient, transactionFactoryWithNewConnection, tryAcquireAdvisoryLock };
+export { type AcquireDatabaseLockMode, type AcquireDatabaseLockOptions, AdvisoryLock, type BatchQueryOptions, Connection, type ConnectionCheckResult, ConnectionPool, type ConnectorType, type CountSQLQueryResult, type DatabaseLock, type DatabaseLockOptions, DatabaseTransaction, DbSQLExecutor, type Dumbo, type DumboOptions, type ExistsSQLQueryResult, JSONSerializer, LogLevel, LogStyle, type LogType, MIGRATIONS_LOCK_ID, type MigrationRecord, type MigrationStyle, type MigratorOptions, type NodePostgresAmbientClientPool, type NodePostgresAmbientConnectionPool, type NodePostgresClient, type NodePostgresClientConnection, type NodePostgresClientOptions, type NodePostgresClientOrPoolClient, type NodePostgresConnection, type NodePostgresConnector, NodePostgresConnectorType, type NodePostgresNativePool, type NodePostgresPool, type NodePostgresPoolClient, type NodePostgresPoolClientConnection, type NodePostgresPoolClientOptions, type NodePostgresPoolNotPooledOptions, type NodePostgresPoolOptions, type NodePostgresPoolOrClient, type NodePostgresPoolPooledOptions, type NodePostgresSQLExecutor, type NodePostgresTransaction, type PoolOptions, type PostgreSQLMigratorOptions, type PostgresConnection, type PostgresConnector, type PostgresPool, type PostgresPoolOptions, QueryResult, QueryResultRow, type ReleaseDatabaseLockOptions, SQL, SQLExecutor, type SQLMigration, type SchemaComponent, type SchemaComponentMigrationsOptions, acquireAdvisoryLock, advisoryLock, checkConnection, color, combineMigrations, connectionPool, count, defaultDatabaseLockOptions, defaultPostgreSQLConenctionString, defaultPostgreSqlDatabase, dumbo, endAllPools, endPool, exists, first, firstOrNull, functionExists, functionExistsSQL, getDatabaseNameOrDefault, getPool, isNodePostgresClient, isNodePostgresNativePool, isNodePostgresPoolClient, mapRows, mapToCamelCase, migrationTableSchemaComponent, nodePostgresAmbientClientPool, nodePostgresAmbientConnectionPool, nodePostgresAmbientNativePool, nodePostgresClientConnection, nodePostgresClientPool, nodePostgresConnection, nodePostgresExecute, nodePostgresNativePool, nodePostgresPool, nodePostgresPoolClientConnection, nodePostgresSQLExecutor, nodePostgresTransaction, onEndPool, postgresPool, prettyJson, releaseAdvisoryLock, runPostgreSQLMigrations, runSQLMigrations, schemaComponent, setNodePostgresTypeParser, single, singleOrNull, sqlMigration, tableExists, tableExistsSQL, toCamelCase, tracer, tryAcquireAdvisoryLock };