@event-driven-io/pongo 0.8.0 → 0.10.0

package/dist/index.d.cts

@@ -1,15 +1,32 @@
+import { SQLExecutor, SQL, PostgresConnector, PostgresPoolOptions, DatabaseTransaction, DatabaseTransactionFactory, NodePostgresConnection } from '@event-driven-io/dumbo';
 import pg from 'pg';
-import { Document, Collection as Collection$1, ObjectId as ObjectId$1, ReadConcern, ReadPreference, BSONSerializeOptions, WriteConcern, Hint, OptionalUnlessRequiredId, InsertOneOptions, InsertOneResult, BulkWriteOptions, InsertManyResult, AnyBulkWriteOperation, BulkWriteResult, Filter, UpdateFilter, UpdateOptions, UpdateResult, WithoutId as WithoutId$1, ReplaceOptions, DeleteOptions, DeleteResult, RenameOptions, DropCollectionOptions, WithId as WithId$1, FindOptions, FindCursor as FindCursor$1, OperationOptions, IndexSpecification, CreateIndexesOptions, IndexDescription, CommandOperationOptions, AbstractCursorOptions, ListIndexesCursor, IndexInformationOptions, IndexDescriptionInfo, IndexDescriptionCompact, EstimatedDocumentCountOptions, CountDocumentsOptions, EnhancedOmit, Flatten, FindOneAndDeleteOptions, ModifyResult, FindOneAndReplaceOptions, FindOneAndUpdateOptions, AggregateOptions, AggregationCursor, ChangeStreamDocument, ChangeStreamOptions, ChangeStream, UnorderedBulkOperation, OrderedBulkOperation, CountOptions, ListSearchIndexesOptions, ListSearchIndexesCursor, SearchIndexDescription } from 'mongodb';
-import { SQL } from '@event-driven-io/dumbo';
+import { ClientSessionOptions } from 'http2';
+import { Document, Collection as Collection$1, ObjectId as ObjectId$1, ClientSession, WithSessionCallback, ReadConcern, ReadPreference, BSONSerializeOptions, WriteConcern, Hint, OptionalUnlessRequiredId, InsertOneOptions, InsertOneResult, BulkWriteOptions, InsertManyResult, AnyBulkWriteOperation, BulkWriteResult, Filter, UpdateFilter, UpdateOptions, UpdateResult, WithoutId as WithoutId$1, ReplaceOptions, DeleteOptions, DeleteResult, RenameOptions, DropCollectionOptions, WithId as WithId$1, FindOptions, FindCursor as FindCursor$1, OperationOptions, IndexSpecification, CreateIndexesOptions, IndexDescription, CommandOperationOptions, AbstractCursorOptions, ListIndexesCursor, IndexInformationOptions, IndexDescriptionInfo, IndexDescriptionCompact, EstimatedDocumentCountOptions, CountDocumentsOptions, EnhancedOmit, Flatten, FindOneAndDeleteOptions, ModifyResult, FindOneAndReplaceOptions, FindOneAndUpdateOptions, AggregateOptions, AggregationCursor, ChangeStreamDocument, ChangeStreamOptions, ChangeStream, UnorderedBulkOperation, OrderedBulkOperation, CountOptions, ListSearchIndexesOptions, ListSearchIndexesCursor, SearchIndexDescription } from 'mongodb';
 
