@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/ProviderCatalog.d.ts

@@ -0,0 +1,7 @@
+export declare class ProviderCatalog {
+    readonly name: string;
+    readonly location: string;
+    readonly module: string;
+    constructor(name: string, location: string, module: string);
+    static readonly default: Readonly<Record<string, ProviderCatalog>>;
+}

package/dist/ProviderCatalog.js

@@ -0,0 +1,23 @@
+export class ProviderCatalog {
+    name;
+    location;
+    module;
+    constructor(name, location, module) {
+        this.name = name;
+        this.location = location;
+        this.module = module;
+    }
+    static default = {
+        json: new ProviderCatalog("json", "@deterministic-code/datasources-json", "JsonDriver"),
+        memory: new ProviderCatalog("memory", "@deterministic-code/datasources-memory", "MemoryDriver"),
+        sqlite: new ProviderCatalog("sqlite", "@deterministic-code/datasources-sqlite", "SqliteDriver"),
+        xml: new ProviderCatalog("xml", "@deterministic-code/datasources-xml", "XmlDriver"),
+        yaml: new ProviderCatalog("yaml", "@deterministic-code/datasources-yaml", "YamlDriver"),
+        mysql: new ProviderCatalog("mysql", "@deterministic-code/datasources-mysql", "MysqlDriver"),
+        sqlserver: new ProviderCatalog("sqlserver", "@deterministic-code/datasources-sqlserver", "SqlServerDriver"),
+        postgres: new ProviderCatalog("postgres", "@deterministic-code/datasources-postgres", "PostgresDriver"),
+        oracle: new ProviderCatalog("oracle", "@deterministic-code/datasources-oracle", "OracleDriver"),
+        mongodb: new ProviderCatalog("mongodb", "@deterministic-code/datasources-mongodb", "MongoDbDriver"),
+        dynamodb: new ProviderCatalog("dynamodb", "@deterministic-code/datasources-dynamodb", "DynamoDbDriver"),
+    };
+}

package/dist/ProviderNotImplementedError.d.ts

@@ -0,0 +1,4 @@
+export declare class ProviderNotImplementedError extends Error {
+    readonly provider: string;
+    constructor(provider: string);
+}

package/dist/ProviderNotImplementedError.js

@@ -0,0 +1,8 @@
+export class ProviderNotImplementedError extends Error {
+    provider;
+    constructor(provider) {
+        super(`Provider "${provider}" is not implemented`);
+        this.name = "ProviderNotImplementedError";
+        this.provider = provider;
+    }
+}

package/dist/ProviderNotInstalledError.d.ts

@@ -0,0 +1,4 @@
+export declare class ProviderNotInstalledError extends Error {
+    readonly provider: string;
+    constructor(provider: string);
+}

package/dist/ProviderNotInstalledError.js

@@ -0,0 +1,8 @@
+export class ProviderNotInstalledError extends Error {
+    provider;
+    constructor(provider) {
+        super(`Provider "${provider}" is not installed`);
+        this.name = "ProviderNotInstalledError";
+        this.provider = provider;
+    }
+}

package/dist/ReadonlyRepository.d.ts

