@event-driven-io/pongo 0.17.0-alpha.6 → 0.17.0-beta.1

package/dist/pongoClient-D8jPedlZ.d.cts

@@ -1,364 +0,0 @@
-import { SchemaComponent, ConnectorType, DatabaseTransactionFactory, DatabaseTransaction, SQLExecutor, SQL, QueryResultRow, QueryResult, MigrationStyle } from '@event-driven-io/dumbo';
-import { PostgresConnector, NodePostgresConnection } from '@event-driven-io/dumbo/pg';
-import pg from 'pg';
-import { ConnectorType as ConnectorType$1 } from '@event-driven-io/dumbo/src';
-
-type PostgresDbClientOptions = PongoDbClientOptions<PostgresConnector>;
-declare const isPostgresClientOptions: (options: PongoDbClientOptions) => options is PostgresDbClientOptions;
-declare const postgresDb: (options: PostgresDbClientOptions) => PongoDb<PostgresConnector>;
-declare const pongoDbSchemaComponent: (collections: string[] | SchemaComponent[]) => SchemaComponent;
-
-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<Connector extends ConnectorType = ConnectorType> extends DatabaseTransactionFactory<Connector> {
-    get connector(): Connector;
-    get databaseName(): string;
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    collection<T extends PongoDocument>(name: string): PongoCollection<T>;
-    collections(): ReadonlyArray<PongoCollection<PongoDocument>>;
-    readonly schema: Readonly<{
-        component: SchemaComponent;
-        migrate(): Promise<void>;
-    }>;
-    sql: {
-        query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions): Promise<Result[]>;
-        command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions): Promise<QueryResult<Result>>;
-    };
-}
-type CollectionOperationOptions = {
-    session?: PongoSession;
-};
-type InsertOneOptions = {
-    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
-} & CollectionOperationOptions;
-type InsertManyOptions = {
-    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
-} & CollectionOperationOptions;
-type UpdateOneOptions = {
-    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
-} & CollectionOperationOptions;
-type UpdateManyOptions = {
-    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
-} & CollectionOperationOptions;
-type HandleOptions = {
-    expectedVersion?: ExpectedDocumentVersion;
-} & CollectionOperationOptions;
-type ReplaceOneOptions = {
-    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
-} & CollectionOperationOptions;
-type DeleteOneOptions = {
-    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
-} & CollectionOperationOptions;
-type DeleteManyOptions = {
-    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
-} & CollectionOperationOptions;
-type FindOptions = {
-    limit?: number;
-    skip?: number;
-} & CollectionOperationOptions;
-interface PongoCollection<T extends PongoDocument> {
-    readonly dbName: string;
-    readonly collectionName: string;
-    createCollection(options?: CollectionOperationOptions): Promise<void>;
-    insertOne(document: OptionalUnlessRequiredId<T>, options?: InsertOneOptions): Promise<PongoInsertOneResult>;
-    insertMany(documents: OptionalUnlessRequiredId<T>[], options?: CollectionOperationOptions): Promise<PongoInsertManyResult>;
-    updateOne(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions): Promise<PongoUpdateResult>;
-    replaceOne(filter: PongoFilter<T> | SQL, document: WithoutId<T>, options?: ReplaceOneOptions): Promise<PongoUpdateResult>;
-    updateMany(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateManyOptions): Promise<PongoUpdateManyResult>;
-    deleteOne(filter?: PongoFilter<T> | SQL, options?: DeleteOneOptions): Promise<PongoDeleteResult>;
-    deleteMany(filter?: PongoFilter<T> | SQL, options?: DeleteManyOptions): Promise<PongoDeleteResult>;
-    findOne(filter?: PongoFilter<T> | SQL, options?: CollectionOperationOptions): Promise<WithIdAndVersion<T> | null>;
-    find(filter?: PongoFilter<T> | SQL, options?: FindOptions): Promise<WithIdAndVersion<T>[]>;
-    findOneAndDelete(filter: PongoFilter<T> | SQL, options?: DeleteOneOptions): Promise<WithIdAndVersion<T> | null>;
-    findOneAndReplace(filter: PongoFilter<T> | SQL, replacement: WithoutId<T>, options?: ReplaceOneOptions): Promise<WithIdAndVersion<T> | null>;
-    findOneAndUpdate(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions): Promise<WithIdAndVersion<T> | null>;
-    countDocuments(filter?: PongoFilter<T> | SQL, options?: CollectionOperationOptions): Promise<number>;
-    drop(options?: CollectionOperationOptions): Promise<boolean>;
-    rename(newName: string, options?: CollectionOperationOptions): Promise<PongoCollection<T>>;
-    handle(id: string, handle: DocumentHandler<T>, options?: HandleOptions): Promise<PongoHandleResult<T>>;
-    readonly schema: Readonly<{
-        component: SchemaComponent;
-        migrate(): Promise<void>;
-    }>;
-    sql: {
-        query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions): Promise<Result[]>;
-        command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions): Promise<QueryResult<Result>>;
-    };
-}
-type ObjectId = string & {
-    __brandId: 'ObjectId';
-};
-declare const ObjectId: (value?: string) => string;
-type HasId = {
-    _id: string;
-};
-declare type InferIdType<TSchema> = TSchema extends {
-    _id: infer IdType;
-} ? Record<any, never> extends IdType ? never : IdType : TSchema extends {
-    _id?: infer IdType;
-} ? unknown extends IdType ? ObjectId : IdType : ObjectId;
-/** TypeScript Omit (Exclude to be specific) does not work for objects with an "any" indexed type, and breaks discriminated unions @public */
-declare type EnhancedOmit<TRecordOrUnion, KeyUnion> = string extends keyof TRecordOrUnion ? TRecordOrUnion : TRecordOrUnion extends any ? Pick<TRecordOrUnion, Exclude<keyof TRecordOrUnion, KeyUnion>> : never;
-declare type OptionalUnlessRequiredId<TSchema> = TSchema extends {
-    _id: string | ObjectId;
-} ? TSchema : OptionalId<TSchema>;
-declare type OptionalUnlessRequiredVersion<TSchema> = TSchema extends {
-    _version: bigint;
-} ? TSchema : OptionalVersion<TSchema>;
-declare type OptionalUnlessRequiredIdAndVersion<TSchema> = OptionalUnlessRequiredId<TSchema> & OptionalUnlessRequiredVersion<TSchema>;
-declare type WithId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
-    _id: string | ObjectId;
-};
-type WithoutId<T> = Omit<T, '_id'>;
-declare type WithVersion<TSchema> = EnhancedOmit<TSchema, '_version'> & {
-    _version: bigint;
-};
-type WithoutVersion<T> = Omit<T, '_version'>;
-type WithIdAndVersion<T> = WithId<WithVersion<T>>;
-type WithoutIdAndVersion<T> = WithoutId<WithoutVersion<T>>;
-/** @public */
-declare type RegExpOrString<T> = T extends string ? RegExp | T : T;
-declare interface Document {
-    [key: string]: any;
-}
-declare type OptionalId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
-    _id?: string | ObjectId;
-};
-declare type OptionalVersion<TSchema> = EnhancedOmit<TSchema, '_version'> & {
-    _version?: bigint;
-};
-declare interface ObjectIdLike {
-    __id?: string | ObjectId;
-}
-declare type NonObjectIdLikeDocument = {
-    [key in keyof ObjectIdLike]?: never;
-} & Document;
-declare type AlternativeType<T> = T extends ReadonlyArray<infer U> ? T | RegExpOrString<U> : RegExpOrString<T>;
-declare type Condition<T> = AlternativeType<T> | PongoFilterOperator<AlternativeType<T>>;
-declare type PongoFilter<TSchema> = {
-    [P in keyof WithId<TSchema>]?: Condition<WithId<TSchema>[P]>;
-} | HasId;
-declare interface RootFilterOperators<TSchema> extends Document {
-    $and?: PongoFilter<TSchema>[];
-    $nor?: PongoFilter<TSchema>[];
-    $or?: PongoFilter<TSchema>[];
-    $text?: {
-        $search: string;
-        $language?: string;
-        $caseSensitive?: boolean;
-        $diacriticSensitive?: boolean;
-    };
-    $where?: string | ((this: TSchema) => boolean);
-    $comment?: string | Document;
-}
-declare interface PongoFilterOperator<TValue> extends NonObjectIdLikeDocument {
-    $eq?: TValue;
-    $gt?: TValue;
-    $gte?: TValue;
-    $lt?: TValue;
-    $lte?: TValue;
-    $ne?: TValue;
-    $in?: TValue[];
-    $nin?: TValue[];
-}
-type $set<T> = Partial<T>;
-type $unset<T> = {
-    [P in keyof T]?: '';
-};
-type $inc<T> = {
-    [P in keyof T]?: number | bigint;
-};
-type $push<T> = {
-    [P in keyof T]?: T[P];
-};
-type ExpectedDocumentVersionGeneral = 'DOCUMENT_EXISTS' | 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK';
-type ExpectedDocumentVersionValue = bigint & {
-    __brand: 'sql';
-};
-type ExpectedDocumentVersion = (bigint & {
-    __brand: 'sql';
-}) | bigint | ExpectedDocumentVersionGeneral;
-declare const DOCUMENT_EXISTS: ExpectedDocumentVersionGeneral;
-declare const DOCUMENT_DOES_NOT_EXIST: ExpectedDocumentVersionGeneral;
-declare const NO_CONCURRENCY_CHECK: ExpectedDocumentVersionGeneral;
-declare const isGeneralExpectedDocumentVersion: (version: ExpectedDocumentVersion) => version is ExpectedDocumentVersionGeneral;
-declare const expectedVersionValue: (version: ExpectedDocumentVersion | undefined) => ExpectedDocumentVersionValue | null;
-declare const expectedVersion: (version: number | bigint | string | undefined | null) => ExpectedDocumentVersion;
-type PongoUpdate<T> = {
-    $set?: Partial<T>;
-    $unset?: $unset<T>;
-    $inc?: $inc<T>;
-    $push?: $push<T>;
-};
-type OperationResult = {
-    acknowledged: boolean;
-    successful: boolean;
-    assertSuccessful: (errorMessage?: string) => void;
-};
-declare const operationResult: <T extends OperationResult>(result: Omit<T, "assertSuccess" | "acknowledged" | "assertSuccessful">, options: {
-    operationName: string;
-    collectionName: string;
-    errors?: {
-        throwOnOperationFailures?: boolean;
-    } | undefined;
-}) => T;
-interface PongoInsertOneResult extends OperationResult {
-    insertedId: string | null;
-    nextExpectedVersion: bigint;
-}
-interface PongoInsertManyResult extends OperationResult {
-    insertedIds: string[];
-    insertedCount: number;
-}
-interface PongoUpdateResult extends OperationResult {
-    matchedCount: number;
-    modifiedCount: number;
-    nextExpectedVersion: bigint;
-}
-interface PongoUpdateManyResult extends OperationResult {
-    matchedCount: number;
-    modifiedCount: number;
-}
-interface PongoDeleteResult extends OperationResult {
-    matchedCount: number;
-    deletedCount: number;
-}
-interface PongoDeleteManyResult extends OperationResult {
-    deletedCount: number;
-}
-type PongoHandleResult<T> = (PongoInsertOneResult & {
-    document: T;
-}) | (PongoUpdateResult & {
-    document: T;
-}) | (PongoDeleteResult & {
-    document: null;
-}) | (OperationResult & {
-    document: null;
-});
-type PongoDocument = Record<string, unknown>;
-type DocumentHandler<T extends PongoDocument> = ((document: T | null) => T | null) | ((document: T | null) => Promise<T | null>);
-
-type PongoDbClientOptions<Connector extends ConnectorType$1 = ConnectorType$1> = {
-    connector: Connector;
-    connectionString: string;
-    dbName: string | undefined;
-} & PongoClientOptions;
-type AllowedDbClientOptions = PostgresDbClientOptions;
-declare const getPongoDb: <DbClientOptions extends AllowedDbClientOptions = AllowedDbClientOptions>(options: DbClientOptions) => PongoDb;
-
-interface PongoCollectionSchema<T extends PongoDocument = PongoDocument> {
-    name: string;
-}
-interface PongoDbSchema<T extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>> {
-    name?: string;
-    collections: T;
-}
-interface PongoClientSchema<T extends Record<string, PongoDbSchema> = Record<string, PongoDbSchema>> {
-    dbs: T;
-}
-type CollectionsMap<T extends Record<string, PongoCollectionSchema>> = {
-    [K in keyof T]: PongoCollection<T[K] extends PongoCollectionSchema<infer U> ? U : PongoDocument>;
-};
-type PongoDbWithSchema<T extends Record<string, PongoCollectionSchema>, Connector extends ConnectorType$1 = ConnectorType$1> = CollectionsMap<T> & PongoDb<Connector>;
-type DBsMap<T extends Record<string, PongoDbSchema>, Connector extends ConnectorType$1 = ConnectorType$1> = {
-    [K in keyof T]: CollectionsMap<T[K]['collections']> & PongoDb<Connector>;
-};
-type PongoClientWithSchema<T extends PongoClientSchema, Connector extends ConnectorType$1 = ConnectorType$1> = DBsMap<T['dbs'], Connector> & PongoClient;
-declare function pongoDbSchema<T extends Record<string, PongoCollectionSchema>>(collections: T): PongoDbSchema<T>;
-declare function pongoDbSchema<T extends Record<string, PongoCollectionSchema>>(name: string, collections: T): PongoDbSchema<T>;
-declare const pongoSchema: {
-    client: <T extends Record<string, PongoDbSchema>>(dbs: T) => PongoClientSchema<T>;
-    db: typeof pongoDbSchema;
-    collection: <T extends PongoDocument>(name: string) => PongoCollectionSchema<T>;
-};
-declare const proxyPongoDbWithSchema: <T extends Record<string, PongoCollectionSchema>, Connector extends ConnectorType$1 = ConnectorType$1>(pongoDb: PongoDb<Connector>, dbSchema: PongoDbSchema<T>, collections: Map<string, PongoCollection<Document>>) => PongoDbWithSchema<T, Connector>;
-declare const proxyClientWithSchema: <TypedClientSchema extends PongoClientSchema>(client: PongoClient, schema: TypedClientSchema | undefined) => PongoClientWithSchema<TypedClientSchema>;
-type PongoCollectionSchemaMetadata = {
-    name: string;
-};
-type PongoDbSchemaMetadata = {
-    name?: string | undefined;
-    collections: PongoCollectionSchemaMetadata[];
-};
-type PongoClientSchemaMetadata = {
-    databases: PongoDbSchemaMetadata[];
-    database: (name?: string) => PongoDbSchemaMetadata | undefined;
-};
-declare const toDbSchemaMetadata: <TypedDbSchema extends PongoDbSchema>(schema: TypedDbSchema) => PongoDbSchemaMetadata;
-declare const toClientSchemaMetadata: <TypedClientSchema extends PongoClientSchema>(schema: TypedClientSchema) => PongoClientSchemaMetadata;
-interface PongoSchemaConfig<TypedClientSchema extends PongoClientSchema = PongoClientSchema> {
-    schema: TypedClientSchema;
-}
-
-type PooledPongoClientOptions = {
-    pool: pg.Pool;
-} | {
-    pooled: true;
-} | {
-    pool: pg.Pool;
-    pooled: true;
-} | object;
-type NotPooledPongoOptions = {
-    client: pg.Client;
-} | {
-    pooled: false;
-} | {
-    client: pg.Client;
-    pooled: false;
-} | {
-    connection: NodePostgresConnection;
-    pooled?: false;
-};
-type PongoClientOptions<TypedClientSchema extends PongoClientSchema = PongoClientSchema> = {
-    schema?: {
-        autoMigration?: MigrationStyle;
-        definition?: TypedClientSchema;
-    };
-    errors?: {
-        throwOnOperationFailures?: boolean;
-    };
-    connectionOptions?: PooledPongoClientOptions | NotPooledPongoOptions;
-};
-declare const pongoClient: <TypedClientSchema extends PongoClientSchema = PongoClientSchema, DbClientOptions extends AllowedDbClientOptions = AllowedDbClientOptions>(connectionString: string, options?: PongoClientOptions<TypedClientSchema>) => PongoClient & PongoClientWithSchema<TypedClientSchema>;
-declare const clientToDbOptions: <DbClientOptions extends AllowedDbClientOptions = AllowedDbClientOptions>(options: {
-    connectionString: string;
-    dbName?: string;
-    clientOptions: PongoClientOptions;
-}) => DbClientOptions;
-
-export { type WithIdAndVersion as $, type AllowedDbClientOptions as A, type PongoClient as B, type CollectionsMap as C, type DocumentHandler as D, type CollectionOperationOptions as E, type InsertManyOptions as F, type UpdateManyOptions as G, type HandleOptions as H, type InsertOneOptions as I, type DeleteOneOptions as J, type DeleteManyOptions as K, type FindOptions as L, type HasId as M, type NotPooledPongoOptions as N, ObjectId as O, type PongoDb as P, type InferIdType as Q, type ReplaceOneOptions as R, type EnhancedOmit as S, type OptionalUnlessRequiredId as T, type UpdateOneOptions as U, type OptionalUnlessRequiredVersion as V, type OptionalUnlessRequiredIdAndVersion as W, type WithId as X, type WithoutId as Y, type WithVersion as Z, type WithoutVersion as _, type PongoHandleResult as a, type WithoutIdAndVersion as a0, type RegExpOrString as a1, type Document as a2, type OptionalId as a3, type OptionalVersion as a4, type ObjectIdLike as a5, type NonObjectIdLikeDocument as a6, type AlternativeType as a7, type Condition as a8, type PongoFilter as a9, isPostgresClientOptions as aA, postgresDb as aB, pongoDbSchemaComponent as aC, type RootFilterOperators as aa, type PongoFilterOperator as ab, type $set as ac, type $unset as ad, type $inc as ae, type $push as af, type ExpectedDocumentVersionGeneral as ag, type ExpectedDocumentVersionValue as ah, type ExpectedDocumentVersion as ai, DOCUMENT_EXISTS as aj, DOCUMENT_DOES_NOT_EXIST as ak, NO_CONCURRENCY_CHECK as al, isGeneralExpectedDocumentVersion as am, expectedVersionValue as an, expectedVersion as ao, type PongoUpdate as ap, type OperationResult as aq, operationResult as ar, type PongoInsertOneResult as as, type PongoInsertManyResult as at, type PongoUpdateResult as au, type PongoUpdateManyResult as av, type PongoDeleteResult as aw, type PongoDeleteManyResult as ax, type PongoDocument as ay, type PostgresDbClientOptions as az, type PongoClientOptions as b, type PongoCollection as c, type PongoTransactionOptions as d, type PongoSession as e, type PongoDbTransaction as f, type PooledPongoClientOptions as g, clientToDbOptions as h, type PongoDbClientOptions as i, getPongoDb as j, type PongoCollectionSchema as k, type PongoDbSchema as l, type PongoClientSchema as m, type PongoDbWithSchema as n, type DBsMap as o, pongoClient as p, type PongoClientWithSchema as q, pongoSchema as r, proxyPongoDbWithSchema as s, proxyClientWithSchema as t, type PongoCollectionSchemaMetadata as u, type PongoDbSchemaMetadata as v, type PongoClientSchemaMetadata as w, toDbSchemaMetadata as x, toClientSchemaMetadata as y, type PongoSchemaConfig as z };