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

package/dist/connections-DM3XBOND.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/connections-KNAIUBC5.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-LKLJL6B2.cjs');
+
+
+
+
+var _chunkTXXOMO2Scjs = require('./chunk-TXXOMO2S.cjs');
+require('./chunk-Y7ETN53Q.cjs');
+require('./chunk-72RN47FR.cjs');
+require('./chunk-PXIJTLLG.cjs');
+require('./chunk-3AZXA4Q4.cjs');
+require('./chunk-55X4XXTZ.cjs');
+require('./chunk-DYX7V3LM.cjs');
+
+
+
+
+exports.SQLite3ConnectorType = _chunkTXXOMO2Scjs.SQLite3ConnectorType; exports.checkConnection = _chunkTXXOMO2Scjs.checkConnection; exports.sqlite3Client = _chunkTXXOMO2Scjs.sqlite3Client;
+//# sourceMappingURL=connections-KNAIUBC5.cjs.map

package/dist/connections-KNAIUBC5.cjs.map

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

package/dist/connections-ROCX4PBC.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkY7ETN53Qcjs = require('./chunk-Y7ETN53Q.cjs');
+require('./chunk-72RN47FR.cjs');
+require('./chunk-PXIJTLLG.cjs');
+require('./chunk-3AZXA4Q4.cjs');
+require('./chunk-55X4XXTZ.cjs');
+require('./chunk-DYX7V3LM.cjs');
+
+
+
+
+
+
+exports.InMemorySQLiteDatabase = _chunkY7ETN53Qcjs.InMemorySQLiteDatabase; exports.isSQLiteError = _chunkY7ETN53Qcjs.isSQLiteError; exports.sqliteClientConnection = _chunkY7ETN53Qcjs.sqliteClientConnection; exports.sqliteConnection = _chunkY7ETN53Qcjs.sqliteConnection; exports.sqlitePoolClientConnection = _chunkY7ETN53Qcjs.sqlitePoolClientConnection;
+//# sourceMappingURL=connections-ROCX4PBC.cjs.map

package/dist/connections-ROCX4PBC.cjs.map

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

package/dist/core-FB34A5DC.js

@@ -0,0 +1,38 @@
+import {
+  InMemorySQLiteDatabase,
+  isSQLiteError,
+  sqliteAlwaysNewClientPool,
+  sqliteAmbientClientPool,
+  sqliteAmbientConnectionPool,
+  sqliteClientConnection,
+  sqliteConnection,
+  sqlitePool,
+  sqlitePoolClientConnection,
+  sqliteSingletonClientPool
+} from "./chunk-VWPQS5RN.js";
+import "./chunk-YJF6HCJO.js";
+import {
+  sqliteTransaction
+} from "./chunk-QD3XOIUK.js";
+import "./chunk-2FKOO7MT.js";
+import {
+  sqliteExecute,
+  sqliteSQLExecutor
+} from "./chunk-ML7B25UO.js";
+import "./chunk-IIFZU7RA.js";
+export {
+  InMemorySQLiteDatabase,
+  isSQLiteError,
+  sqliteAlwaysNewClientPool,
+  sqliteAmbientClientPool,
+  sqliteAmbientConnectionPool,
+  sqliteClientConnection,
+  sqliteConnection,
+  sqliteExecute,
+  sqlitePool,
+  sqlitePoolClientConnection,
+  sqliteSQLExecutor,
+  sqliteSingletonClientPool,
+  sqliteTransaction
+};
+//# sourceMappingURL=core-FB34A5DC.js.map