@@ -0,0 +1,59 @@
+import type { ICommand } from "./ICommand.js";
+import type { ICommandMiddleware } from "./ICommandMiddleware.js";
+import type { IConnection } from "./IConnection.js";
+import type { Parameter } from "./Parameter.js";
+import type { IReadonlyRepository, ReadQuery } from "./IReadonlyRepository.js";
+import type { Row } from "./Row.js";
+import type { Cell, Cells } from "./converters/Cell.js";
+import type { Constructable } from "./converters/Constructable.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+import type { BuiltRepository } from "./BuiltRepository.js";
+import type { TypeConverter } from "./converters/TypeConverter.js";
+import type { Enrichment } from "./Enrichment.js";
+import type { IEnriched } from "./IEnriched.js";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.js";
+import { StoredEnrichment } from "./StoredEnrichment.js";
+export declare const untyped: <T>() => Constructable<T>;
+export type Sourced<T> = {
+    item: T;
+    source?: Row;
+};
+export declare const enrichmentsOf: (host: object) => readonly StoredEnrichment[] | undefined;
+export declare const isBuilt: <T>(value: IConnection | BuiltRepository<T>) => value is BuiltRepository<T>;
+export declare const builtOf: <T>(typeOrConnectionOrBuilt: Constructable<T> | IConnection | BuiltRepository<T>, connectionOrOptions?: IConnection | ReadonlyRepositoryMappingOptions<T>) => BuiltRepository<T> | undefined;
+export declare class ReadonlyRepository<T> implements IReadonlyRepository<T>, IEnriched<T> {
+    readonly type: Constructable<T>;
+    private connection?;
+    protected rowConverter?: TypeConverter<Cells, Cells>;
+    protected objectConverter?: TypeConverter<T, Cells>;
+    private entityMappers;
+    private propertyMappers;
+    private statementMappers;
+    private readonlyStatements?;
+    private readonly middlewares;
+    constructor(type: Constructable<T>);
+    constructor(type: Constructable<T>, connection: IConnection);
+    constructor(connection: IConnection, options: ReadonlyRepositoryMappingOptions<T>);
+    constructor(built: BuiltRepository<T>);
+    constructor();
+    addMiddleware: (middleware: ICommandMiddleware) => this;
+    addEnriched<TRelated extends object>(enrichment: Enrichment, via: IReadonlyRepository<TRelated>, strategy?: IReadonlyEnrichmentStrategy<T & object>): this;
+    read(query?: ReadQuery, parameters?: Parameter[], options?: ReadonlyRepositoryMappingOptions<T>): AsyncIterable<T>;
+    readSingle(query?: ReadQuery, parameters?: Parameter[], options?: ReadonlyRepositoryMappingOptions<T>): Promise<T | undefined>;
+    protected get enriched(): boolean;
+    protected command: () => ICommand;
+    protected column: (property: string) => string;
+    protected cell: (property: string, value: Cell, fieldsApplied: boolean, options?: ReadonlyRepositoryMappingOptions<T>) => Cell;
+    private entries;
+    private mappers;
+    private rowConverterOf;
+    private objects;
+    private readTracked;
+    private apply;
+    private convertObject;
+    private readItems;
+    private sourced;
+    private fill;
+    private columnToPropertyName;
+    private readQuery;
+}

package/dist/ReadonlyRepository.js

