@event-driven-io/pongo 0.10.0 → 0.11.0

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { SQLExecutor, SQL, PostgresConnector, PostgresPoolOptions, DatabaseTransaction, DatabaseTransactionFactory, NodePostgresConnection } from '@event-driven-io/dumbo';
-import pg from 'pg';
-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';
+import { SQLExecutor, SQL } from '@event-driven-io/dumbo';
+import { P as PongoDb, a as PongoDocument, b as PongoCollection, W as WithId, c as PongoFilter, d as PongoUpdate, e as WithoutId, f as PongoTransactionOptions, g as PongoSession, h as PongoDbTransaction } from './pongoDb-C4vfKipo.cjs';
+export { r as $inc, s as $push, $ as $set, q as $unset, A as AllowedDbClientOptions, C as CollectionOperationOptions, D as DocumentHandler, H as HasId, N as NotPooledPongoOptions, n as PongoClient, j as PongoClientOptions, l as PongoDbClientOptions, y as PongoDeleteManyResult, x as PongoDeleteResult, o as PongoFilterOperator, u as PongoInsertManyResult, t as PongoInsertOneResult, w as PongoUpdateManyResult, v as PongoUpdateResult, i as PooledPongoClientOptions, z as PostgresDbClientOptions, k as clientToDbOptions, m as getPongoDb, B as isPostgresClientOptions, p as pongoClient, E as postgresDb } from './pongoDb-C4vfKipo.cjs';
+import 'pg';
 
 type PongoCollectionOptions<ConnectorType extends string = string> = {
     db: PongoDb<ConnectorType>;
@@ -49,168 +49,8 @@ declare const OperatorMap: {
 declare const isOperator: (key: string) => boolean;
 declare const hasOperators: (value: Record<string, unknown>) => boolean;
 
-type PostgresDbClientOptions = PongoDbClientOptions<PostgresConnector> & PostgresPoolOptions;
-declare const isPostgresClientOptions: (options: PongoDbClientOptions) => options is PostgresDbClientOptions;
-declare const postgresDb: (options: PostgresDbClientOptions) => PongoDb<PostgresConnector>;
-
 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 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(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;
-};
-type WithId<T> = T & HasId;
-type WithoutId<T> = Omit<T, '_id'>;
-type PongoFilter<T> = {
-    [P in keyof T]?: T[P] | PongoFilterOperator<T[P]>;
-} | HasId;
-type PongoFilterOperator<T> = {
-    $eq?: T;
-    $gt?: T;
-    $gte?: T;
-    $lt?: T;
-    $lte?: T;
-    $ne?: T;
-    $in?: T[];
-    $nin?: T[];
-};
-type $set<T> = Partial<T>;
-type $unset<T> = {
-    [P in keyof T]?: '';
-};
-type $inc<T> = {
-    [P in keyof T]?: number;
-};
-type $push<T> = {
-    [P in keyof T]?: T[P];
-};
-type PongoUpdate<T> = {
-    $set?: Partial<T>;
-    $unset?: $unset<T>;
-    $inc?: $inc<T>;
-    $push?: $push<T>;
-};
-interface PongoInsertOneResult {
-    insertedId: string | null;
-    acknowledged: boolean;
-}
-interface PongoInsertManyResult {
-    acknowledged: boolean;
-    insertedIds: string[];
-    insertedCount: number;
-}
-interface PongoUpdateResult {
-    acknowledged: boolean;
-    modifiedCount: number;
-}
-interface PongoUpdateManyResult {
-    acknowledged: boolean;
-    modifiedCount: number;
-}
-interface PongoDeleteResult {
-    acknowledged: boolean;
-    deletedCount: number;
-}
-interface PongoDeleteManyResult {
-    acknowledged: boolean;
-    deletedCount: number;
-}
-type PongoDocument = Record<string, unknown>;
-type DocumentHandler<T extends PongoDocument> = ((document: T | null) => T | null) | ((document: T | null) => Promise<T | null>);
-
-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]];
 }[keyof Required<T>];
@@ -222,14 +62,6 @@ 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;
@@ -238,142 +70,4 @@ declare const pongoSession: (options?: PongoSessionOptions) => PongoSession;
 
 declare const pongoTransaction: (options: PongoTransactionOptions) => PongoDbTransaction;
 
