@deterministic-code/datasources 0.1.0 → 0.1.2

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/Enrichment.js

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

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/EnrichmentPropertyType.js

@@ -0,0 +1,6 @@
+export const EnrichmentPropertyType = {
+    Object: "object",
+    List: "list",
+    Dictionary: "dictionary",
+    Custom: "custom",
+};

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/ExpectConsoleMiddleware.js

@@ -0,0 +1,30 @@
+import { ConsoleCommandMiddleware } from "./ConsoleCommandMiddleware.js";
+export const consoleSignature = (line) => {
+    const duration = line.lastIndexOf("] ");
+    return duration >= 0 && (line.endsWith("ms") || line.endsWith("μs"))
+        ? line.slice(0, duration + 1)
+        : line;
+};
+export class ExpectConsoleMiddleware {
+    expected;
+    normalize;
+    inner;
+    index = 0;
+    constructor(expected, now, normalize = consoleSignature) {
+        this.expected = expected;
+        this.normalize = normalize;
+        this.inner = new ConsoleCommandMiddleware((line) => this.check(line), now, { isVerbose: "true" });
+    }
+    beforeCommand = (text, params) => this.inner.beforeCommand(text, params);
+    afterCommand = (text, params, results, elapsedMs, error) => this.inner.afterCommand(text, params, results, elapsedMs, error);
+    complete = () => {
+        if (this.index !== this.expected.length)
+            throw new Error(`console mismatch at ${this.index}\nexpected: ${this.expected[this.index]}\nactual:   <missing>`);
+    };
+    check = (line) => {
+        const actual = this.normalize(line);
+        if (this.index >= this.expected.length || actual !== this.expected[this.index])
+            throw new Error(`console mismatch at ${this.index}\nexpected: ${this.index < this.expected.length ? this.expected[this.index] : "<missing>"}\nactual:   ${actual}`);
+        this.index++;
+    };
+}

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/FirstResultReader.js

@@ -0,0 +1,43 @@
+import { readerToAsyncIterable } from "./readerToAsyncIterable.js";
+export class FirstResultReader {
+    first;
+    live;
+    current = undefined;
+    index = -1;
+    firstSet = true;
+    constructor(first, live) {
+        this.first = first;
+        this.live = live;
+    }
+    static async capture(live) {
+        const rows = [];
+        while (await live.next())
+            if (live.current != null)
+                rows.push(live.current);
+        return { value: new FirstResultReader(rows, live), rows };
+    }
+    async next() {
+        if (!this.firstSet) {
+            const moved = await this.live.next();
+            this.current = this.live.current;
+            return moved;
+        }
+        this.index += 1;
+        if (this.index < this.first.length) {
+            this.current = this.first[this.index];
+            return true;
+        }
+        this.current = undefined;
+        return false;
+    }
+    async nextResult() {
+        this.firstSet = false;
+        this.current = undefined;
+        return this.live.nextResult();
+    }
+    read() {
+        return readerToAsyncIterable(this);
+    }
+    dispose = () => this.live.dispose();
+    [Symbol.asyncDispose] = () => this.dispose();
+}

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/HashsetOptimizedReadonlyEnrichmentStrategy.js

@@ -0,0 +1,58 @@
+import { Operator, Where } from "./statements/index.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+const hasKey = (value) => value !== undefined && value !== null;
+export class HashsetOptimizedReadonlyEnrichmentStrategy extends DefaultReadonlyEnrichmentStrategy {
+    async applyObject(via, enrichment, parents, sources) {
+        const keys = this.keysOf(parents, sources, enrichment.sourceProperty);
+        if (keys.size === 0)
+            return;
+        const index = new Map();
+        for await (const item of via.read(new Where(new Operator.In(enrichment.relatedKey, [...keys.values()])))) {
+            const by = this.props(item)[enrichment.relatedKey];
+            if (hasKey(by))
+                index.set(this.keyOf(by), item);
+        }
+        for (const [indexOfParent, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, enrichment.sourceProperty, sources, indexOfParent);
+            if (key === undefined || key === null)
+                continue;
+            const related = index.get(this.keyOf(key));
+            if (!related)
+                continue;
+            Object.assign(parent, {
+                [enrichment.destinationProperty]: enrichment.relatedProperty ? this.props(related)[enrichment.relatedProperty] : related,
+            });
+        }
+    }
+    async applyList(via, enrichment, parents, sources) {
+        const keys = this.keysOf(parents, sources, enrichment.sourceProperty);
+        if (keys.size === 0)
+            return;
+        const index = new Map();
+        for await (const item of via.read(new Where(new Operator.In(enrichment.relatedKey, [...keys.values()])))) {
+            const by = this.props(item)[enrichment.relatedKey];
+            if (hasKey(by)) {
+                const cacheKey = this.keyOf(by);
+                const list = index.get(cacheKey) ?? [];
+                list.push(item);
+                index.set(cacheKey, list);
+            }
+        }
+        for (const [indexOfParent, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, enrichment.sourceProperty, sources, indexOfParent);
+            if (key === undefined || key === null)
+                continue;
+            Object.assign(parent, { [enrichment.destinationProperty]: index.get(this.keyOf(key)) ?? [] });
+        }
+    }
+    keysOf(parents, sources, from) {
+        const keys = new Map();
+        for (const [index, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, from, sources, index);
+            if (key === undefined || key === null)
+                continue;
+            keys.set(this.keyOf(key), this.scalar(key));
+        }
+        return keys;
+    }
+}

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/IBulkWriteStrategy.js

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

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/ICRUDRepository.js

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

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/ICRUDRepositoryFactory.js

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

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/ICommand.js

