@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/dist/ArrayReader.d.ts

@@ -0,0 +1,12 @@
+import type { IReader } from "./IReader.js";
+export declare class ArrayReader<T = unknown> implements IReader<T> {
+    private readonly rows;
+    private index;
+    current: T | undefined;
+    constructor(rows: readonly T[]);
+    next(): Promise<boolean>;
+    read(): AsyncIterable<T>;
+    nextResult(): Promise<boolean>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}

package/dist/BatchCommandIBulkWriteStrategy.d.ts

@@ -0,0 +1,33 @@
+import type { CRUDRepository } from "./CRUDRepository.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { Response } from "./Response.js";
+import type { IWhere } from "./statements/IWhere.js";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.js";
+import { type ICommand } from "./ICommand.js";
+export declare class BatchCommandIBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
+    repo: CRUDRepository<T>;
+    command: ICommand;
+    options: CRUDRepositoryOptions<T>;
+    private cached?;
+    attach: (command: ICommand, options: CRUDRepositoryOptions<T>) => void;
+    create: (items: T[]) => Promise<Response>;
+    update: (items: T[], byWhere: IWhere | undefined) => Promise<Response>;
+    delete: (items: T[], byWhere: IWhere | undefined) => Promise<Response>;
+    private then;
+    private writeCreates;
+    private writeUpdates;
+    private writeDeletes;
+    private chunked;
+    private sendEach;
+    private mappedInsert;
+    private mappedUpdate;
+    private mappedDelete;
+    private updateCommand;
+    private deleteCommand;
+    private statements;
+    private get ids();
+    private reverse;
+    private fields;
+    private cell;
+    private idsWhere;
+}

package/dist/BuiltRepository.d.ts

@@ -0,0 +1,16 @@
+import type { IConnection } from "./IConnection.js";
+import type { Cells } from "./converters/Cell.js";
+import type { Constructable } from "./converters/Constructable.js";
+import type { TypeConverter } from "./converters/TypeConverter.js";
+import type { IMapper } from "./mappers/IMapper.js";
+import type { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+export type BuiltRepository<T = Cells> = {
+    connection: IConnection;
+    rowConverter?: TypeConverter<Cells, Cells>;
+    objectConverter: TypeConverter<T, Cells>;
+    propertyMappings: IMapper<string, string>;
+    entityMapper: IMapper<string, string>;
+    statements: ReadonlyRepositoryStatements;
+    ids: string[];
+    type: Constructable<T>;
+};

package/dist/BulkCRUDRepository.d.ts

@@ -0,0 +1,17 @@
+import type { IConnection } from "./IConnection.js";
+import type { Constructable } from "./converters/Constructable.js";
+import type { Cells } from "./converters/Cell.js";
+import { CRUDRepository } from "./CRUDRepository.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { Response } from "./Response.js";
+import type { IWhere } from "./statements/IWhere.js";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.js";
+export declare class BulkCRUDRepository<T extends object = Cells> extends CRUDRepository<T> {
+    private readonly strategy;
+    private readonly transactional;
+    constructor(type: Constructable<T>, connection: IConnection, bulk?: IBulkWriteStrategy<T>);
+    constructor(connection: IConnection, options: CRUDRepositoryOptions<T>, bulk?: IBulkWriteStrategy<T>);
+    createBulk: (items: T[]) => Promise<T[]>;
+    updateBulk: (items: T[], byWhere?: IWhere) => Promise<Response>;
+    deleteBulk: (items: T[], byWhere?: IWhere) => Promise<Response>;
+}

package/dist/BulkCommand.d.ts

@@ -0,0 +1,5 @@
+import type { Parameter } from "./Parameter.js";
+export interface BulkCommand {
+    text: string;
+    parameters: Parameter[];
+}

package/dist/BulkWriteEnrichment.d.ts

@@ -0,0 +1,4 @@
+import type { CRUDRepository } from "./CRUDRepository.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { WriteMode } from "./WriteMode.js";
+export declare const afterBulkWrite: <T extends object>(repo: CRUDRepository<T>, options: CRUDRepositoryOptions<T>, items: T[], mode: WriteMode) => Promise<void>;

package/dist/CRUDRepository.d.ts

@@ -0,0 +1,40 @@
+import type { IConnection } from "./IConnection.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { Response } from "./Response.js";
+import type { IWhere } from "./statements/IWhere.js";
+import type { Scalar } from "./builders/Scalar.js";
+import type { Cells } from "./converters/Cell.js";
+import type { Constructable } from "./converters/Constructable.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import { ReadonlyRepository } from "./ReadonlyRepository.js";
+import type { Enrichment } from "./Enrichment.js";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+export declare class CRUDRepository<T = Cells> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
+    readonly ids: readonly string[];
+    private readonly crudStatements;
+    private readonly tree;
+    private readonly write;
+    private get useTransaction();
+    constructor(type: Constructable<T>, connection: IConnection);
+    constructor(connection: IConnection, options: CRUDRepositoryOptions<T>);
+    addEnriched<TRelated extends object>(enrichment: Enrichment, via: IReadonlyRepository<TRelated>, strategy?: IReadonlyEnrichmentStrategy<T & object>): this;
+    addLinked<TRelated extends object, TLink extends object>(enrichment: Enrichment, via: IReadonlyRepository<TRelated>, link: ICRUDRepository<TLink>, strategy?: IReadonlyEnrichmentStrategy<T & object>): this;
+    create: (item: T) => Promise<T>;
+    update: (item: T, byWhere?: IWhere) => Promise<Response>;
+    delete: (item: T, byWhere?: IWhere) => Promise<Response>;
+    private inTransaction;
+    private createCore;
+    private updateCore;
+    private deleteCore;
+    readSingleById: (id: Scalar | Cells) => Promise<T | undefined>;
+    private insert;
+    private copyInsertedId;
+    private idValue;
+    private save;
+    private remove;
+    private byId;
+    private reverseConvert;
+    private idWhere;
+    protected enrichmentInto: (name: string) => boolean;
+}