package/dist/core-FB34A5DC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/core-ROYOQ2PP.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkY7ETN53Qcjs = require('./chunk-Y7ETN53Q.cjs');
+require('./chunk-72RN47FR.cjs');
+
+
+var _chunkPXIJTLLGcjs = require('./chunk-PXIJTLLG.cjs');
+require('./chunk-3AZXA4Q4.cjs');
+
+
+
+var _chunk55X4XXTZcjs = require('./chunk-55X4XXTZ.cjs');
+require('./chunk-DYX7V3LM.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.InMemorySQLiteDatabase = _chunkY7ETN53Qcjs.InMemorySQLiteDatabase; exports.isSQLiteError = _chunkY7ETN53Qcjs.isSQLiteError; exports.sqliteAlwaysNewClientPool = _chunkY7ETN53Qcjs.sqliteAlwaysNewClientPool; exports.sqliteAmbientClientPool = _chunkY7ETN53Qcjs.sqliteAmbientClientPool; exports.sqliteAmbientConnectionPool = _chunkY7ETN53Qcjs.sqliteAmbientConnectionPool; exports.sqliteClientConnection = _chunkY7ETN53Qcjs.sqliteClientConnection; exports.sqliteConnection = _chunkY7ETN53Qcjs.sqliteConnection; exports.sqliteExecute = _chunk55X4XXTZcjs.sqliteExecute; exports.sqlitePool = _chunkY7ETN53Qcjs.sqlitePool; exports.sqlitePoolClientConnection = _chunkY7ETN53Qcjs.sqlitePoolClientConnection; exports.sqliteSQLExecutor = _chunk55X4XXTZcjs.sqliteSQLExecutor; exports.sqliteSingletonClientPool = _chunkY7ETN53Qcjs.sqliteSingletonClientPool; exports.sqliteTransaction = _chunkPXIJTLLGcjs.sqliteTransaction;
+//# sourceMappingURL=core-ROYOQ2PP.cjs.map

package/dist/core-ROYOQ2PP.cjs.map

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

package/dist/execute-DVHVB627.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk55X4XXTZcjs = require('./chunk-55X4XXTZ.cjs');
+require('./chunk-DYX7V3LM.cjs');
+
+
+
+exports.sqliteExecute = _chunk55X4XXTZcjs.sqliteExecute; exports.sqliteSQLExecutor = _chunk55X4XXTZcjs.sqliteSQLExecutor;
+//# sourceMappingURL=execute-DVHVB627.cjs.map

package/dist/execute-DVHVB627.cjs.map

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

package/dist/execute-HCURO5PS.cjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-3AZXA4Q4.cjs');
+
+
+
+var _chunk55X4XXTZcjs = require('./chunk-55X4XXTZ.cjs');
+require('./chunk-DYX7V3LM.cjs');
+
+
+
+exports.sqliteExecute = _chunk55X4XXTZcjs.sqliteExecute; exports.sqliteSQLExecutor = _chunk55X4XXTZcjs.sqliteSQLExecutor;
+//# sourceMappingURL=execute-HCURO5PS.cjs.map

package/dist/execute-HCURO5PS.cjs.map

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

package/dist/execute-NABA4WBO.js

@@ -0,0 +1,10 @@
+import {
+  sqliteExecute,
+  sqliteSQLExecutor
+} from "./chunk-ML7B25UO.js";
+import "./chunk-IIFZU7RA.js";
+export {
+  sqliteExecute,
+  sqliteSQLExecutor
+};
+//# sourceMappingURL=execute-NABA4WBO.js.map

package/dist/execute-NABA4WBO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/execute-TDYAV2AC.js

@@ -0,0 +1,11 @@
+import "./chunk-2FKOO7MT.js";
+import {
+  sqliteExecute,
+  sqliteSQLExecutor
+} from "./chunk-ML7B25UO.js";
+import "./chunk-IIFZU7RA.js";
+export {
+  sqliteExecute,
+  sqliteSQLExecutor
+};
+//# sourceMappingURL=execute-TDYAV2AC.js.map

package/dist/execute-TDYAV2AC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index-C0xy8dwZ.d.cts

@@ -0,0 +1,183 @@
+interface QueryResultRow {
+    [column: string]: any;
+}
+type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
+    rowCount: number | null;
+    rows: Result[];
+};
+
+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>(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>(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>(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 DatabaseType = string;
+type DatabaseDriverName = string;
+type ConnectorTypeName<DatabaseTypeName extends DatabaseType = DatabaseType, DriverName extends DatabaseDriverName = DatabaseDriverName> = `${DatabaseTypeName}:${DriverName}`;
+type ConnectorTypeParts<T extends DatabaseType = DatabaseType> = {
+    databaseType: T;
+    driverName: string;
+};
+/**
+ * Accepts a `databaseType` (e.g. PostgreSQL, SQLite) and a `driverName`
+ * (the library name, e.g. pg, sqlite3) and combines them to a singular
+ * `connectorType` which can be used in database handling.
+ */
+declare function toConnectorType<T extends DatabaseType>(databaseType: T, driverName: string): ConnectorTypeName<T>;
+/**
+ * Accepts a fully formatted `connectorType` and returns the broken down
+ * `databaseType` and `driverName`.
+ */
+declare function fromConnectorType<T extends DatabaseType>(connectorType: ConnectorTypeName<T>): ConnectorTypeParts<T>;
+/**
+ * Accepts a fully formatted `connectorType` and returns the `driverName`.
+ */
+declare function getDriverName<T extends DatabaseType>(connectorType: ConnectorTypeName<T>): DatabaseDriverName;
+
+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;
+}
+
+export { type Serializer as A, composeJSONReplacers as B, type Connection as C, type DbSQLExecutor as D, composeJSONRevivers as E, JSONReplacer as F, JSONReplacers as G, JSONReviver as H, JSONRevivers as I, JSONSerializer as J, jsonSerializer as K, JSONObjectCodec as L, type JSONObjectCodecOptions as M, identifier as N, type ObjectCodec as O, isSQL as P, type QueryResultRow as Q, RawJSONSerializer as R, type SQLExecutor as S, type TransactionResult as T, literal as U, plainString as V, type WithSQLExecutor as W, rawSql as X, sql as Y, type ConnectionPool as a, type DatabaseTransaction as b, type ConnectorTypeName as c, type QueryResult as d, SQL as e, type ConnectionFactory as f, type CreateConnectionOptions as g, createConnection as h, type ConnectionPoolFactory as i, createConnectionPool as j, type DatabaseTransactionFactory as k, executeInTransaction as l, transactionFactoryWithNewConnection as m, type DatabaseType as n, type DatabaseDriverName as o, type ConnectorTypeParts as p, toConnectorType as q, fromConnectorType as r, getDriverName as s, transactionFactoryWithDbClient as t, type SQLQueryOptions as u, type SQLCommandOptions as v, sqlExecutor as w, sqlExecutorInNewConnection as x, executeInNewDbClient as y, executeInNewConnection as z };

package/dist/index-C0xy8dwZ.d.ts

@@ -0,0 +1,183 @@
+interface QueryResultRow {
+    [column: string]: any;
+}
+type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
+    rowCount: number | null;
+    rows: Result[];
+};
+
+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>(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>(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>(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 DatabaseType = string;
+type DatabaseDriverName = string;
+type ConnectorTypeName<DatabaseTypeName extends DatabaseType = DatabaseType, DriverName extends DatabaseDriverName = DatabaseDriverName> = `${DatabaseTypeName}:${DriverName}`;
+type ConnectorTypeParts<T extends DatabaseType = DatabaseType> = {
+    databaseType: T;
+    driverName: string;
+};
+/**
+ * Accepts a `databaseType` (e.g. PostgreSQL, SQLite) and a `driverName`
+ * (the library name, e.g. pg, sqlite3) and combines them to a singular
+ * `connectorType` which can be used in database handling.
+ */
+declare function toConnectorType<T extends DatabaseType>(databaseType: T, driverName: string): ConnectorTypeName<T>;
+/**
+ * Accepts a fully formatted `connectorType` and returns the broken down
+ * `databaseType` and `driverName`.
+ */
+declare function fromConnectorType<T extends DatabaseType>(connectorType: ConnectorTypeName<T>): ConnectorTypeParts<T>;
+/**
+ * Accepts a fully formatted `connectorType` and returns the `driverName`.
+ */
+declare function getDriverName<T extends DatabaseType>(connectorType: ConnectorTypeName<T>): DatabaseDriverName;
+
+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;
+}
+
+export { type Serializer as A, composeJSONReplacers as B, type Connection as C, type DbSQLExecutor as D, composeJSONRevivers as E, JSONReplacer as F, JSONReplacers as G, JSONReviver as H, JSONRevivers as I, JSONSerializer as J, jsonSerializer as K, JSONObjectCodec as L, type JSONObjectCodecOptions as M, identifier as N, type ObjectCodec as O, isSQL as P, type QueryResultRow as Q, RawJSONSerializer as R, type SQLExecutor as S, type TransactionResult as T, literal as U, plainString as V, type WithSQLExecutor as W, rawSql as X, sql as Y, type ConnectionPool as a, type DatabaseTransaction as b, type ConnectorTypeName as c, type QueryResult as d, SQL as e, type ConnectionFactory as f, type CreateConnectionOptions as g, createConnection as h, type ConnectionPoolFactory as i, createConnectionPool as j, type DatabaseTransactionFactory as k, executeInTransaction as l, transactionFactoryWithNewConnection as m, type DatabaseType as n, type DatabaseDriverName as o, type ConnectorTypeParts as p, toConnectorType as q, fromConnectorType as r, getDriverName as s, transactionFactoryWithDbClient as t, type SQLQueryOptions as u, type SQLCommandOptions as v, sqlExecutor as w, sqlExecutorInNewConnection as x, executeInNewDbClient as y, executeInNewConnection as z };