-declare class FindCursor<T> {
-    private findDocumentsPromise;
-    private documents;
-    private index;
-    constructor(documents: Promise<T[]>);
-    toArray(): Promise<T[]>;
-    forEach(callback: (doc: T) => void): Promise<void>;
-    hasNext(): boolean;
-    next(): Promise<T | null>;
-    private findDocuments;
-}
-
-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>;
-    };
-}
-
-declare class MongoClient {
-    private pongoClient;
-    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> {
-    private collection;
-    constructor(collection: PongoCollection<T>);
-    get dbName(): string;
-    get collectionName(): string;
-    get namespace(): string;
-    get readConcern(): ReadConcern | undefined;
-    get readPreference(): ReadPreference | undefined;
-    get bsonOptions(): BSONSerializeOptions;
-    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>>;
-    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>;
-    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>;
-    findOne<TS = T>(): Promise<TS | null>;
-    findOne<TS = T>(filter: Filter<TS>): Promise<TS | null>;
-    findOne<TS = T>(filter: Filter<TS>, options?: FindOptions<Document> | undefined): Promise<TS | null>;
-    find(): FindCursor$1<WithId$1<T>>;
-    find(filter: Filter<T>, options?: FindOptions<Document> | undefined): FindCursor$1<WithId$1<T>>;
-    find<T extends Document>(filter: Filter<T>, options?: FindOptions<Document> | undefined): FindCursor$1<T>;
-    options(_options?: OperationOptions | undefined): Promise<Document>;
-    isCapped(_options?: OperationOptions | undefined): Promise<boolean>;
-    createIndex(_indexSpec: IndexSpecification, _options?: CreateIndexesOptions | undefined): Promise<string>;
-    createIndexes(_indexSpecs: IndexDescription[], _options?: CreateIndexesOptions | undefined): Promise<string[]>;
-    dropIndex(_indexName: string, _options?: CommandOperationOptions | undefined): Promise<Document>;
-    dropIndexes(_options?: CommandOperationOptions | undefined): Promise<boolean>;
-    listIndexes(_options?: AbstractCursorOptions | undefined): ListIndexesCursor;
-    indexExists(_indexes: string | string[], _options?: AbstractCursorOptions | undefined): Promise<boolean>;
-    indexInformation(options: IndexInformationOptions & {
-        full: true;
-    }): Promise<IndexDescriptionInfo[]>;
-    indexInformation(options: IndexInformationOptions & {
-        full?: false | undefined;
-    }): 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>;
-    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]>[]>;
-    distinct(key: string): Promise<any[]>;
-    distinct(key: string, filter: Filter<T>): Promise<any[]>;
-    distinct(key: string, filter: Filter<T>, options: CommandOperationOptions): Promise<any[]>;
-    indexes(options: IndexInformationOptions & {
-        full?: true | undefined;
-    }): Promise<IndexDescriptionInfo[]>;
-    indexes(options: IndexInformationOptions & {
-        full: false;
-    }): Promise<IndexDescriptionCompact>;
-    indexes(options: IndexInformationOptions): Promise<IndexDescriptionCompact | IndexDescriptionInfo[]>;
-    indexes(options?: AbstractCursorOptions | undefined): Promise<IndexDescriptionInfo[]>;
-    findOneAndDelete(filter: Filter<T>, options: FindOneAndDeleteOptions & {
-        includeResultMetadata: true;
-    }): Promise<ModifyResult<T>>;
-    findOneAndDelete(filter: Filter<T>, options: FindOneAndDeleteOptions & {
-        includeResultMetadata: false;
-    }): Promise<WithId$1<T> | null>;
-    findOneAndDelete(filter: Filter<T>, options: FindOneAndDeleteOptions): Promise<WithId$1<T> | null>;
-    findOneAndDelete(filter: Filter<T>): Promise<WithId$1<T> | null>;
-    findOneAndReplace(filter: Filter<T>, replacement: WithoutId$1<T>, options: FindOneAndReplaceOptions & {
-        includeResultMetadata: true;
-    }): Promise<ModifyResult<T>>;
-    findOneAndReplace(filter: Filter<T>, replacement: WithoutId$1<T>, options: FindOneAndReplaceOptions & {
-        includeResultMetadata: false;
-    }): Promise<WithId$1<T> | null>;
-    findOneAndReplace(filter: Filter<T>, replacement: WithoutId$1<T>, options: FindOneAndReplaceOptions): Promise<WithId$1<T> | null>;
-    findOneAndReplace(filter: Filter<T>, replacement: WithoutId$1<T>): Promise<WithId$1<T> | null>;
-    findOneAndUpdate(filter: Filter<T>, update: UpdateFilter<T>, options: FindOneAndUpdateOptions & {
-        includeResultMetadata: true;
-    }): Promise<ModifyResult<T>>;
-    findOneAndUpdate(filter: Filter<T>, update: UpdateFilter<T>, options: FindOneAndUpdateOptions & {
-        includeResultMetadata: false;
-    }): Promise<WithId$1<T> | null>;
-    findOneAndUpdate(filter: Filter<T>, update: UpdateFilter<T>, options: FindOneAndUpdateOptions): Promise<WithId$1<T> | null>;
-    findOneAndUpdate(filter: Filter<T>, update: UpdateFilter<T>): Promise<WithId$1<T> | null>;
-    aggregate<T extends Document = Document>(_pipeline?: Document[] | undefined, _options?: AggregateOptions | undefined): AggregationCursor<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>;
-    listSearchIndexes(options?: ListSearchIndexesOptions | undefined): ListSearchIndexesCursor;
-    listSearchIndexes(name: string, options?: ListSearchIndexesOptions | undefined): ListSearchIndexesCursor;
-    createSearchIndex(_description: SearchIndexDescription): Promise<string>;
-    createSearchIndexes(_descriptions: SearchIndexDescription[]): Promise<string[]>;
-    dropSearchIndex(_name: string): Promise<void>;
-    updateSearchIndex(_name: string, _definition: Document): Promise<void>;
-    createCollection(): Promise<void>;
-    handle(id: ObjectId$1, handle: DocumentHandler<T>): Promise<T | null>;
-}
-
-type ObjectId = string & {
-    __brandId: 'ObjectId';
-};
-
-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 };
+export { type NonPartial, OperatorMap, PongoCollection, type PongoCollectionOptions, type PongoCollectionSQLBuilder, PongoDb, PongoDbTransaction, PongoDocument, PongoFilter, PongoSession, type PongoSessionOptions, PongoTransactionOptions, PongoUpdate, QueryOperators, WithId, WithoutId, entries, hasOperators, isOperator, pongoCollection, pongoSession, pongoTransaction, postgresSQLBuilder };