package/dist/CRUDRepositoryBuilder.d.ts

@@ -0,0 +1,19 @@
+import type { IConnection } from "./IConnection.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import { CRUDRepository } from "./CRUDRepository.js";
+import { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.js";
+import type { BuiltRepository } from "./BuiltRepository.js";
+import type { Constructable } from "./converters/Constructable.js";
+import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+export declare const repositoryParts: <T>(typeOrConnection: Constructable<T> | IConnection, connectionOrOptions?: IConnection | CRUDRepositoryOptions<T>) => {
+    built: BuiltRepository<T>;
+    statements: CRUDRepositoryStatements;
+};
+export declare class CRUDRepositoryBuilder<T = object> extends ReadonlyRepositoryBuilder<T> {
+    crudStatements?: CRUDRepositoryStatements;
+    protected ids: (options: ReadonlyRepositoryMappingOptions<T>) => string[];
+    protected statements: (table: string, columns: string[]) => ReadonlyRepositoryStatements;
+    build: (connection: IConnection, options: CRUDRepositoryOptions<T>) => CRUDRepository<T>;
+}

package/dist/CRUDRepositoryOptions.d.ts

@@ -0,0 +1,7 @@
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+import type { Cells } from "./converters/Cell.js";
+import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.js";
+export type CRUDRepositoryOptions<T = Cells> = ReadonlyRepositoryMappingOptions<T> & {
+    ids?: string[];
+    write?: IWriteEnrichmentStrategy<T>;
+};

package/dist/CRUDRepositoryStatements.d.ts

@@ -0,0 +1,17 @@
+import type { Cell } from "./converters/Cell.js";
+import type { Field } from "./builders/Field.js";
+import type { IMapper } from "./mappers/IMapper.js";
+import { DeleteStatement } from "./statements/DeleteStatement.js";
+import { InsertStatement } from "./statements/InsertStatement.js";
+import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.js";
+import { UpdateStatement } from "./statements/UpdateStatement.js";
+import type { IWhere } from "./statements/IWhere.js";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+export declare class CRUDRepositoryStatements extends ReadonlyRepositoryStatements {
+    private readonly mappings;
+    constructor(table: string, columns: readonly string[], entityMappers?: IMapper<string, string>, propertyMappers?: IMapper<string, string>);
+    insert: (fields: Field[]) => InsertStatement;
+    update: (fields: Field[], where?: IWhere, cell?: (name: string, value: Cell) => Cell) => UpdateStatement;
+    delete: (where?: IWhere, cell?: (name: string, value: Cell) => Cell) => DeleteStatement;
+    selectInsertedId: (column: string) => SelectInsertedIdStatement;
+}

package/dist/CascadeDeleteEnrichmentStrategy.d.ts

@@ -0,0 +1,7 @@
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+export declare class CascadeDeleteEnrichmentStrategy<T> extends DeleteEnrichmentStrategy<T> {
+    deleteChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T, deleteNested: (rows: TChild[]) => Promise<void>): Promise<void>;
+    deleteLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+}

