@deterministic-code/datasources 0.0.0-stage → 0.1.1

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/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/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/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/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/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/IRepositoryTree.d.ts

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

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/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/IUnitOfWork.d.ts

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

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/Information.d.ts

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

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/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/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/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/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/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/ProviderNotImplementedError.d.ts

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

package/dist/ProviderNotInstalledError.d.ts

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

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/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/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/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/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/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/RepositoryNotRegisteredError.d.ts

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

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/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/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/Row.d.ts

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

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/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;
+}

package/dist/StoredEnrichment.d.ts

@@ -0,0 +1,11 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { Row } from "./Row.js";
+export type ApplyEnrichment<T extends object = object> = (parents: T[], sources?: (Row | undefined)[]) => Promise<void>;
+export declare class StoredEnrichment<T extends object = object> {
+    readonly enrichment: Enrichment;
+    apply: ApplyEnrichment<T>;
+    persist?: ICRUDRepository<object>;
+    link?: ICRUDRepository<object>;
+    constructor(enrichment: Enrichment, apply: ApplyEnrichment<T>, persist?: ICRUDRepository<object>, link?: ICRUDRepository<object>);
+}

package/dist/StoredProcedureBulkWriteStrategy.d.ts

@@ -0,0 +1,27 @@
+import type { Response } from "./Response.js";
+import type { IWhere } from "./statements/IWhere.js";
+import type { CRUDRepository } from "./CRUDRepository.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { ICommand } from "./ICommand.js";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.js";
+export declare class StoredProcedureBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
+    private readonly createName;
+    private readonly updateName;
+    private readonly deleteName;
+    repo: CRUDRepository<T>;
+    command: ICommand;
+    options: CRUDRepositoryOptions<T>;
+    attach: (command: ICommand, options: CRUDRepositoryOptions<T>) => void;
+    constructor(createName: string, updateName: string, deleteName: string);
+    create: (items: T[]) => Promise<Response>;
+    update: (items: T[], _byWhere: IWhere | undefined) => Promise<Response>;
+    delete: (items: T[], _byWhere: IWhere | undefined) => Promise<Response>;
+    private then;
+    private call;
+    private ids;
+    private rowOf;
+    private identity;
+    private applyIds;
+    private column;
+    private reverse;
+}

package/dist/StreamingReader.d.ts

@@ -0,0 +1,16 @@
+import type { Cells } from "./converters/Cell.js";
+import type { IReader } from "./IReader.js";
+export declare class StreamingReader implements IReader<Cells> {
+    private readonly pull;
+    private readonly advance;
+    private readonly close;
+    current: Cells | undefined;
+    private closed;
+    constructor(pull: () => Promise<Cells | undefined>, advance: () => Promise<boolean>, close?: () => Promise<void>);
+    next(): Promise<boolean>;
+    read(): AsyncIterable<Cells>;
+    nextResult(): Promise<boolean>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}
+export declare const statementReader: (statements: readonly string[], load: (sql: string) => AsyncIterable<Cells>) => StreamingReader;

package/dist/UnitOfWorkTransaction.d.ts

@@ -0,0 +1,12 @@
+import type { IConnection } from "./IConnection.js";
+import type { IUnitOfWork } from "./IUnitOfWork.js";
+export declare class UnitOfWorkTransaction implements IUnitOfWork {
+    private readonly connection;
+    private begun;
+    private transaction;
+    constructor(connection: IConnection);
+    begin: () => Promise<void>;
+    commit: () => Promise<void>;
+    abort: () => Promise<void>;
+    private release;
+}

package/dist/UpdateEnrichmentStrategy.d.ts

@@ -0,0 +1,18 @@
+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 UpdateEnrichmentStrategy<T> {
+    abstract updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    abstract updateLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    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 hasKey: <TItem extends object>(item: TItem, keys: readonly string[]) => boolean;
+    protected keyOf: <TItem extends object>(item: TItem, keys: readonly string[]) => string;
+    protected namesOf: <TChild extends object>(writer: ICRUDRepository<TChild>, item: TChild) => readonly string[];
+    protected linkWhere: (association: NonNullable<Enrichment["association"]>, parentKey: Scalar, relatedKey: Scalar) => Where;
+    protected relatedIds: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar[];
+    protected requiredKey: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar;
+}

package/dist/WriteMode.d.ts

@@ -0,0 +1 @@
+export type WriteMode = "create" | "update" | "delete";

package/dist/builders/Field.d.ts

@@ -0,0 +1,5 @@
+import type { Scalar } from "./Scalar.js";
+export interface Field {
+    name: string;
+    value: Scalar;
+}

package/dist/builders/Scalar.d.ts

@@ -0,0 +1 @@
+export type Scalar = string | number | boolean | bigint | null;

package/dist/builders/index.d.ts

@@ -0,0 +1,2 @@
+export type { Field } from "./Field.js";
+export type { Scalar } from "./Scalar.js";

package/dist/collectAsync.d.ts

@@ -0,0 +1 @@
+export declare function collectAsync<T>(items: AsyncIterable<T>): Promise<T[]>;

package/dist/converters/Cell.d.ts

@@ -0,0 +1,2 @@
+export type Cell = string | number | boolean | bigint | Date | Uint8Array | null;
+export type Cells = Record<string, Cell>;