@@ -0,0 +1,6 @@
+import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.js";
+import { Native } from "./statements/Native.js";
+export const execute = (command, statement, parameters) => command.executeStatement?.(statement, parameters) ??
+    command.executeNative(new Native(DefaultStatementTextRenderer.instance.render(statement)), parameters);
+export const executeReader = (command, statement, parameters) => command.executeReaderStatement?.(statement, parameters) ??
+    command.executeReaderNative(new Native(DefaultStatementTextRenderer.instance.render(statement)), parameters);

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/ICommandMiddleware.js

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

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/IConnection.js

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

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/IDatasource.js

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

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/IDatasourceFactory.js

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

package/dist/IDriver.d.ts

@@ -0,0 +1,23 @@
+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 { DefaultValueConverter } from "./converters/DefaultValueConverter.js";
+import type { IMapping } from "./converters/IMapping.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;
+    typeConverter?: IMapping<string, string> | null;
+    defaultValueConverter?: DefaultValueConverter | null;
+    statementRenderer?: StatementTextRenderer | null;
+    information?: Information | null;
+}

package/dist/IDriver.js

@@ -0,0 +1 @@
+export const columnType = (name) => name;

package/dist/IEnriched.d.ts

@@ -0,0 +1,6 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+export interface IEnriched<T> {
+    addEnriched<TRelated extends object>(enrichment: Enrichment, via: IReadonlyRepository<TRelated>, strategy?: IReadonlyEnrichmentStrategy<T & object>): this;
+}

package/dist/IEnriched.js

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

package/dist/IReader.d.ts