package/dist/CascadeDeleteUpdateEnrichmentStrategy.d.ts

@@ -0,0 +1,8 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+export declare class CascadeDeleteUpdateEnrichmentStrategy<T> extends UpdateEnrichmentStrategy<T> {
+    private readonly create;
+    updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    updateLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+}

package/dist/CommandMiddlewareHost.d.ts

@@ -0,0 +1,22 @@
+import type { ICommandMiddleware } from "./ICommandMiddleware.js";
+import type { IReader } from "./IReader.js";
+import type { Parameter } from "./Parameter.js";
+import type { Response } from "./Response.js";
+import type { Row } from "./Row.js";
+import type { Cells } from "./converters/Cell.js";
+import type { IStatement } from "./statements/IStatement.js";
+import { Native } from "./statements/Native.js";
+export declare class CommandMiddlewareHost {
+    private readonly middlewares;
+    addMiddleware(middleware: ICommandMiddleware): this;
+    execute(text: string, parameters?: Parameter[]): Promise<Response>;
+    executeReader(text: string, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response>;
+    executeReaderStatement(statement: IStatement, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeNative(_text: Native, _parameters?: Parameter[]): Promise<Response>;
+    executeReaderNative(_text: Native, _parameters?: Parameter[]): Promise<IReader<Cells>>;
+    run<T>(text: string, params: Parameter[] | undefined, fn: (text: string, params?: Parameter[]) => Promise<{
+        value: T;
+        rows: readonly Row[];
+    }>): Promise<T>;
+}

package/dist/ConsoleCommandMiddleware.d.ts

@@ -0,0 +1,14 @@
+import type { ICommandMiddleware } from "./ICommandMiddleware.js";
+import type { Parameter } from "./Parameter.js";
+import type { Row } from "./Row.js";
+export declare const formatElapsed: (elapsedMs: number) => string;
+export declare class ConsoleCommandMiddleware implements ICommandMiddleware {
+    private readonly write;
+    private readonly now;
+    private readonly options;
+    constructor(write?: (line: string) => void, now?: () => Date, options?: Record<string, string>);
+    beforeCommand: (text: string, params?: ReadonlyArray<Parameter>) => void;
+    afterCommand: (text: string, _params: ReadonlyArray<Parameter> | undefined, results: ReadonlyArray<Row>, elapsedMs: number) => void;
+    private verbose;
+    private line;
+}

package/dist/CreateEnrichmentStrategy.d.ts

@@ -0,0 +1,14 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { Scalar } from "./builders/Scalar.js";
+export declare abstract class CreateEnrichmentStrategy<T> {
+    abstract createChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    abstract createLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    collectChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): TChild[];
+    protected getCell: <TItem>(item: TItem, name: string) => Scalar | object | undefined;
+    protected presentCell: (value: Scalar | object | undefined) => value is Scalar;
+    protected payloadOf: <TChild extends object, TParent>(parent: TParent, into: string, enrichment?: Enrichment) => TChild[];
+    protected stampCell: <TItem extends object>(related: TItem, by: string, key: Scalar | object | undefined) => void;
+    protected relatedIds: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar[];
+    protected requiredKey: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar;
+}

package/dist/Datasource.d.ts

@@ -0,0 +1,30 @@
+import type { Constructable } from "./converters/Constructable.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { ICommand } from "./ICommand.js";
+import type { IConnection } from "./IConnection.js";
+import type { IDatasource } from "./IDatasource.js";
+import type { IDriver } from "./IDriver.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { DatasourceOptions } from "./DatasourceOptions.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+import { RepositoryFactory } from "./RepositoryFactory.js";
+export declare class Datasource implements IDatasource {
+    readonly provider: string;
+    private readonly driver;
+    private readonly options?;
+    private connection?;
+    readonly repositories: RepositoryFactory;
+    constructor(provider: string, driver: IDriver, options?: DatasourceOptions | undefined);
+    private defaultConnection;
+    createConnection: () => Promise<IConnection>;
+    createCommand: (connection?: IConnection) => Promise<ICommand>;
+    private applyCrud;
+    private applyReadonly;
+    createRepository<T>(type: Constructable<T>, connection?: IConnection, options?: CRUDRepositoryOptions<T>): ICRUDRepository<T>;
+    createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
+    createReadonlyRepository<T>(type: Constructable<T>, connection?: IConnection, options?: ReadonlyRepositoryMappingOptions<T>): IReadonlyRepository<T>;
+    createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
+    static create: (options?: DatasourceOptions) => Datasource;
+    static get default(): Datasource;
+}

package/dist/DatasourceError.d.ts

@@ -0,0 +1,3 @@
+export declare class DatasourceError extends Error {
+    constructor(message: string);
+}

package/dist/DatasourceFactory.d.ts

@@ -0,0 +1,12 @@
+import type { IDatasource } from "./IDatasource.js";
+import type { IDatasourceFactory } from "./IDatasourceFactory.js";
+import type { IDriver } from "./IDriver.js";
+import type { DatasourceOptions } from "./DatasourceOptions.js";
+export declare class DatasourceFactory implements IDatasourceFactory {
+    static defaults: (options: DatasourceOptions) => void;
+    static register: (provider: string, driver: IDriver) => void;
+    static create: (options?: DatasourceOptions) => IDatasource;
+    create: (options?: DatasourceOptions) => IDatasource;
+    static reset: () => void;
+    static registered: () => string[];
+}

package/dist/DatasourceOptions.d.ts

@@ -0,0 +1 @@
+export type DatasourceOptions = Record<string, string>;

package/dist/DatasourceUrl.d.ts

@@ -0,0 +1,12 @@
+export declare class DatasourceUrl {
+    readonly provider: string;
+    readonly username: string | undefined;
+    readonly password: string | undefined;
+    readonly host: string | undefined;
+    readonly port: number | undefined;
+    readonly path: string;
+    readonly schema: string | undefined;
+    readonly options: Readonly<Record<string, string>>;
+    constructor(provider: string, username: string | undefined, password: string | undefined, host: string | undefined, port: number | undefined, path: string, schema: string | undefined, options: Readonly<Record<string, string>>);
+    get datasource(): string | undefined;
+}

package/dist/DatasourceUrlParser.d.ts

@@ -0,0 +1,4 @@
+import { DatasourceUrl } from "./DatasourceUrl.js";
+export declare class DatasourceUrlParser {
+    static parse(url: string | undefined): DatasourceUrl | undefined;
+}

package/dist/DefaultCreateEnrichmentStrategy.d.ts

@@ -0,0 +1,7 @@
+import { CreateEnrichmentStrategy } from "./CreateEnrichmentStrategy.js";
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+export declare class DefaultCreateEnrichmentStrategy<T> extends CreateEnrichmentStrategy<T> {
+    createChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    createLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+}

package/dist/DefaultReadonlyEnrichmentStrategy.d.ts

@@ -0,0 +1,19 @@
+import type { Scalar } from "./builders/Scalar.js";
+import type { Enrichment } from "./Enrichment.js";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { Row } from "./Row.js";
+type Props = Record<string, Scalar | object>;
+export declare class DefaultReadonlyEnrichmentStrategy<T extends object> implements IReadonlyEnrichmentStrategy<T> {
+    apply<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    applyLinked<TRelated extends object, TLink extends object>(via: IReadonlyRepository<TRelated>, link: IReadonlyRepository<TLink>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    protected applyObject<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    protected applyList<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    protected applyDictionary<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    protected sourceKey(parent: T, name: string, sources: (Row | undefined)[] | undefined, index: number): Scalar | object | undefined;
+    protected props: <TItem>(item: TItem) => Props;
+    protected keyOf: (key: Scalar | object) => string;
+    protected lookupKey: (value: Scalar | object | undefined) => Scalar | object | undefined;
+    protected scalar: (value: Scalar | object) => Scalar;
+}
+export {};

package/dist/DefaultUpdateEnrichmentStrategy.d.ts

@@ -0,0 +1,7 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+export declare class DefaultUpdateEnrichmentStrategy<T> extends UpdateEnrichmentStrategy<T> {
+    updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    updateLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+}

package/dist/DefaultWriteEnrichmentStrategy.d.ts

@@ -0,0 +1,21 @@
+import type { CreateEnrichmentStrategy } from "./CreateEnrichmentStrategy.js";
+import type { IRepositoryTree } from "./IRepositoryTree.js";
+import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.js";
+import type { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import type { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+import type { WriteMode } from "./WriteMode.js";
+export declare class DefaultWriteEnrichmentStrategy<T> implements IWriteEnrichmentStrategy<T> {
+    protected skipUnloaded: boolean;
+    readonly useTransaction: boolean;
+    private readonly createStrategy;
+    private readonly deleteStrategy;
+    private readonly updateStrategy;
+    constructor(deleteStrategy?: DeleteEnrichmentStrategy<T>, updateStrategy?: UpdateEnrichmentStrategy<T>, createStrategy?: CreateEnrichmentStrategy<T>, useTransaction?: boolean);
+    persist: (tree: IRepositoryTree, items: T[], mode: WriteMode) => Promise<void>;
+    persistBulk: (tree: IRepositoryTree, items: T[], mode: WriteMode) => Promise<void>;
+    private walk;
+    private walkBulk;
+    private persistEntryBulk;
+    private persistEntry;
+    private skip;
+}

package/dist/DeleteEnrichmentStrategy.d.ts

@@ -0,0 +1,11 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { Scalar } from "./builders/Scalar.js";
+import { Where } from "./statements/index.js";
+export declare abstract class DeleteEnrichmentStrategy<T> {
+    abstract deleteChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T, deleteNested: (rows: TChild[]) => Promise<void>): Promise<void>;
+    abstract deleteLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    static load: <TParent, TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: TParent) => Promise<TChild[]>;
+    static childrenWhere: <TParent, TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: TParent) => Where | undefined;
+    static loadLinks: <TChild extends object>(writer: ICRUDRepository<TChild>, column: string, key: Scalar) => Promise<TChild[]>;
+}

package/dist/DriverLoader.d.ts

@@ -0,0 +1,5 @@
+import type { IDriver } from "./IDriver.js";
+import type { ProviderCatalog } from "./ProviderCatalog.js";
+export declare class DriverLoader {
+    static load: (catalog: ProviderCatalog) => IDriver;
+}

package/dist/Enrichment.d.ts

@@ -0,0 +1,13 @@
+import type { EnrichmentPropertyType } from "./EnrichmentPropertyType.js";
+export type Association = {
+    parent: string;
+    related: string;
+};
+export type Enrichment = {
+    destinationProperty: string;
+    sourceProperty: string;
+    relatedKey: string;
+    relatedProperty?: string;
+    type?: EnrichmentPropertyType;
+    association?: Association;
+};

package/dist/EnrichmentPropertyType.d.ts

@@ -0,0 +1,7 @@
+export declare const EnrichmentPropertyType: {
+    readonly Object: "object";
+    readonly List: "list";
+    readonly Dictionary: "dictionary";
+    readonly Custom: "custom";
+};
+export type EnrichmentPropertyType = (typeof EnrichmentPropertyType)[keyof typeof EnrichmentPropertyType];

package/dist/ExpectConsoleMiddleware.d.ts

@@ -0,0 +1,15 @@
+import type { ICommandMiddleware } from "./ICommandMiddleware.js";
+import type { Parameter } from "./Parameter.js";
+import type { Row } from "./Row.js";
+export declare const consoleSignature: (line: string) => string;
+export declare class ExpectConsoleMiddleware implements ICommandMiddleware {
+    private readonly expected;
+    private readonly normalize;
+    private readonly inner;
+    private index;
+    constructor(expected: readonly string[], now: () => Date, normalize?: (line: string) => string);
+    beforeCommand: (text: string, params?: ReadonlyArray<Parameter>) => void;
+    afterCommand: (text: string, params: ReadonlyArray<Parameter> | undefined, results: ReadonlyArray<Row>, elapsedMs: number, error?: Error) => void;
+    complete: () => void;
+    private check;
+}

package/dist/FirstResultReader.d.ts

@@ -0,0 +1,19 @@
+import type { Cells } from "./converters/Cell.js";
+import type { IReader } from "./IReader.js";
+export declare class FirstResultReader implements IReader<Cells> {
+    private readonly first;
+    private readonly live;
+    current: Cells | undefined;
+    private index;
+    private firstSet;
+    private constructor();
+    static capture(live: IReader<Cells>): Promise<{
+        value: IReader<Cells>;
+        rows: Cells[];
+    }>;
+    next(): Promise<boolean>;
+    nextResult(): Promise<boolean>;
+    read(): AsyncIterable<Cells>;
+    dispose: () => Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}

package/dist/HashsetOptimizedReadonlyEnrichmentStrategy.d.ts

@@ -0,0 +1,9 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { Row } from "./Row.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+export declare class HashsetOptimizedReadonlyEnrichmentStrategy<T extends object> extends DefaultReadonlyEnrichmentStrategy<T> {
+    protected applyObject<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    protected applyList<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    private keysOf;
+}