@@ -0,0 +1,150 @@
+import { executeReader } from "./ICommand.js";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+import { SelectStatement } from "./statements/SelectStatement.js";
+import { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.js";
+import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
+import { IdentityMapper } from "./mappers/IdentityMapper.js";
+import { StatementMappers } from "./StatementMappers.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+import { StoredEnrichment } from "./StoredEnrichment.js";
+export const untyped = () => Object;
+const storedEnrichments = new WeakMap();
+export const enrichmentsOf = (host) => storedEnrichments.get(host);
+export const isBuilt = (value) => "statements" in value && "objectConverter" in value && "propertyMappings" in value;
+export const builtOf = (typeOrConnectionOrBuilt, connectionOrOptions) => typeof typeOrConnectionOrBuilt === "function"
+    ? connectionOrOptions === undefined
+        ? undefined
+        : new ReadonlyRepositoryBuilder().parts(connectionOrOptions, createReadonlyRepositoryMappingOptions(typeOrConnectionOrBuilt))
+    : isBuilt(typeOrConnectionOrBuilt)
+        ? typeOrConnectionOrBuilt
+        : new ReadonlyRepositoryBuilder().parts(typeOrConnectionOrBuilt, connectionOrOptions);
+export class ReadonlyRepository {
+    type;
+    connection;
+    rowConverter;
+    objectConverter;
+    entityMappers = new IdentityMapper();
+    propertyMappers = new IdentityMapper();
+    statementMappers = new StatementMappers(new IdentityMapper(), new IdentityMapper());
+    readonlyStatements;
+    middlewares = [];
+    constructor(typeOrConnectionOrBuilt, connectionOrOptions) {
+        storedEnrichments.set(this, []);
+        if (typeOrConnectionOrBuilt === undefined) {
+            this.type = untyped();
+            return;
+        }
+        const built = builtOf(typeOrConnectionOrBuilt, connectionOrOptions);
+        if (!built) {
+            this.type = typeOrConnectionOrBuilt;
+            return;
+        }
+        this.type = built.type;
+        this.connection = built.connection;
+        this.rowConverter = built.rowConverter;
+        this.objectConverter = built.objectConverter;
+        this.entityMappers = built.entityMapper;
+        this.propertyMappers = built.propertyMappings;
+        this.statementMappers = new StatementMappers(built.entityMapper, built.propertyMappings);
+        this.readonlyStatements = built.statements;
+    }
+    addMiddleware = (middleware) => {
+        this.middlewares.push(middleware);
+        return this;
+    };
+    addEnriched(enrichment, via, strategy) {
+        const chosen = strategy ?? new DefaultReadonlyEnrichmentStrategy();
+        this.entries().push(new StoredEnrichment(enrichment, (parents, sources) => chosen.apply(via, enrichment, parents, sources)));
+        return this;
+    }
+    async *read(query, parameters, options) {
+        for await (const sourced of this.readTracked(query, parameters, options))
+            yield sourced.item;
+    }
+    async readSingle(query, parameters, options) {
+        for await (const item of this.read(query, parameters, options))
+            return item;
+        return undefined;
+    }
+    get enriched() {
+        return this.entries().length > 0;
+    }
+    command = () => this.middlewares.reduce((command, middleware) => command.addMiddleware(middleware), this.connection.createCommand());
+    column = (property) => this.statementMappers.column(property);
+    cell = (property, value, fieldsApplied, options) => {
+        const objects = options?.objectConverter ?? this.objectConverter;
+        const field = objects instanceof MetaDataRowTypeConverter ? objects.fields[property] : undefined;
+        return field && !fieldsApplied ? field.reverseConvert(value) : value;
+    };
+    entries = () => storedEnrichments.get(this);
+    mappers = (options) => options?.entityMapper === undefined && options?.propertyMappings === undefined
+        ? this.statementMappers
+        : new StatementMappers(options?.entityMapper ?? this.entityMappers, options?.propertyMappings ?? this.propertyMappers);
+    rowConverterOf = (options) => options?.rowConverter ?? this.rowConverter;
+    objects = (options) => options?.objectConverter ??
+        this.objectConverter ??
+        (() => {
+            throw new DatasourceError("Object converter required");
+        })();
+    async *readTracked(query, parameters, options) {
+        const mappers = this.mappers(options);
+        const statement = mappers.apply(query instanceof ExecuteStoredProcedureStatement ? query : this.readQuery(query, mappers, options), (name, value) => this.cell(name, value, false, options));
+        const listed = parameters ??
+            (statement instanceof SelectStatement ? statement.where?.parameters : undefined);
+        yield* this.apply(this.readItems(statement, listed, mappers, this.rowConverterOf(options), this.objects(options)));
+    }
+    async *apply(pairs) {
+        if (!this.enriched) {
+            yield* pairs;
+            return;
+        }
+        yield* this.sourced(pairs);
+    }
+    convertObject = (row, objects) => objects instanceof MetaDataRowTypeConverter
+        ? objects.convert(row, this.type)
+        : objects.convert(row);
+    async *readItems(query, parameters, mappers, rows, objects) {
+        const statement = query ?? this.readonlyStatements.select();
+        const reader = await executeReader(this.command(), statement, parameters);
+        try {
+            while (await reader.next()) {
+                const renamed = this.columnToPropertyName(reader.current ??
+                    (() => {
+                        throw new DatasourceError("Reader current must be a row");
+                    })(), mappers);
+                yield {
+                    item: this.convertObject(rows ? rows.convert(renamed) : renamed, objects),
+                    source: renamed,
+                };
+            }
+        }
+        finally {
+            await reader.dispose();
+        }
+    }
+    async *sourced(pairs) {
+        const items = [];
+        const sources = [];
+        for await (const sourced of pairs) {
+            items.push(sourced.item);
+            sources.push(sourced.source);
+        }
+        await this.fill(items, sources);
+        for (let index = 0; index < items.length; index++)
+            yield { item: items[index], source: sources[index] };
+    }
+    fill = async (parents, sources) => {
+        for (const entry of this.entries())
+            await entry.apply(parents, sources);
+    };
+    columnToPropertyName = (row, mappers) => Object.fromEntries(Object.entries(row).map(([key, value]) => [mappers.property(key), value]));
+    readQuery = (query, mappers, options) => !query
+        ? this.readonlyStatements?.select()
+        : "where" in query
+            ? query
+            : this.readonlyStatements
+                ? this.readonlyStatements.select(mappers.applyWhere(query, (name, cell) => this.cell(name, cell, false, options)))
+                : new SelectStatement({ where: query });
+}

package/dist/ReadonlyRepositoryBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { IConnection } from "./IConnection.js";
+import type { BuiltRepository } from "./BuiltRepository.js";
+import type { IMapper } from "./mappers/IMapper.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+export declare class ReadonlyRepositoryBuilder<T = object> {
+    protected entityMapper: IMapper<string, string>;
+    protected propertyMapper: IMapper<string, string>;
+    parts: (connection: IConnection, options: ReadonlyRepositoryMappingOptions<T>) => BuiltRepository<T>;
+    protected ids: (_options: ReadonlyRepositoryMappingOptions<T>) => string[];
+    protected statements: (table: string, columns: string[]) => ReadonlyRepositoryStatements;
+}