-type PongoClientOptions = {
-    connectionString: string;
-    dbName?: string | undefined;
-    client?: pg.PoolClient | pg.Client | undefined;
+type PongoCollectionOptions<ConnectorType extends string = string> = {
+    db: PongoDb<ConnectorType>;
+    collectionName: string;
+    sqlExecutor: SQLExecutor;
+    sqlBuilder: PongoCollectionSQLBuilder;
+};
+declare const pongoCollection: <T extends PongoDocument, ConnectorType extends string = string>({ db, collectionName, sqlExecutor, sqlBuilder: SqlFor, }: PongoCollectionOptions<ConnectorType>) => PongoCollection<T>;
+type PongoCollectionSQLBuilder = {
+    createCollection: () => SQL;
+    insertOne: <T>(document: WithId<T>) => SQL;
+    insertMany: <T>(documents: WithId<T>[]) => SQL;
+    updateOne: <T>(filter: PongoFilter<T>, update: PongoUpdate<T>) => SQL;
+    replaceOne: <T>(filter: PongoFilter<T>, document: WithoutId<T>) => SQL;
+    updateMany: <T>(filter: PongoFilter<T>, update: PongoUpdate<T>) => SQL;
+    deleteOne: <T>(filter: PongoFilter<T>) => SQL;
+    deleteMany: <T>(filter: PongoFilter<T>) => SQL;
+    findOne: <T>(filter: PongoFilter<T>) => SQL;
+    find: <T>(filter: PongoFilter<T>) => SQL;
+    countDocuments: <T>(filter: PongoFilter<T>) => SQL;
+    rename: (newName: string) => SQL;
+    drop: () => SQL;
 };
-declare const postgresClient: (options: PongoClientOptions) => DbClient;
 
-declare const Operators: {
+declare const QueryOperators: {
     $eq: string;
     $gt: string;
     $gte: string;
@@ -22,66 +39,88 @@ declare const Operators: {
     $all: string;
     $size: string;
 };
+declare const OperatorMap: {
+    $gt: string;
+    $gte: string;
+    $lt: string;
+    $lte: string;
+    $ne: string;
+};
 declare const isOperator: (key: string) => boolean;
 declare const hasOperators: (value: Record<string, unknown>) => boolean;
-declare const handleOperator: (path: string, operator: string, value: unknown) => string;
 
-declare const constructFilterQuery: <T>(filter: PongoFilter<T>) => string;
+type PostgresDbClientOptions = PongoDbClientOptions<PostgresConnector> & PostgresPoolOptions;
+declare const isPostgresClientOptions: (options: PongoDbClientOptions) => options is PostgresDbClientOptions;
+declare const postgresDb: (options: PostgresDbClientOptions) => PongoDb<PostgresConnector>;
 
-declare const postgresCollection: <T extends PongoDocument>(collectionName: string, { dbName, poolOrClient: clientOrPool, }: {
-    dbName: string;
-    poolOrClient: pg.Pool | pg.PoolClient | pg.Client;
-}) => PongoCollection<T>;
-declare const collectionSQLBuilder: (collectionName: string) => {
-    createCollection: () => SQL;
-    insertOne: <T>(document: WithId<T>) => SQL;
-    insertMany: <T_1>(documents: WithId<T_1>[]) => SQL;
-    updateOne: <T_2>(filter: PongoFilter<T_2>, update: PongoUpdate<T_2>) => SQL;
-    replaceOne: <T_3>(filter: PongoFilter<T_3>, document: WithoutId<T_3>) => SQL;
-    updateMany: <T_4>(filter: PongoFilter<T_4>, update: PongoUpdate<T_4>) => SQL;
-    deleteOne: <T_5>(filter: PongoFilter<T_5>) => SQL;
-    deleteMany: <T_6>(filter: PongoFilter<T_6>) => SQL;
-    findOne: <T_7>(filter: PongoFilter<T_7>) => SQL;
-    find: <T_8>(filter: PongoFilter<T_8>) => SQL;
-    countDocuments: <T_9>(filter: PongoFilter<T_9>) => SQL;
-    rename: (newName: string) => SQL;
-    drop: (targetName?: string) => SQL;
-};
-
-declare const buildUpdateQuery: <T>(update: PongoUpdate<T>) => SQL;
-declare const buildSetQuery: <T>(set: $set<T>, currentUpdateQuery: SQL) => SQL;
-declare const buildUnsetQuery: <T>(unset: $unset<T>, currentUpdateQuery: SQL) => SQL;
-declare const buildIncQuery: <T>(inc: $inc<T>, currentUpdateQuery: SQL) => SQL;
-declare const buildPushQuery: <T>(push: $push<T>, currentUpdateQuery: SQL) => SQL;
+declare const postgresSQLBuilder: (collectionName: string) => PongoCollectionSQLBuilder;
 
 interface PongoClient {
     connect(): Promise<this>;
     close(): Promise<void>;
     db(dbName?: string): PongoDb;
+    startSession(): PongoSession;
+    withSession<T = unknown>(callback: (session: PongoSession) => Promise<T>): Promise<T>;
+}
+declare interface PongoTransactionOptions {
+    get snapshotEnabled(): boolean;
+    maxCommitTimeMS?: number;
+}
+interface PongoDbTransaction {
+    get databaseName(): string | null;
+    options: PongoTransactionOptions;
+    enlistDatabase: (database: PongoDb) => Promise<DatabaseTransaction>;
+    commit: () => Promise<void>;
+    rollback: (error?: unknown) => Promise<void>;
+    get sqlExecutor(): SQLExecutor;
+    get isStarting(): boolean;
+    get isActive(): boolean;
+    get isCommitted(): boolean;
 }
-interface PongoDb {
+interface PongoSession {
+    hasEnded: boolean;
+    explicit: boolean;
+    defaultTransactionOptions: PongoTransactionOptions;
+    transaction: PongoDbTransaction | null;
+    get snapshotEnabled(): boolean;
+    endSession(): Promise<void>;
+    incrementTransactionNumber(): void;
+    inTransaction(): boolean;
+    startTransaction(options?: PongoTransactionOptions): void;
+    commitTransaction(): Promise<void>;
+    abortTransaction(): Promise<void>;
+    withTransaction<T = unknown>(fn: (session: PongoSession) => Promise<T>, options?: PongoTransactionOptions): Promise<T>;
+}
+interface PongoDb<ConnectorType extends string = string> extends DatabaseTransactionFactory<ConnectorType> {
+    get connectorType(): ConnectorType;
+    get databaseName(): string;
+    connect(): Promise<void>;
+    close(): Promise<void>;
     collection<T extends PongoDocument>(name: string): PongoCollection<T>;
 }
+type CollectionOperationOptions = {
+    session?: PongoSession;
+};
 interface PongoCollection<T extends PongoDocument> {
     readonly dbName: string;
     readonly collectionName: string;
-    createCollection(): Promise<void>;
-    insertOne(document: T): Promise<PongoInsertOneResult>;
-    insertMany(documents: T[]): Promise<PongoInsertManyResult>;
-    updateOne(filter: PongoFilter<T>, update: PongoUpdate<T>): Promise<PongoUpdateResult>;
-    replaceOne(filter: PongoFilter<T>, document: WithoutId<T>): Promise<PongoUpdateResult>;
-    updateMany(filter: PongoFilter<T>, update: PongoUpdate<T>): Promise<PongoUpdateResult>;
-    deleteOne(filter?: PongoFilter<T>): Promise<PongoDeleteResult>;
-    deleteMany(filter?: PongoFilter<T>): Promise<PongoDeleteResult>;
-    findOne(filter?: PongoFilter<T>): Promise<T | null>;
-    find(filter?: PongoFilter<T>): Promise<T[]>;
-    findOneAndDelete(filter: PongoFilter<T>): Promise<T | null>;
-    findOneAndReplace(filter: PongoFilter<T>, replacement: WithoutId<T>): Promise<T | null>;
-    findOneAndUpdate(filter: PongoFilter<T>, update: PongoUpdate<T>): Promise<T | null>;
-    countDocuments(filter?: PongoFilter<T>): Promise<number>;
-    drop(): Promise<boolean>;
-    rename(newName: string): Promise<PongoCollection<T>>;
-    handle(id: string, handle: DocumentHandler<T>): Promise<T | null>;
+    createCollection(options?: CollectionOperationOptions): Promise<void>;
+    insertOne(document: T, options?: CollectionOperationOptions): Promise<PongoInsertOneResult>;
+    insertMany(documents: T[], options?: CollectionOperationOptions): Promise<PongoInsertManyResult>;
+    updateOne(filter: PongoFilter<T>, update: PongoUpdate<T>, options?: CollectionOperationOptions): Promise<PongoUpdateResult>;
+    replaceOne(filter: PongoFilter<T>, document: WithoutId<T>, options?: CollectionOperationOptions): Promise<PongoUpdateResult>;
+    updateMany(filter: PongoFilter<T>, update: PongoUpdate<T>, options?: CollectionOperationOptions): Promise<PongoUpdateResult>;
+    deleteOne(filter?: PongoFilter<T>, options?: CollectionOperationOptions): Promise<PongoDeleteResult>;
+    deleteMany(filter?: PongoFilter<T>, options?: CollectionOperationOptions): Promise<PongoDeleteResult>;
+    findOne(filter?: PongoFilter<T>, options?: CollectionOperationOptions): Promise<T | null>;
+    find(filter?: PongoFilter<T>, options?: CollectionOperationOptions): Promise<T[]>;
+    findOneAndDelete(filter: PongoFilter<T>, options?: CollectionOperationOptions): Promise<T | null>;
+    findOneAndReplace(filter: PongoFilter<T>, replacement: WithoutId<T>, options?: CollectionOperationOptions): Promise<T | null>;
+    findOneAndUpdate(filter: PongoFilter<T>, update: PongoUpdate<T>, options?: CollectionOperationOptions): Promise<T | null>;
+    countDocuments(filter?: PongoFilter<T>, options?: CollectionOperationOptions): Promise<number>;
+    drop(options?: CollectionOperationOptions): Promise<boolean>;
+    rename(newName: string, options?: CollectionOperationOptions): Promise<PongoCollection<T>>;
+    handle(id: string, handle: DocumentHandler<T>, options?: CollectionOperationOptions): Promise<T | null>;
 }
 type HasId = {
     _id: string;
@@ -145,16 +184,32 @@ interface PongoDeleteManyResult {
 type PongoDocument = Record<string, unknown>;
 type DocumentHandler<T extends PongoDocument> = ((document: T | null) => T | null) | ((document: T | null) => Promise<T | null>);
 
-interface DbClient {
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    collection: <T extends PongoDocument>(name: string) => PongoCollection<T>;
-}
-declare const getDbClient: (options: PongoClientOptions) => DbClient;
-
-declare const pongoClient: (connectionString: string, options?: {
-    client?: pg.PoolClient | pg.Client;
-}) => PongoClient;
+type PooledPongoClientOptions = {
+    pool: pg.Pool;
+} | {
+    pooled: true;
+} | {
+    pool: pg.Pool;
+    pooled: true;
+} | {};
+type NotPooledPongoOptions = {
+    client: pg.Client;
+} | {
+    pooled: false;
+} | {
+    client: pg.Client;
+    pooled: false;
+} | {
+    connection: NodePostgresConnection;
+    pooled?: false;
+};
+type PongoClientOptions = PooledPongoClientOptions | NotPooledPongoOptions;
+declare const pongoClient: <DbClientOptions extends PostgresDbClientOptions = PostgresDbClientOptions>(connectionString: string, options?: PongoClientOptions) => PongoClient;
+declare const clientToDbOptions: <DbClientOptions extends PostgresDbClientOptions = PostgresDbClientOptions>(options: {
+    connectionString: string;
+    dbName?: string;
+    clientOptions: PongoClientOptions;
+}) => DbClientOptions;
 
 type Entry<T> = {
     [K in keyof Required<T>]: [K, Required<T>[K]];
@@ -167,6 +222,22 @@ type NonPartial<T> = {
     [K in keyof Required<T>]: T[K];
 };
 
+type PongoDbClientOptions<ConnectorType extends string = string> = {
+    connectorType: ConnectorType;
+    connectionString: string;
+    dbName: string | undefined;
+};
+type AllowedDbClientOptions = PostgresDbClientOptions;
+declare const getPongoDb: <DbClientOptions extends PostgresDbClientOptions = PostgresDbClientOptions>(options: DbClientOptions) => PongoDb;
+
+type PongoSessionOptions = {
+    explicit?: boolean;
+    defaultTransactionOptions: PongoTransactionOptions;
+};
+declare const pongoSession: (options?: PongoSessionOptions) => PongoSession;
+
+declare const pongoTransaction: (options: PongoTransactionOptions) => PongoDbTransaction;
+
 declare class FindCursor<T> {
     private findDocumentsPromise;
     private documents;
@@ -182,6 +253,7 @@ declare class FindCursor<T> {
 declare class Db {
     private pongoDb;
     constructor(pongoDb: PongoDb);
+    get databaseName(): string;
     collection<T extends Document>(collectionName: string): Collection$1<T> & {
         handle(id: ObjectId$1, handle: DocumentHandler<T>): Promise<T | null>;
     };
@@ -189,12 +261,13 @@ declare class Db {
 
 declare class MongoClient {
     private pongoClient;
-    constructor(connectionString: string, options?: {
-        client?: pg.PoolClient | pg.Client;
-    });
+    constructor(connectionString: string, options?: PongoClientOptions);
     connect(): Promise<this>;
     close(): Promise<void>;
     db(dbName?: string): Db;
+    startSession(_options?: ClientSessionOptions): ClientSession;
+    withSession<T = any>(_executor: WithSessionCallback<T>): Promise<T>;
+    withSession<T = any>(_options: ClientSessionOptions, _executor: WithSessionCallback<T>): Promise<T>;
 }
 
 declare class Collection<T extends Document> implements Collection$1<T> {
@@ -209,16 +282,16 @@ declare class Collection<T extends Document> implements Collection$1<T> {
     get writeConcern(): WriteConcern | undefined;
     get hint(): Hint | undefined;
     set hint(v: Hint | undefined);
-    insertOne(doc: OptionalUnlessRequiredId<T>, _options?: InsertOneOptions | undefined): Promise<InsertOneResult<T>>;
-    insertMany(docs: OptionalUnlessRequiredId<T>[], _options?: BulkWriteOptions | undefined): Promise<InsertManyResult<T>>;
+    insertOne(doc: OptionalUnlessRequiredId<T>, options?: InsertOneOptions | undefined): Promise<InsertOneResult<T>>;
+    insertMany(docs: OptionalUnlessRequiredId<T>[], options?: BulkWriteOptions | undefined): Promise<InsertManyResult<T>>;
     bulkWrite(_operations: AnyBulkWriteOperation<T>[], _options?: BulkWriteOptions | undefined): Promise<BulkWriteResult>;
-    updateOne(filter: Filter<T>, update: Document[] | UpdateFilter<T>, _options?: UpdateOptions | undefined): Promise<UpdateResult<T>>;
-    replaceOne(filter: Filter<T>, document: WithoutId$1<T>, _options?: ReplaceOptions | undefined): Promise<Document | UpdateResult<T>>;
-    updateMany(filter: Filter<T>, update: Document[] | UpdateFilter<T>, _options?: UpdateOptions | undefined): Promise<UpdateResult<T>>;
-    deleteOne(filter?: Filter<T> | undefined, _options?: DeleteOptions | undefined): Promise<DeleteResult>;
-    deleteMany(filter?: Filter<T> | undefined, _options?: DeleteOptions | undefined): Promise<DeleteResult>;
-    rename(newName: string, _options?: RenameOptions | undefined): Promise<Collection<Document>>;
-    drop(_options?: DropCollectionOptions | undefined): Promise<boolean>;
+    updateOne(filter: Filter<T>, update: Document[] | UpdateFilter<T>, options?: UpdateOptions | undefined): Promise<UpdateResult<T>>;
+    replaceOne(filter: Filter<T>, document: WithoutId$1<T>, options?: ReplaceOptions | undefined): Promise<Document | UpdateResult<T>>;
+    updateMany(filter: Filter<T>, update: Document[] | UpdateFilter<T>, options?: UpdateOptions | undefined): Promise<UpdateResult<T>>;
+    deleteOne(filter?: Filter<T> | undefined, options?: DeleteOptions | undefined): Promise<DeleteResult>;
+    deleteMany(filter?: Filter<T> | undefined, options?: DeleteOptions | undefined): Promise<DeleteResult>;
+    rename(newName: string, options?: RenameOptions | undefined): Promise<Collection<Document>>;
+    drop(options?: DropCollectionOptions | undefined): Promise<boolean>;
     findOne(): Promise<WithId$1<T> | null>;
     findOne(filter: Filter<T>): Promise<WithId$1<T> | null>;
     findOne(filter: Filter<T>, options: FindOptions<Document>): Promise<WithId$1<T> | null>;
@@ -244,8 +317,8 @@ declare class Collection<T extends Document> implements Collection$1<T> {
     }): Promise<IndexDescriptionCompact>;
     indexInformation(options: IndexInformationOptions): Promise<IndexDescriptionCompact | IndexDescriptionInfo[]>;
     indexInformation(): Promise<IndexDescriptionCompact>;
-    estimatedDocumentCount(_options?: EstimatedDocumentCountOptions | undefined): Promise<number>;
-    countDocuments(filter?: Filter<T> | undefined, _options?: CountDocumentsOptions | undefined): Promise<number>;
+    estimatedDocumentCount(options?: EstimatedDocumentCountOptions | undefined): Promise<number>;
+    countDocuments(filter?: Filter<T> | undefined, options?: CountDocumentsOptions | undefined): Promise<number>;
     distinct<Key extends '_id' | keyof EnhancedOmit<T, '_id'>>(key: Key): Promise<Flatten<WithId$1<T>[Key]>[]>;
     distinct<Key extends '_id' | keyof EnhancedOmit<T, '_id'>>(key: Key, filter: Filter<T>): Promise<Flatten<WithId$1<T>[Key]>[]>;
     distinct<Key extends '_id' | keyof EnhancedOmit<T, '_id'>>(key: Key, filter: Filter<T>, options: CommandOperationOptions): Promise<Flatten<WithId$1<T>[Key]>[]>;
@@ -288,7 +361,7 @@ declare class Collection<T extends Document> implements Collection$1<T> {
     watch<TLocal extends Document = T, TChange extends Document = ChangeStreamDocument<TLocal>>(_pipeline?: Document[] | undefined, _options?: ChangeStreamOptions | undefined): ChangeStream<TLocal, TChange>;
     initializeUnorderedBulkOp(_options?: BulkWriteOptions | undefined): UnorderedBulkOperation;
     initializeOrderedBulkOp(_options?: BulkWriteOptions | undefined): OrderedBulkOperation;
-    count(filter?: Filter<T> | undefined, _options?: CountOptions | undefined): Promise<number>;
+    count(filter?: Filter<T> | undefined, options?: CountOptions | undefined): Promise<number>;
     listSearchIndexes(options?: ListSearchIndexesOptions | undefined): ListSearchIndexesCursor;
     listSearchIndexes(name: string, options?: ListSearchIndexesOptions | undefined): ListSearchIndexesCursor;
     createSearchIndex(_description: SearchIndexDescription): Promise<string>;
@@ -303,4 +376,4 @@ type ObjectId = string & {
     __brandId: 'ObjectId';
 };
 
-export { type $inc, type $push, type $set, type $unset, Collection, Db, type DbClient, type DocumentHandler, FindCursor, type HasId, MongoClient, type NonPartial, type ObjectId, Operators, type PongoClient, type PongoClientOptions, type PongoCollection, type PongoDb, type PongoDeleteManyResult, type PongoDeleteResult, type PongoDocument, type PongoFilter, type PongoFilterOperator, type PongoInsertManyResult, type PongoInsertOneResult, type PongoUpdate, type PongoUpdateManyResult, type PongoUpdateResult, type WithId, type WithoutId, buildIncQuery, buildPushQuery, buildSetQuery, buildUnsetQuery, buildUpdateQuery, collectionSQLBuilder, constructFilterQuery, entries, getDbClient, handleOperator, hasOperators, isOperator, pongoClient, postgresClient, postgresCollection };
+export { type $inc, type $push, type $set, type $unset, type AllowedDbClientOptions, Collection, type CollectionOperationOptions, Db, type DocumentHandler, FindCursor, type HasId, MongoClient, type NonPartial, type NotPooledPongoOptions, type ObjectId, OperatorMap, type PongoClient, type PongoClientOptions, type PongoCollection, type PongoCollectionOptions, type PongoCollectionSQLBuilder, type PongoDb, type PongoDbClientOptions, type PongoDbTransaction, type PongoDeleteManyResult, type PongoDeleteResult, type PongoDocument, type PongoFilter, type PongoFilterOperator, type PongoInsertManyResult, type PongoInsertOneResult, type PongoSession, type PongoSessionOptions, type PongoTransactionOptions, type PongoUpdate, type PongoUpdateManyResult, type PongoUpdateResult, type PooledPongoClientOptions, type PostgresDbClientOptions, QueryOperators, type WithId, type WithoutId, clientToDbOptions, entries, getPongoDb, hasOperators, isOperator, isPostgresClientOptions, pongoClient, pongoCollection, pongoSession, pongoTransaction, postgresDb, postgresSQLBuilder };