package/dist/IBulkWriteStrategy.d.ts

@@ -0,0 +1,12 @@
+import type { CRUDRepository } from "./CRUDRepository.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { ICommand } from "./ICommand.js";
+import type { Response } from "./Response.js";
+import type { IWhere } from "./statements/IWhere.js";
+export interface IBulkWriteStrategy<T extends object> {
+    repo: CRUDRepository<T>;
+    attach(command: ICommand, options: CRUDRepositoryOptions<T>): void;
+    create(items: T[]): Promise<Response>;
+    update(items: T[], byWhere: IWhere | undefined): Promise<Response>;
+    delete(items: T[], byWhere: IWhere | undefined): Promise<Response>;
+}

package/dist/ICRUDRepository.d.ts

@@ -0,0 +1,12 @@
+import type { Scalar } from "./builders/Scalar.js";
+import type { Cells } from "./converters/Cell.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { IWhere } from "./statements/IWhere.js";
+import type { Response } from "./Response.js";
+export interface ICRUDRepository<T = unknown> extends IReadonlyRepository<T> {
+    readonly ids: readonly string[];
+    create(item: T): Promise<T>;
+    update(item: T, byWhere?: IWhere): Promise<Response>;
+    delete(item: T, byWhere?: IWhere): Promise<Response>;
+    readSingleById(id: Scalar | Cells): Promise<T | undefined>;
+}