package/dist/ReadonlyRepositoryBuilder.js

@@ -0,0 +1,43 @@
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+import { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.js";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+import { IdentityMapper } from "./mappers/IdentityMapper.js";
+export class ReadonlyRepositoryBuilder {
+    entityMapper = new IdentityMapper();
+    propertyMapper = new IdentityMapper();
+    parts = (connection, options) => {
+        const rowConverter = options.rowConverter;
+        const objectConverter = options.objectConverter ?? new MetaDataRowTypeConverter();
+        const entityMapper = options.entityMapper ?? new IdentityMapper();
+        const propertyMappings = options.propertyMappings ?? new IdentityMapper();
+        this.entityMapper = entityMapper;
+        this.propertyMapper = propertyMappings;
+        const entity = entityMapper.map(options.entity ?? options.type?.name ?? "");
+        const names = options.readProperties ?? (options.type ? fieldNamesOf(options.type) : []);
+        if (objectConverter instanceof MetaDataRowTypeConverter && options.type) {
+            const instance = new options.type();
+            objectConverter.references.clear();
+            objectConverter.referenceColumns = propertyMappings;
+            for (const name of names) {
+                const value = instance[name];
+                if (value !== null && typeof value === "object" && !Array.isArray(value))
+                    objectConverter.references.add(name);
+            }
+        }
+        const columns = [...names]
+            .map((name) => propertyMappings.map(name))
+            .sort((left, right) => left.localeCompare(right));
+        return {
+            connection,
+            rowConverter,
+            objectConverter,
+            propertyMappings,
+            entityMapper,
+            statements: this.statements(entity, columns),
+            ids: this.ids(options),
+            type: options.type ?? Object,
+        };
+    };
+    ids = (_options) => [];
+    statements = (table, columns) => new ReadonlyRepositoryStatements(table, columns);
+}

package/dist/ReadonlyRepositoryMappingOptions.d.ts

@@ -0,0 +1,14 @@
+import type { Cell, 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";
+export type ReadonlyRepositoryMappingOptions<T = Cells> = {
+    entity?: string;
+    entityMapper?: IMapper<string, string>;
+    propertyMappings?: IMapper<string, string>;
+    rowConverter?: TypeConverter<Cells, Cells>;
+    objectConverter?: TypeConverter<T, Cells>;
+    type?: Constructable<T>;
+    rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>;
+    readProperties?: string[];
+};

package/dist/ReadonlyRepositoryMappingOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/ReadonlyRepositoryStatements.d.ts

@@ -0,0 +1,8 @@
+import type { ISelectStatement } from "./statements/ISelectStatement.js";
+import type { IWhere } from "./statements/IWhere.js";
+export declare class ReadonlyRepositoryStatements {
+    protected readonly table: string;
+    readonly readColumns: readonly string[];
+    constructor(table: string, readColumns: readonly string[]);
+    select: (where?: IWhere) => ISelectStatement;
+}

package/dist/ReadonlyRepositoryStatements.js

@@ -0,0 +1,10 @@
+import { SelectStatement } from "./statements/SelectStatement.js";
+export class ReadonlyRepositoryStatements {
+    table;
+    readColumns;
+    constructor(table, readColumns) {
+        this.table = table;
+        this.readColumns = readColumns;
+    }
+    select = (where) => new SelectStatement({ table: this.table, fields: [...this.readColumns], where });
+}

package/dist/RepositoryAccess.d.ts

@@ -0,0 +1,11 @@
+import type { IConnection } from "./IConnection.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+export declare class RepositoryAccess {
+    private readonly createRepo;
+    private readonly createReadonlyRepo;
+    private readonly connection;
+    constructor(createRepo: (connection: IConnection) => ICRUDRepository, createReadonlyRepo: (connection: IConnection) => IReadonlyRepository, connection: IConnection);
+    create: () => ICRUDRepository;
+    createReadonly: () => IReadonlyRepository;
+}

package/dist/RepositoryAccess.js

@@ -0,0 +1,12 @@
+export class RepositoryAccess {
+    createRepo;
+    createReadonlyRepo;
+    connection;
+    constructor(createRepo, createReadonlyRepo, connection) {
+        this.createRepo = createRepo;
+        this.createReadonlyRepo = createReadonlyRepo;
+        this.connection = connection;
+    }
+    create = () => this.createRepo(this.connection);
+    createReadonly = () => this.createReadonlyRepo(this.connection);
+}

package/dist/RepositoryFactory.d.ts

@@ -0,0 +1,23 @@
+import type { Constructable } from "./converters/Constructable.js";
+import type { IConnection } from "./IConnection.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { IRepository } from "./IRepository.js";
+import type { IRepositoryFactory } from "./IRepositoryFactory.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { ICRUDRepositoryFactory } from "./ICRUDRepositoryFactory.js";
+import { RepositoryAccess } from "./RepositoryAccess.js";
+export declare class RepositoryFactory implements ICRUDRepositoryFactory {
+    #private;
+    constructor();
+    static bind: (register: (factory: RepositoryFactory) => void) => void;
+    static resetBinders: () => void;
+    private applyBound;
+    register(repository: IRepository): void;
+    register(typeName: string, pluralName: string, create: (connection: IConnection) => ICRUDRepository, createReadonly: (connection: IConnection) => IReadonlyRepository): void;
+    create<T>(type: Constructable<T>): ICRUDRepository<T>;
+    create(name: string, connection: IConnection): ICRUDRepository;
+    createReadonly: (name: string, connection: IConnection) => IReadonlyRepository;
+    access: (name: string, connection: IConnection) => RepositoryAccess;
+    has: (name: string) => boolean;
+    readonly asReadonly: IRepositoryFactory;
+}

package/dist/RepositoryFactory.js

@@ -0,0 +1,71 @@
+import { RepositoryAccess } from "./RepositoryAccess.js";
+import { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.js";
+const binders = [];
+export class RepositoryFactory {
+    #readonlyByType = new Map();
+    #crudByType = new Map();
+    #byName = new Map();
+    constructor() {
+        this.applyBound();
+    }
+    static bind = (register) => {
+        binders.push(register);
+    };
+    static resetBinders = () => {
+        binders.length = 0;
+    };
+    applyBound() {
+        for (const register of binders)
+            register(this);
+    }
+    register(repositoryOrType, pluralName, create, createReadonly) {
+        if (typeof repositoryOrType !== "string") {
+            this.#put(repositoryOrType, true);
+            return;
+        }
+        const named = { create: create, createReadonly: createReadonly };
+        this.#byName.set(repositoryOrType, named);
+        this.#byName.set(pluralName, named);
+    }
+    create(typeOrName, connection) {
+        if (typeof typeOrName !== "string")
+            return this.#get(this.#crudByType, typeOrName);
+        this.applyBound();
+        return this.#lookup(typeOrName).create(connection);
+    }
+    createReadonly = (name, connection) => {
+        this.applyBound();
+        return this.#lookup(name).createReadonly(connection);
+    };
+    access = (name, connection) => {
+        this.applyBound();
+        const named = this.#lookup(name);
+        return new RepositoryAccess(named.create, named.createReadonly, connection);
+    };
+    has = (name) => {
+        this.applyBound();
+        return this.#byName.has(name);
+    };
+    asReadonly = {
+        register: (repository) => this.#put(repository, false),
+        create: (type) => this.#get(this.#readonlyByType, type),
+    };
+    #put = (repository, crud) => {
+        this.#readonlyByType.set(repository.type, repository);
+        if (!crud)
+            return;
+        this.#crudByType.set(repository.type, repository);
+    };
+    #get = (map, type) => {
+        const repository = map.get(type);
+        if (!repository)
+            throw new RepositoryNotRegisteredError(type.name);
+        return repository;
+    };
+    #lookup = (name) => {
+        const named = this.#byName.get(name);
+        if (!named)
+            throw new RepositoryNotRegisteredError(name);
+        return named;
+    };
+}