@@ -0,0 +1,8 @@
+export interface IReader<T = unknown> {
+    readonly current: T | undefined;
+    next(): Promise<boolean>;
+    nextResult(): Promise<boolean>;
+    read(): AsyncIterable<T>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/IReader.js

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

package/dist/IReadonlyEnrichmentStrategy.d.ts

@@ -0,0 +1,7 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { Row } from "./Row.js";
+export interface IReadonlyEnrichmentStrategy<T extends object> {
+    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>;
+}

package/dist/IReadonlyEnrichmentStrategy.js

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

package/dist/IReadonlyRepository.d.ts

@@ -0,0 +1,11 @@
+import type { Parameter } from "./Parameter.js";
+import type { IExecuteStoredProcedureStatement } from "./statements/IExecuteStoredProcedureStatement.js";
+import type { ISelectStatement } from "./statements/ISelectStatement.js";
+import type { IRepository } from "./IRepository.js";
+import type { IWhere } from "./statements/IWhere.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+export type ReadQuery = ISelectStatement | IWhere | IExecuteStoredProcedureStatement;
+export interface IReadonlyRepository<T = unknown> extends IRepository<T> {
+    readSingle(query?: ReadQuery, parameters?: Parameter[], options?: ReadonlyRepositoryMappingOptions<T>): Promise<T | undefined>;
+    read(query?: ReadQuery, parameters?: Parameter[], options?: ReadonlyRepositoryMappingOptions<T>): AsyncIterable<T>;
+}

package/dist/IReadonlyRepository.js

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

package/dist/IRepository.d.ts

@@ -0,0 +1,4 @@
+import type { Constructable } from "./converters/Constructable.js";
+export interface IRepository<T = unknown> {
+    readonly type: Constructable<T>;
+}

package/dist/IRepository.js

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

package/dist/IRepositoryFactory.d.ts

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

package/dist/IRepositoryFactory.js

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

package/{src/IRepositoryTree.ts → dist/IRepositoryTree.d.ts}

@@ -1,5 +1,4 @@
-import type { IRepositoryTreeNode } from "./IRepositoryTreeNode.ts";
-
+import type { IRepositoryTreeNode } from "./IRepositoryTreeNode.js";
 export interface IRepositoryTree {
-  readonly parent: IRepositoryTreeNode;
+    readonly parent: IRepositoryTreeNode;
 }

package/dist/IRepositoryTree.js

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

package/dist/IRepositoryTreeNode.d.ts

@@ -0,0 +1,7 @@
+import type { Enrichment } from "./Enrichment.js";
+export interface IRepositoryTreeNode {
+    readonly value: object;
+    readonly propertyName: string;
+    readonly parent?: IRepositoryTreeNode;
+    readonly enrichment?: Enrichment;
+}

package/dist/IRepositoryTreeNode.js

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

package/dist/ITransaction.d.ts

@@ -0,0 +1,8 @@
+import type { IConnection } from "./IConnection.js";
+import type { IsolationLevel } from "./IsolationLevel.js";
+export interface ITransaction {
+    readonly connection: IConnection;
+    readonly isolation: IsolationLevel;
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}

package/dist/ITransaction.js

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

package/dist/IUnitOfWork.d.ts

@@ -0,0 +1,5 @@
+export interface IUnitOfWork {
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}

package/dist/IUnitOfWork.js

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

package/dist/IWriteEnrichmentStrategy.d.ts

@@ -0,0 +1,7 @@
+import type { IRepositoryTree } from "./IRepositoryTree.js";
+import type { WriteMode } from "./WriteMode.js";
+export interface IWriteEnrichmentStrategy<T> {
+    readonly useTransaction: boolean;
+    persist(tree: IRepositoryTree, items: T[], mode: WriteMode): Promise<void>;
+    persistBulk?(tree: IRepositoryTree, items: T[], mode: WriteMode): Promise<void>;
+}

package/dist/IWriteEnrichmentStrategy.js

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

package/dist/Information.d.ts

@@ -0,0 +1,5 @@
+export type Information = {
+    descriptions: readonly string[];
+    overrides: readonly string[];
+    changeLogs: readonly string[];
+};

package/dist/Information.js

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

package/dist/IsolationLevel.d.ts

@@ -0,0 +1,7 @@
+export declare const IsolationLevel: {
+    readonly ReadUncommitted: "readUncommitted";
+    readonly ReadCommitted: "readCommitted";
+    readonly RepeatableRead: "repeatableRead";
+    readonly Serializable: "serializable";
+};
+export type IsolationLevel = (typeof IsolationLevel)[keyof typeof IsolationLevel];

package/dist/IsolationLevel.js

@@ -0,0 +1,6 @@
+export const IsolationLevel = {
+    ReadUncommitted: "readUncommitted",
+    ReadCommitted: "readCommitted",
+    RepeatableRead: "repeatableRead",
+    Serializable: "serializable",
+};

package/dist/LazyWriteEnrichmentStrategy.d.ts

@@ -0,0 +1,4 @@
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.js";
+export declare class LazyWriteEnrichmentStrategy<T> extends DefaultWriteEnrichmentStrategy<T> {
+    protected skipUnloaded: boolean;
+}

package/dist/LazyWriteEnrichmentStrategy.js

@@ -0,0 +1,4 @@
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.js";
+export class LazyWriteEnrichmentStrategy extends DefaultWriteEnrichmentStrategy {
+    skipUnloaded = true;
+}

package/dist/NestedToObjectEnrichmentStrategy.d.ts

@@ -0,0 +1,10 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { TypeMap } from "./mappers/TypeMap.js";
+import type { Row } from "./Row.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+export declare class NestedToObjectEnrichmentStrategy<T extends object> extends DefaultReadonlyEnrichmentStrategy<T> {
+    private readonly nested;
+    constructor(typeMap: TypeMap<T>);
+    apply<TRelated extends object>(_via: IReadonlyRepository<TRelated>, _enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+}

package/dist/NestedToObjectEnrichmentStrategy.js

@@ -0,0 +1,20 @@
+import { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+export class NestedToObjectEnrichmentStrategy extends DefaultReadonlyEnrichmentStrategy {
+    nested;
+    constructor(typeMap) {
+        super();
+        this.nested = new FlatToNestedMapper(typeMap);
+    }
+    apply(_via, _enrichment, parents, sources) {
+        parents.length = 0;
+        for (const item of this.nested.map(rows(sources)))
+            parents.push(item);
+        return Promise.resolve();
+    }
+}
+function* rows(sources) {
+    for (const source of sources ?? [])
+        if (source)
+            yield source;
+}

package/dist/Parameter.d.ts

@@ -0,0 +1,7 @@
+import type { Scalar } from "./builders/Scalar.js";
+import type { ParameterDirection } from "./ParameterDirection.js";
+export interface Parameter<T = Scalar> {
+    name: string;
+    value?: T;
+    direction?: ParameterDirection;
+}

package/dist/Parameter.js

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

package/dist/ParameterDirection.d.ts

@@ -0,0 +1,7 @@
+export declare const ParameterDirection: {
+    readonly Input: "input";
+    readonly Output: "output";
+    readonly InputOutput: "inputOutput";
+    readonly ReturnValue: "returnValue";
+};
+export type ParameterDirection = (typeof ParameterDirection)[keyof typeof ParameterDirection];

package/dist/ParameterDirection.js

@@ -0,0 +1,6 @@
+export const ParameterDirection = {
+    Input: "input",
+    Output: "output",
+    InputOutput: "inputOutput",
+    ReturnValue: "returnValue",
+};