package/dist/ICRUDRepositoryFactory.d.ts

@@ -0,0 +1,7 @@
+import type { Constructable } from "./converters/Constructable.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { IRepository } from "./IRepository.js";
+export interface ICRUDRepositoryFactory {
+    register(repository: IRepository): void;
+    create<T>(type: Constructable<T>): ICRUDRepository<T>;
+}

package/dist/ICommand.d.ts

@@ -0,0 +1,20 @@
+import type { IStatement } from "./statements/IStatement.js";
+import { Native } from "./statements/Native.js";
+import type { ICommandMiddleware } from "./ICommandMiddleware.js";
+import type { IConnection } from "./IConnection.js";
+import type { Cells } from "./converters/Cell.js";
+import type { IReader } from "./IReader.js";
+import type { Response } from "./Response.js";
+import type { Parameter } from "./Parameter.js";
+export interface ICommand {
+    readonly connection: IConnection;
+    addMiddleware(middleware: ICommandMiddleware): this;
+    executeReader(text: string, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    execute(text: string, parameters?: Parameter[]): Promise<Response>;
+    executeNative(text: Native, parameters?: Parameter[]): Promise<Response>;
+    executeReaderNative(text: Native, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeStatement?(statement: IStatement, parameters?: Parameter[]): Promise<Response>;
+    executeReaderStatement?(statement: IStatement, parameters?: Parameter[]): Promise<IReader<Cells>>;
+}
+export declare const execute: (command: ICommand, statement: IStatement, parameters?: Parameter[]) => Promise<Response>;
+export declare const executeReader: (command: ICommand, statement: IStatement, parameters?: Parameter[]) => Promise<IReader<Cells>>;

package/dist/ICommandMiddleware.d.ts

@@ -0,0 +1,12 @@
+import type { Parameter } from "./Parameter.js";
+import type { Row } from "./Row.js";
+export interface ICommandMiddleware {
+    beforeCommand(text: string, params?: ReadonlyArray<Parameter>): void | {
+        text: string;
+        params?: ReadonlyArray<Parameter>;
+    } | Promise<void | {
+        text: string;
+        params?: ReadonlyArray<Parameter>;
+    }>;
+    afterCommand(text: string, params: ReadonlyArray<Parameter> | undefined, results: ReadonlyArray<Row>, elapsedMs: number, error?: Error): void | Promise<void>;
+}

package/dist/IConnection.d.ts

@@ -0,0 +1,12 @@
+import type { ICommand } from "./ICommand.js";
+import type { ITransaction } from "./ITransaction.js";
+import type { IsolationLevel } from "./IsolationLevel.js";
+export interface IConnection {
+    readonly provider: string;
+    readonly isOpen: boolean;
+    createCommand(): ICommand;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    startTransaction(isolation?: IsolationLevel): Promise<ITransaction>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/IDatasource.d.ts

@@ -0,0 +1,18 @@
+import type { Constructable } from "./converters/Constructable.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { ICommand } from "./ICommand.js";
+import type { IConnection } from "./IConnection.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+import type { RepositoryFactory } from "./RepositoryFactory.js";
+export interface IDatasource {
+    readonly provider: string;
+    readonly repositories: RepositoryFactory;
+    createConnection(): Promise<IConnection>;
+    createCommand(connection?: IConnection): Promise<ICommand>;
+    createRepository<T>(type: Constructable<T>, connection?: IConnection, options?: CRUDRepositoryOptions<T>): ICRUDRepository<T>;
+    createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
+    createReadonlyRepository<T>(type: Constructable<T>, connection?: IConnection, options?: ReadonlyRepositoryMappingOptions<T>): IReadonlyRepository<T>;
+    createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
+}

package/dist/IDatasourceFactory.d.ts

@@ -0,0 +1,5 @@
+import type { DatasourceOptions } from "./DatasourceOptions.js";
+import type { IDatasource } from "./IDatasource.js";
+export interface IDatasourceFactory {
+    create(options?: DatasourceOptions): IDatasource;
+}

package/dist/IDriver.d.ts

@@ -0,0 +1,19 @@
+import type { ICommand } from "./ICommand.js";
+import type { IConnection } from "./IConnection.js";
+import type { ITransaction } from "./ITransaction.js";
+import type { IsolationLevel } from "./IsolationLevel.js";
+import type { DatasourceOptions } from "./DatasourceOptions.js";
+import type { Cell } from "./converters/Cell.js";
+import type { TypeConverter } from "./converters/TypeConverter.js";
+import type { Information } from "./Information.js";
+import type { StatementTextRenderer } from "./statements/StatementTextRenderer.js";
+export declare const columnType: (name: string) => string;
+export interface IDriver {
+    connection(options?: DatasourceOptions): IConnection;
+    command(connection: IConnection): ICommand;
+    transaction(connection: IConnection, isolation?: IsolationLevel): ITransaction;
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    columnType(name: string): string;
+    statementRenderer?: StatementTextRenderer | null;
+    information?: Information | null;
+}