package/dist/RepositoryNotRegisteredError.d.ts

@@ -0,0 +1,4 @@
+export declare class RepositoryNotRegisteredError extends Error {
+    readonly entityTypeName: string;
+    constructor(entityTypeName: string);
+}

package/dist/RepositoryNotRegisteredError.js

@@ -0,0 +1,8 @@
+export class RepositoryNotRegisteredError extends Error {
+    entityTypeName;
+    constructor(entityTypeName) {
+        super(`Repository "${entityTypeName}" is not registered`);
+        this.name = "RepositoryNotRegisteredError";
+        this.entityTypeName = entityTypeName;
+    }
+}

package/dist/RepositoryTree.d.ts

@@ -0,0 +1,6 @@
+import type { IRepositoryTree } from "./IRepositoryTree.js";
+import type { IRepositoryTreeNode } from "./IRepositoryTreeNode.js";
+export declare class RepositoryTree implements IRepositoryTree {
+    readonly parent: IRepositoryTreeNode;
+    constructor(parent: IRepositoryTreeNode);
+}

package/dist/RepositoryTree.js

@@ -0,0 +1,6 @@
+export class RepositoryTree {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+}

package/dist/RepositoryTreeNode.d.ts

@@ -0,0 +1,9 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { IRepositoryTreeNode } from "./IRepositoryTreeNode.js";
+export declare class RepositoryTreeNode implements IRepositoryTreeNode {
+    readonly value: object;
+    readonly propertyName: string;
+    readonly parent?: IRepositoryTreeNode | undefined;
+    readonly enrichment?: Enrichment | undefined;
+    constructor(value: object, propertyName: string, parent?: IRepositoryTreeNode | undefined, enrichment?: Enrichment | undefined);
+}

