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

package/dist/pongoCollectionSchemaComponent-t_e9n2Wc.d.ts

@@ -0,0 +1,426 @@
+import { DatabaseDriverType, SchemaComponent, MigrationStyle, WithDatabaseTransactionFactory, AnyConnection, DatabaseTransaction, SQLExecutor, SQL, QueryResultRow, QueryResult, SchemaComponentOptions } from '@event-driven-io/dumbo';
+
+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>, DriverType extends DatabaseDriverType = DatabaseDriverType> = CollectionsMap<T> & PongoDb<DriverType>;
+type DBsMap<T extends Record<string, PongoDbSchema>, DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>> = {
+    [K in keyof T]: CollectionsMap<T[K]['collections']> & Database;
+};
+type PongoClientWithSchema<T extends PongoClientSchema, DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>> = DBsMap<T['dbs'], DriverType, Database> & PongoClient<DriverType, Database>;
+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 namespace pongoDbSchema {
+    var from: (databaseName: string | undefined, collectionNames: string[]) => PongoDbSchema;
+}
+declare const pongoSchema: {
+    client: <T extends Record<string, PongoDbSchema>>(dbs: T) => PongoClientSchema<T>;
+    db: typeof pongoDbSchema;
+    collection: {
+        <T extends PongoDocument>(name: string): PongoCollectionSchema<T>;
+        from(collectionNames: string[]): Record<string, PongoCollectionSchema>;
+    };
+};
+declare const proxyPongoDbWithSchema: <Collections extends Record<string, PongoCollectionSchema>, DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>>(pongoDb: Database, dbSchema: PongoDbSchema<Collections>, collections: Map<string, PongoCollection<Document>>) => PongoDbWithSchema<Collections, DriverType> & Database;
+declare const proxyClientWithSchema: <TypedClientSchema extends PongoClientSchema, DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>>(client: PongoClient<DriverType, Database>, schema: TypedClientSchema | undefined) => PongoClientWithSchema<TypedClientSchema, DriverType, Database>;
+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 PongoDatabaseURNType = 'sc:dumbo:database';
+type PongoDatabaseURN = `${PongoDatabaseURNType}:${string}`;
+type PongoDatabaseSchemaComponentOptions<DriverType extends DatabaseDriverType = DatabaseDriverType, T extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>> = Readonly<{
+    driverType: DriverType;
+    definition: PongoDbSchema<T>;
+    collectionFactory: <T extends PongoDocument = PongoDocument>(schema: PongoCollectionSchema<T>) => PongoCollectionSchemaComponent;
+}>;
+type PongoDatabaseSchemaComponent<DriverType extends DatabaseDriverType = DatabaseDriverType, T extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>> = SchemaComponent<PongoDatabaseURN> & {
+    definition: PongoDbSchema<T>;
+    collections: ReadonlyArray<PongoCollectionSchemaComponent>;
+    collection: <T extends PongoDocument = PongoDocument>(schema: PongoCollectionSchema<T>) => PongoCollectionSchemaComponent;
+};
+declare const PongoDatabaseSchemaComponent: <DriverType extends DatabaseDriverType = DatabaseDriverType>({ definition, collectionFactory, }: PongoDatabaseSchemaComponentOptions<DriverType>) => PongoDatabaseSchemaComponent;
+type PongoDatabaseSQLBuilder<DriverType extends DatabaseDriverType = DatabaseDriverType> = {
+    driverType: DriverType;
+    collection: PongoCollectionSQLBuilder;
+};
+
+interface PongoDatabaseDriverOptions<ConnectionOptions = unknown> {
+    connectionOptions?: ConnectionOptions | undefined;
+}
+type AnyPongoDatabaseDriverOptions = PongoDatabaseDriverOptions<any>;
+type PongoDatabaseFactoryOptions<CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>, DriverOptions extends AnyPongoDatabaseDriverOptions = AnyPongoDatabaseDriverOptions> = {
+    databaseName?: string | undefined;
+    schema?: {
+        autoMigration?: MigrationStyle;
+        definition?: PongoDbSchema<CollectionsSchema>;
+    } | undefined;
+    errors?: {
+        throwOnOperationFailures?: boolean;
+    } | undefined;
+} & DriverOptions;
+type DatabaseDriverOptionsWithDatabaseName = {
+    databaseName?: string | undefined;
+};
+type DatabaseDriverOptionsWithConnectionString = {
+    connectionString?: string | undefined;
+};
+interface PongoDatabaseDriver<Database extends AnyPongoDb = AnyPongoDb, DriverOptions extends AnyPongoDatabaseDriverOptions = AnyPongoDatabaseDriverOptions> {
+    driverType: Database['driverType'];
+    databaseFactory<CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>>(options: PongoDatabaseFactoryOptions<CollectionsSchema, DriverOptions>): Database & PongoDb<Database['driverType']>;
+    getDatabaseNameOrDefault?<CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>>(options: PongoDatabaseFactoryOptions<CollectionsSchema, DriverOptions>): string;
+    defaultConnectionString: string;
+}
+type AnyPongoDatabaseDriver = PongoDatabaseDriver<AnyPongoDb, AnyPongoDatabaseDriverOptions>;
+type ExtractPongoDatabaseDriverOptions<DatabaseDriver> = DatabaseDriver extends PongoDatabaseDriver<any, infer O> ? O : never;
+type ExtractPongoDatabaseTypeFromDriver<DatabaseDriver> = DatabaseDriver extends PongoDatabaseDriver<infer D, any> ? D : never;
+declare const PongoDatabaseDriverRegistry: () => {
+    register: <Database extends AnyPongoDb = AnyPongoDb>(driverType: Database["driverType"], driver: PongoDatabaseDriver<Database> | (() => Promise<PongoDatabaseDriver<Database>>)) => void;
+    tryResolve: <Driver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver>(driverType: Driver["driverType"]) => Promise<Driver | null>;
+    tryGet: <Driver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver>(driverType: Driver["driverType"]) => Driver | null;
+    has: (driverType: DatabaseDriverType) => boolean;
+    readonly databaseDriverTypes: DatabaseDriverType[];
+};
+declare global {
+    var pongoDatabaseDriverRegistry: ReturnType<typeof PongoDatabaseDriverRegistry>;
+}
+declare const pongoDatabaseDriverRegistry: {
+    register: <Database extends AnyPongoDb = AnyPongoDb>(driverType: Database["driverType"], driver: PongoDatabaseDriver<Database> | (() => Promise<PongoDatabaseDriver<Database>>)) => void;
+    tryResolve: <Driver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver>(driverType: Driver["driverType"]) => Promise<Driver | null>;
+    tryGet: <Driver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver>(driverType: Driver["driverType"]) => Driver | null;
+    has: (driverType: DatabaseDriverType) => boolean;
+    readonly databaseDriverTypes: DatabaseDriverType[];
+};
+
+interface PongoClient<DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>> {
+    driverType: DriverType;
+    connect(): Promise<this>;
+    close(): Promise<void>;
+    db(dbName?: string): Database;
+    startSession(): PongoSession<DriverType>;
+    withSession<T = unknown>(callback: (session: PongoSession<DriverType>) => Promise<T>): Promise<T>;
+}
+type PongoClientOptions<DatabaseDriver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver, TypedClientSchema extends PongoClientSchema = PongoClientSchema> = ExtractPongoDatabaseDriverOptions<DatabaseDriver> extends infer Options ? Options extends unknown ? {
+    driver: DatabaseDriver;
+    schema?: {
+        autoMigration?: MigrationStyle;
+        definition?: TypedClientSchema;
+    } | undefined;
+    errors?: {
+        throwOnOperationFailures?: boolean;
+    } | undefined;
+} & Omit<Options, 'driver'> : never : never;
+declare interface PongoTransactionOptions {
+    get snapshotEnabled(): boolean;
+    maxCommitTimeMS?: number;
+}
+interface PongoDbTransaction<DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>> {
+    get databaseName(): string | null;
+    options: PongoTransactionOptions;
+    enlistDatabase: (database: Database) => Promise<DatabaseTransaction<AnyConnection>>;
+    commit: () => Promise<void>;
+    rollback: (error?: unknown) => Promise<void>;
+    get sqlExecutor(): SQLExecutor;
+    get isStarting(): boolean;
+    get isActive(): boolean;
+    get isCommitted(): boolean;
+}
+interface PongoSession<DriverType extends DatabaseDriverType = DatabaseDriverType> {
+    hasEnded: boolean;
+    explicit: boolean;
+    defaultTransactionOptions: PongoTransactionOptions;
+    transaction: PongoDbTransaction<DriverType> | 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<DriverType>) => Promise<T>, options?: PongoTransactionOptions): Promise<T>;
+}
+interface PongoDb<DriverType extends DatabaseDriverType = DatabaseDriverType> extends WithDatabaseTransactionFactory<AnyConnection> {
+    driverType: DriverType;
+    databaseName: string;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    collection<T extends PongoDocument>(name: string): PongoCollection<T>;
+    collections(): ReadonlyArray<PongoCollection<PongoDocument>>;
+    readonly schema: Readonly<{
+        component: PongoDatabaseSchemaComponent<DriverType>;
+        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 AnyPongoDb = PongoDb<DatabaseDriverType>;
+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: PongoCollectionSchemaComponent;
+        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 PongoCollectionSQLBuilder = {
+    createCollection: () => SQL;
+    insertOne: <T>(document: OptionalUnlessRequiredIdAndVersion<T>) => SQL;
+    insertMany: <T>(documents: OptionalUnlessRequiredIdAndVersion<T>[]) => SQL;
+    updateOne: <T>(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions) => SQL;
+    replaceOne: <T>(filter: PongoFilter<T> | SQL, document: WithoutId<T>, options?: ReplaceOneOptions) => SQL;
+    updateMany: <T>(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL) => SQL;
+    deleteOne: <T>(filter: PongoFilter<T> | SQL, options?: DeleteOneOptions) => SQL;
+    deleteMany: <T>(filter: PongoFilter<T> | SQL) => SQL;
+    findOne: <T>(filter: PongoFilter<T> | SQL) => SQL;
+    find: <T>(filter: PongoFilter<T> | SQL, options?: FindOptions) => SQL;
+    countDocuments: <T>(filter: PongoFilter<T> | SQL) => SQL;
+    rename: (newName: string) => SQL;
+    drop: () => SQL;
+};
+
+type PongoCollectionURNType = 'sc:pongo:collection';
+type PongoCollectionURN = `${PongoCollectionURNType}:${string}`;
+type PongoCollectionSchemaComponentOptions<DriverType extends DatabaseDriverType = DatabaseDriverType> = Readonly<{
+    driverType: DriverType;
+    definition: PongoCollectionSchema;
+    migrationsOrSchemaComponents: SchemaComponentOptions;
+    sqlBuilder: PongoCollectionSQLBuilder;
+}>;
+type PongoCollectionSchemaComponent = SchemaComponent<PongoCollectionURN> & {
+    collectionName: string;
+    definition: PongoCollectionSchema;
+    sqlBuilder: PongoCollectionSQLBuilder;
+};
+declare const PongoCollectionSchemaComponent: <DriverType extends DatabaseDriverType = DatabaseDriverType>({ definition, migrationsOrSchemaComponents, sqlBuilder, }: PongoCollectionSchemaComponentOptions<DriverType>) => PongoCollectionSchemaComponent;
+
+export { type DeleteOneOptions as $, type AnyPongoDb as A, type DatabaseDriverOptionsWithConnectionString as B, type CollectionOperationOptions as C, type DatabaseDriverOptionsWithDatabaseName as D, type ExtractPongoDatabaseTypeFromDriver as E, type ExtractPongoDatabaseDriverOptions as F, PongoDatabaseDriverRegistry as G, pongoDatabaseDriverRegistry as H, type CollectionsMap as I, type PongoDbWithSchema as J, type DBsMap as K, pongoSchema as L, proxyPongoDbWithSchema as M, proxyClientWithSchema as N, type PongoCollectionSchemaMetadata as O, type PongoDatabaseDriver as P, type PongoDbSchemaMetadata as Q, type PongoClientSchemaMetadata as R, toDbSchemaMetadata as S, toClientSchemaMetadata as T, type PongoSchemaConfig as U, type InsertOneOptions as V, type InsertManyOptions as W, type UpdateOneOptions as X, type UpdateManyOptions as Y, type HandleOptions as Z, type ReplaceOneOptions as _, type PongoDb as a, type DeleteManyOptions as a0, type FindOptions as a1, ObjectId as a2, type HasId as a3, type InferIdType as a4, type EnhancedOmit as a5, type OptionalUnlessRequiredId as a6, type OptionalUnlessRequiredVersion as a7, type OptionalUnlessRequiredIdAndVersion as a8, type WithId as a9, isGeneralExpectedDocumentVersion as aA, expectedVersionValue as aB, expectedVersion as aC, type PongoUpdate as aD, type OperationResult as aE, operationResult as aF, type PongoInsertOneResult as aG, type PongoInsertManyResult as aH, type PongoUpdateResult as aI, type PongoUpdateManyResult as aJ, type PongoDeleteResult as aK, type PongoDeleteManyResult as aL, type PongoHandleResult as aM, type DocumentHandler as aN, type WithoutId as aa, type WithVersion as ab, type WithoutVersion as ac, type WithIdAndVersion as ad, type WithoutIdAndVersion as ae, type RegExpOrString as af, type Document as ag, type OptionalId as ah, type OptionalVersion as ai, type ObjectIdLike as aj, type NonObjectIdLikeDocument as ak, type AlternativeType as al, type Condition as am, type PongoFilter as an, type RootFilterOperators as ao, type PongoFilterOperator as ap, type $set as aq, type $unset as ar, type $inc as as, type $push as at, type ExpectedDocumentVersionGeneral as au, type ExpectedDocumentVersionValue as av, type ExpectedDocumentVersion as aw, DOCUMENT_EXISTS as ax, DOCUMENT_DOES_NOT_EXIST as ay, NO_CONCURRENCY_CHECK as az, type PongoDatabaseDriverOptions as b, PongoCollectionSchemaComponent as c, type PongoDocument as d, type PongoCollection as e, type PongoClientSchema as f, type PongoCollectionSchema as g, type PongoDatabaseFactoryOptions as h, PongoDatabaseSchemaComponent as i, type PongoDbSchema as j, type AnyPongoDatabaseDriver as k, type PongoClientOptions as l, type PongoClient as m, type PongoClientWithSchema as n, type PongoTransactionOptions as o, type PongoSession as p, type PongoDbTransaction as q, type PongoCollectionSQLBuilder as r, type PongoCollectionURNType as s, type PongoCollectionURN as t, type PongoCollectionSchemaComponentOptions as u, type PongoDatabaseURNType as v, type PongoDatabaseURN as w, type PongoDatabaseSchemaComponentOptions as x, type PongoDatabaseSQLBuilder as y, type AnyPongoDatabaseDriverOptions as z };

package/dist/shim.cjs

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
 
-var _chunkAV4SHJQBcjs = require('./chunk-AV4SHJQB.cjs');
+var _chunkTP73JUIXcjs = require('./chunk-TP73JUIX.cjs');
 
 // src/mongo/findCursor.ts
 var FindCursor = (_class = class {
@@ -35,6 +35,13 @@ var FindCursor = (_class = class {
   }
 }, _class);
 
+// src/mongo/mongoClient.ts
+
+
+
+var _dumbo = require('@event-driven-io/dumbo');
+require('http2');
+
 // src/mongo/mongoDb.ts
 require('mongodb');
 
@@ -58,8 +65,13 @@ var toFindOptions = (options) => {
 };
 var Collection = class {
   
-  constructor(collection) {
+  
+  constructor(database, collection) {
     this.collection = collection;
+    this.database = database;
+  }
+  get db() {
+    return this.database;
   }
   get dbName() {
     return this.collection.dbName;
@@ -85,6 +97,9 @@ var Collection = class {
   get hint() {
     return void 0;
   }
+  get timeoutMS() {
+    return void 0;
+  }
   set hint(v) {
     throw new Error("Method not implemented.");
   }
@@ -304,15 +319,34 @@ var Db = class {
     return this.pongoDb.databaseName;
   }
   collection(collectionName) {
-    return new Collection(this.pongoDb.collection(collectionName));
+    return new Collection(this, this.pongoDb.collection(collectionName));
   }
 };
 
 // src/mongo/mongoClient.ts
 var MongoClient = class {
   
-  constructor(connectionString, options = {}) {
-    this.pongoClient = _chunkAV4SHJQBcjs.pongoClient.call(void 0, connectionString, options);
+  constructor(connectionStringOrOptions, options) {
+    if (typeof connectionStringOrOptions !== "string") {
+      this.pongoClient = _chunkTP73JUIXcjs.pongoClient.call(void 0, connectionStringOrOptions);
+      return;
+    }
+    const { databaseType, driverName } = _dumbo.parseConnectionString.call(void 0, 
+      connectionStringOrOptions
+    );
+    const driver = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.driver]), () => ( pongoDatabaseDriverRegistry.tryGet(
+      _dumbo.toDatabaseDriverType.call(void 0, databaseType, driverName)
+    )));
+    if (driver === null) {
+      throw new Error(
+        `No database driver registered for ${databaseType} with name ${driverName}`
+      );
+    }
+    this.pongoClient = _chunkTP73JUIXcjs.pongoClient.call(void 0, {
+      ..._nullishCoalesce(options, () => ( {})),
+      ...{ connectionString: connectionStringOrOptions },
+      driver
+    });
   }
   async connect() {
     await this.pongoClient.connect();
@@ -325,12 +359,12 @@ var MongoClient = class {
     return new Db(this.pongoClient.db(dbName));
   }
   startSession(_options) {
-    return _chunkAV4SHJQBcjs.pongoSession.call(void 0, );
+    return _chunkTP73JUIXcjs.pongoSession.call(void 0, );
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async withSession(optionsOrExecutor, executor) {
     const callback = typeof optionsOrExecutor === "function" ? optionsOrExecutor : executor;
-    const session = _chunkAV4SHJQBcjs.pongoSession.call(void 0, );
+    const session = _chunkTP73JUIXcjs.pongoSession.call(void 0, );
     try {
       return await callback(session);
     } finally {