package/dist/converters/ChangeCasingConverter.d.ts

@@ -0,0 +1,7 @@
+export type Casing = "camelCase" | "capitalCase" | "constantCase" | "dotCase" | "kebabCase" | "noCase" | "pascalCase" | "pascalSnakeCase" | "pathCase" | "sentenceCase" | "snakeCase" | "trainCase";
+export declare class ChangeCasingConverter {
+    private readonly casing;
+    constructor(casing: Casing);
+    convert: (from: string) => string;
+    reverseConvert: (to: string) => string;
+}

package/dist/converters/Constructable.d.ts

@@ -0,0 +1 @@
+export type Constructable<T> = new () => T;

package/dist/converters/MetaDataRowTypeConverter.d.ts

@@ -0,0 +1,14 @@
+import type { Cell, Cells } from "./Cell.js";
+import { TypeConverter } from "./TypeConverter.js";
+import type { Constructable } from "./Constructable.js";
+import type { IMapper } from "../mappers/IMapper.js";
+export declare class MetaDataRowTypeConverter<T = Cells> extends TypeConverter<T, Cells> {
+    fields: Record<string, TypeConverter<Cell, Cell>>;
+    references: Set<string>;
+    referenceColumns: IMapper<string, string>;
+    shouldCoerceId: boolean;
+    constructor(fields?: Record<string, TypeConverter<Cell, Cell>>);
+    convert: (row: Cells, type?: Constructable<T>) => T;
+    reverseConvert: (row: T) => Cells;
+    private converted;
+}

package/dist/converters/PluralizerConverter.d.ts

@@ -0,0 +1,4 @@
+export declare class PluralizerConverter {
+    convert: (from: string) => string;
+    reverseConvert: (to: string) => string;
+}

package/dist/converters/RegexConverter.d.ts

@@ -0,0 +1,7 @@
+export declare class RegexConverter {
+    readonly regex: RegExp;
+    readonly replacement: string;
+    constructor(pattern: string | RegExp, replacement: string);
+    convert: (from: string) => string;
+    reverseConvert: (to: string) => string;
+}

package/dist/converters/ReplaceConverter.d.ts

@@ -0,0 +1,7 @@
+export declare class ReplaceConverter {
+    readonly search: string;
+    readonly replacement: string;
+    constructor(search: string, replacement: string);
+    convert: (from: string) => string;
+    reverseConvert: (to: string) => string;
+}

package/dist/converters/RowTypeConverter.d.ts

@@ -0,0 +1,10 @@
+import type { Cell, Cells } from "./Cell.js";
+import { TypeConverter } from "./TypeConverter.js";
+export declare class RowTypeConverter extends TypeConverter<Cells, Cells> {
+    readonly fields: Record<string, TypeConverter<Cell, Cell>>;
+    constructor(fields: Record<string, TypeConverter<Cell, Cell>>);
+    static from(converters: Record<string, TypeConverter<Cell, Cell>>, columns: Record<string, string>): RowTypeConverter;
+    convert: (from: Cells) => Cells;
+    reverseConvert: (to: Cells) => Cells;
+    private apply;
+}

package/dist/converters/ToLowerCaseConverter.d.ts

@@ -0,0 +1,4 @@
+export declare class ToLowerCaseConverter {
+    convert: (from: string) => string;
+    reverseConvert: (to: string) => string;
+}

package/dist/converters/ToUpperCaseConverter.d.ts

@@ -0,0 +1,4 @@
+export declare class ToUpperCaseConverter {
+    convert: (from: string) => string;
+    reverseConvert: (to: string) => string;
+}

package/dist/converters/TypeConverter.d.ts

@@ -0,0 +1,5 @@
+import type { Cells } from "./Cell.js";
+export declare abstract class TypeConverter<To = Cells, From = Cells> {
+    abstract convert(from: From): To;
+    abstract reverseConvert(to: To): From;
+}

package/dist/createCRUDRepositoryOptions.d.ts

@@ -0,0 +1,7 @@
+import type { Cell } from "./converters/Cell.js";
+import type { Constructable } from "./converters/Constructable.js";
+import type { TypeConverter } from "./converters/TypeConverter.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+export { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.js";
+export declare const defaultId: (fields: string[]) => string[];
+export declare const createCRUDRepositoryOptions: <T>(type: Constructable<T>, rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>) => CRUDRepositoryOptions<T>;

package/dist/createReadonlyRepositoryMappingOptions.d.ts

@@ -0,0 +1,6 @@
+import type { Cell } from "./converters/Cell.js";
+import type { Constructable } from "./converters/Constructable.js";
+import type { TypeConverter } from "./converters/TypeConverter.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+export declare const fieldNamesOf: <T>(type: Constructable<T>) => string[];
+export declare const createReadonlyRepositoryMappingOptions: <T>(type: Constructable<T>, rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>) => ReadonlyRepositoryMappingOptions<T>;

package/dist/dotEnv.d.ts

@@ -0,0 +1,5 @@
+import type { DatasourceOptions } from "./DatasourceOptions.js";
+export declare const DotEnv: {
+    parse: (text: string) => DatasourceOptions;
+    load: (path?: string) => DatasourceOptions;
+};