package/dist/RepositoryTreeNode.js

@@ -0,0 +1,12 @@
+export class RepositoryTreeNode {
+    value;
+    propertyName;
+    parent;
+    enrichment;
+    constructor(value, propertyName, parent, enrichment) {
+        this.value = value;
+        this.propertyName = propertyName;
+        this.parent = parent;
+        this.enrichment = enrichment;
+    }
+}

package/dist/Response.d.ts

@@ -0,0 +1,7 @@
+import type { Parameter } from "./Parameter.js";
+export declare class Response {
+    readonly result: unknown;
+    readonly rowsAffected: number;
+    readonly parameters?: Parameter[];
+    constructor(result: unknown, rowsAffected: number, parameters?: Parameter[]);
+}

package/dist/Response.js

@@ -0,0 +1,13 @@
+import { ParameterDirection } from "./ParameterDirection.js";
+export class Response {
+    result;
+    rowsAffected;
+    parameters;
+    constructor(result, rowsAffected, parameters) {
+        const returned = parameters?.find((parameter) => parameter.direction === ParameterDirection.ReturnValue)?.value;
+        this.result = result == null && returned != null ? returned : result;
+        this.rowsAffected = rowsAffected;
+        if (parameters !== undefined)
+            this.parameters = parameters;
+    }
+}

package/dist/Row.d.ts

@@ -0,0 +1,2 @@
+import type { Cell } from "./converters/Cell.js";
+export type Row = Record<string, Cell>;

package/dist/Row.js

@@ -0,0 +1 @@
+export {};

package/dist/SingleCommandIBulkWriteStrategy.d.ts

@@ -0,0 +1,11 @@
+import type { CRUDRepository } from "./CRUDRepository.js";
+import type { Response } from "./Response.js";
+import type { IWhere } from "./statements/IWhere.js";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.js";
+export declare class SingleCommandIBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
+    repo: CRUDRepository<T>;
+    attach: () => void;
+    create: (items: T[]) => Promise<Response>;
+    update: (items: T[], byWhere: IWhere | undefined) => Promise<Response>;
+    delete: (items: T[], byWhere: IWhere | undefined) => Promise<Response>;
+}

package/dist/SingleCommandIBulkWriteStrategy.js

@@ -0,0 +1,21 @@
+const fold = async (items, write) => {
+    let result = null;
+    let rowsAffected = 0;
+    for (const item of items) {
+        const response = await write(item);
+        result = response.result;
+        rowsAffected += response.rowsAffected;
+    }
+    return { result, rowsAffected };
+};
+export class SingleCommandIBulkWriteStrategy {
+    repo;
+    attach = () => { };
+    create = async (items) => {
+        for (const item of items)
+            await this.repo.create(item);
+        return { result: null, rowsAffected: items.length };
+    };
+    update = (items, byWhere) => fold(items, (item) => this.repo.update(item, byWhere));
+    delete = (items, byWhere) => fold(items, (item) => this.repo.delete(item, byWhere));
+}

package/dist/StatementMappers.d.ts

@@ -0,0 +1,16 @@
+import type { Cell } from "./converters/Cell.js";
+import type { IMapper } from "./mappers/IMapper.js";
+import type { IStatement } from "./statements/IStatement.js";
+import type { IWhere } from "./statements/IWhere.js";
+export declare class StatementMappers implements IMapper<string, string> {
+    private readonly entityMappers;
+    private readonly propertyMappers;
+    constructor(entityMappers: IMapper<string, string>, propertyMappers: IMapper<string, string>);
+    map: (property: string) => string;
+    reverseMap: (key: string) => string;
+    column: (property: string) => string;
+    property: (key: string) => string;
+    apply: (query: IStatement | undefined, cell: (property: string, value: Cell) => Cell) => IStatement | undefined;
+    applyWhere: (where: IWhere | undefined, cell: (property: string, value: Cell) => Cell) => IWhere | undefined;
+    private mapSelectField;
+}