@deterministic-code/datasources 0.1.0 → 0.1.2

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

@@ -0,0 +1,27 @@
+import { readerToAsyncIterable } from "./readerToAsyncIterable.js";
+export class ArrayReader {
+    rows;
+    index = -1;
+    current = undefined;
+    constructor(rows) {
+        this.rows = rows;
+    }
+    async next() {
+        this.index += 1;
+        if (this.index < this.rows.length) {
+            this.current = this.rows[this.index];
+            return true;
+        }
+        this.current = undefined;
+        return false;
+    }
+    read() {
+        return readerToAsyncIterable(this);
+    }
+    async nextResult() {
+        this.current = undefined;
+        return false;
+    }
+    async dispose() { }
+    [Symbol.asyncDispose] = () => this.dispose();
+}

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

@@ -0,0 +1,150 @@
+import { Native } from "./statements/Native.js";
+import { execute } from "./ICommand.js";
+import { BulkDeleteStatement, BulkInsertStatement, BulkUpdateStatement, DefaultStatementTextRenderer, Literal, Operator, Where, } from "./statements/index.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { repositoryParts } from "./CRUDRepositoryBuilder.js";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+import { afterBulkWrite } from "./BulkWriteEnrichment.js";
+const empty = () => ({ result: null, rowsAffected: 0 });
+const budget = 8000;
+const maxRows = 250;
+const assigned = (value) => value !== null && value !== "" && value !== 0 && value !== 0n;
+const columnsOf = (rows) => {
+    const seen = new Set();
+    const columns = [];
+    for (const row of rows)
+        for (const field of row)
+            if (!seen.has(field.name)) {
+                seen.add(field.name);
+                columns.push(field.name);
+            }
+    return columns;
+};
+export class BatchCommandIBulkWriteStrategy {
+    repo;
+    command;
+    options;
+    cached;
+    attach = (command, options) => {
+        this.command = command;
+        this.options = options;
+    };
+    create = (items) => this.then(this.writeCreates(items), items, "create");
+    update = (items, byWhere) => this.then(byWhere ? this.sendEach(items.map((item) => this.updateCommand(item, byWhere))) : this.writeUpdates(items), items, "update");
+    delete = (items, byWhere) => this.then(byWhere ? this.sendEach(items.map((item) => this.deleteCommand(item, byWhere))) : this.writeDeletes(items), items, "delete");
+    then = async (write, items, mode) => {
+        const response = await write;
+        await afterBulkWrite(this.repo, this.options, items, mode);
+        return response;
+    };
+    writeCreates = async (items) => {
+        if (items.length === 0)
+            return empty();
+        const rows = items.map(this.mappedInsert);
+        const columns = columnsOf(rows.map((row) => row.fields));
+        return this.chunked(rows, columns.length, (chunk) => {
+            const statement = new BulkInsertStatement(rows[0].table, columns, chunk.map((row) => row.fields));
+            return execute(this.command, statement, statement.parameters);
+        });
+    };
+    writeUpdates = async (items) => {
+        if (items.length === 0)
+            return empty();
+        const rows = items.map(this.mappedUpdate);
+        const set = columnsOf(rows.map((row) => row.fields));
+        const ids = columnsOf(rows.map((row) => row.ids));
+        return this.chunked(rows, set.length + ids.length, (chunk) => {
+            const statement = new BulkUpdateStatement(rows[0].table, set, ids, chunk);
+            return execute(this.command, statement, statement.parameters);
+        });
+    };
+    writeDeletes = async (items) => {
+        if (items.length === 0)
+            return empty();
+        const rows = items.map(this.mappedDelete);
+        const ids = columnsOf(rows.map((row) => row.ids));
+        return this.chunked(rows, ids.length, (chunk) => {
+            const statement = new BulkDeleteStatement(rows[0].table, ids, chunk.map((row) => row.ids));
+            return execute(this.command, statement, statement.parameters);
+        });
+    };
+    chunked = async (rows, width, write) => {
+        const size = Math.min(maxRows, Math.max(1, Math.floor(budget / Math.max(1, width))));
+        let rowsAffected = 0;
+        for (let at = 0; at < rows.length; at += size)
+            rowsAffected += (await write(rows.slice(at, at + size))).rowsAffected;
+        return { result: null, rowsAffected };
+    };
+    sendEach = async (commands) => {
+        let rowsAffected = 0;
+        for (const command of commands)
+            rowsAffected += (await this.command.executeNative(new Native(command.text), command.parameters)).rowsAffected;
+        return { result: null, rowsAffected };
+    };
+    mappedInsert = (item) => {
+        const record = this.reverse(item);
+        const statement = this.statements().insert(this.fields(record, (col) => !this.ids.includes(col) || assigned(record[col] ?? null)));
+        return { table: statement.table, fields: statement.fields };
+    };
+    mappedUpdate = (item) => {
+        const record = this.reverse(item);
+        const fields = this.fields(record, (col) => !this.ids.includes(col));
+        if (fields.length === 0)
+            throw new DatasourceError("Update requires at least one non-Id field");
+        const statement = this.statements().update(fields, this.idsWhere(record), (name, value) => this.cell(name, value, true));
+        return { table: statement.table, fields: statement.fields, ids: statement.where?.parameters ?? [] };
+    };
+    mappedDelete = (item) => {
+        const record = this.reverse(item);
+        const statement = this.statements().delete(this.idsWhere(record), (name, value) => this.cell(name, value, true));
+        return { table: statement.table, ids: statement.where?.parameters ?? [] };
+    };
+    updateCommand = (item, byWhere) => {
+        const record = this.reverse(item);
+        const fields = this.fields(record, (col) => !this.ids.includes(col));
+        if (fields.length === 0)
+            throw new DatasourceError("Update requires at least one non-Id field");
+        const statement = this.statements().update(fields, byWhere ?? this.idsWhere(record), (name, value) => this.cell(name, value, byWhere === undefined));
+        return { text: DefaultStatementTextRenderer.instance.render(statement), parameters: statement.parameters };
+    };
+    deleteCommand = (item, byWhere) => {
+        const record = this.reverse(item);
+        const statement = this.statements().delete(byWhere ?? this.idsWhere(record), (name, value) => this.cell(name, value, byWhere === undefined));
+        const listed = statement.where?.parameters ?? [];
+        const parameters = listed.length
+            ? listed
+            : DefaultStatementTextRenderer.instance.render(statement).includes("$")
+                ? this.fields(record, () => true)
+                : [];
+        return { text: DefaultStatementTextRenderer.instance.render(statement), parameters };
+    };
+    statements = () => (this.cached ??= repositoryParts(this.command.connection, this.options).statements);
+    get ids() {
+        return this.options.ids ?? this.repo.ids;
+    }
+    reverse = (item) => {
+        const objects = this.options.objectConverter ?? new MetaDataRowTypeConverter();
+        const row = objects.reverseConvert(item);
+        return this.options.rowConverter ? this.options.rowConverter.reverseConvert(row) : row;
+    };
+    fields = (record, include) => Object.entries(record)
+        .filter(([key, value]) => include(key) && value !== null && value !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, value]) => ({ name, value: this.cell(name, value, true) }));
+    cell = (property, value, fieldsApplied) => fieldsApplied
+        ? value
+        : this.options.objectConverter instanceof MetaDataRowTypeConverter &&
+            this.options.objectConverter.fields[property]
+            ? this.options.objectConverter.fields[property].reverseConvert(value)
+            : value;
+    idsWhere = (record) => {
+        const parts = this.ids.map((col) => {
+            if (!Object.prototype.hasOwnProperty.call(record, col))
+                throw new DatasourceError(`Missing Id value "${col}"`);
+            return new Operator.Equals(col, record[col]);
+        });
+        return new Where(parts.length === 0
+            ? new Operator.Equals(new Literal(1), new Literal(1))
+            : parts.reduce((left, right) => new Operator.And(left, right)));
+    };
+}

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

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

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

@@ -0,0 +1,48 @@
+import { CRUDRepository } from "./CRUDRepository.js";
+import { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.js";
+import { SingleCommandIBulkWriteStrategy } from "./SingleCommandIBulkWriteStrategy.js";
+import { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.js";
+const isBulkStrategy = (value) => "create" in value &&
+    "update" in value &&
+    "delete" in value &&
+    !("persist" in value) &&
+    !("createCommand" in value) &&
+    !("statements" in value);
+const transactionOf = (options) => options !== undefined && "write" in options ? options.write?.useTransaction ?? false : false;
+const inTransaction = async (transactional, connection, write) => {
+    if (!transactional)
+        return write();
+    const work = new UnitOfWorkTransaction(connection);
+    await work.begin();
+    try {
+        const result = await write();
+        await work.commit();
+        return result;
+    }
+    catch (error) {
+        await work.abort();
+        throw error;
+    }
+};
+export class BulkCRUDRepository extends CRUDRepository {
+    strategy;
+    transactional;
+    constructor(typeOrConnection, connectionOrOptions, bulk) {
+        const strategy = bulk ?? (isBulkStrategy(connectionOrOptions ?? {}) ? connectionOrOptions : undefined);
+        const transactional = transactionOf(connectionOrOptions);
+        const parent = (isBulkStrategy(connectionOrOptions ?? {}) ? undefined : connectionOrOptions);
+        super(typeOrConnection, parent);
+        this.strategy = strategy ?? new SingleCommandIBulkWriteStrategy();
+        this.transactional = transactional;
+        this.strategy.repo = this;
+        this.strategy.attach(this.command(), typeof typeOrConnection === "function"
+            ? createCRUDRepositoryOptions(typeOrConnection)
+            : parent);
+    }
+    createBulk = async (items) => {
+        await inTransaction(this.transactional || items.length > 0, this.command().connection, () => this.strategy.create(items));
+        return items;
+    };
+    updateBulk = (items, byWhere) => inTransaction(this.transactional, this.command().connection, () => this.strategy.update(items, byWhere));
+    deleteBulk = (items, byWhere) => inTransaction(this.transactional, this.command().connection, () => this.strategy.delete(items, byWhere));
+}

package/dist/BulkCommand.d.ts

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

package/dist/BulkCommand.js

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

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

@@ -0,0 +1,11 @@
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.js";
+import { enrichmentsOf } from "./ReadonlyRepository.js";
+import { RepositoryTree } from "./RepositoryTree.js";
+import { RepositoryTreeNode } from "./RepositoryTreeNode.js";
+export const afterBulkWrite = async (repo, options, items, mode) => {
+    if (items.length === 0 || !enrichmentsOf(repo)?.length)
+        return;
+    const write = options.write ?? new DefaultWriteEnrichmentStrategy();
+    const tree = new RepositoryTree(new RepositoryTreeNode(repo, ""));
+    await (write.persistBulk ?? write.persist)(tree, items, mode);
+};

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

@@ -0,0 +1,182 @@
+import { Literal } from "./statements/Literal.js";
+import { DefaultStatementTextRenderer, Operator, Where } from "./statements/index.js";
+import { repositoryParts } from "./CRUDRepositoryBuilder.js";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+import { enrichmentsOf, ReadonlyRepository } from "./ReadonlyRepository.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+import { execute, executeReader } from "./ICommand.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.js";
+import { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.js";
+import { RepositoryTree } from "./RepositoryTree.js";
+import { RepositoryTreeNode } from "./RepositoryTreeNode.js";
+const assigned = (value) => value !== null && value !== "" && value !== 0 && value !== 0n;
+const fieldsOf = (record, include, cell, enrichmentInto) => Object.entries(record)
+    .filter(([key, value]) => include(key) && !enrichmentInto(key) && value !== null && value !== undefined)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([name, value]) => ({ name, value: cell(name, value, true) }));
+const isCells = (id) => typeof id === "object" && id !== null;
+const named = (row, property, sqlColumn) => {
+    if (property === sqlColumn || !(sqlColumn in row))
+        return row;
+    const { [sqlColumn]: cell, ...rest } = row;
+    return { ...rest, [property]: cell };
+};
+const identified = (row, column) => {
+    const values = Object.values(row);
+    return column in row || values.length !== 1 ? row : { [column]: values[0] };
+};
+const scalarOf = (value) => value === undefined || value === null || typeof value === "object" ? undefined : value;
+export class CRUDRepository extends ReadonlyRepository {
+    ids;
+    crudStatements;
+    tree;
+    write;
+    get useTransaction() {
+        return this.write.useTransaction;
+    }
+    constructor(typeOrConnection, connectionOrOptions) {
+        const options = connectionOrOptions;
+        const opened = repositoryParts(typeOrConnection, options);
+        super(opened.built);
+        this.ids = opened.built.ids;
+        this.crudStatements = opened.statements;
+        this.tree = new RepositoryTree(new RepositoryTreeNode(this, ""));
+        this.write = options.write ?? new DefaultWriteEnrichmentStrategy();
+    }
+    addEnriched(enrichment, via, strategy) {
+        super.addEnriched(enrichment, via, strategy);
+        const writer = writerOf(via);
+        if (writer)
+            lastEnrichment(this).persist = writer;
+        return this;
+    }
+    addLinked(enrichment, via, link, strategy) {
+        const chosen = strategy ?? new DefaultReadonlyEnrichmentStrategy();
+        super.addEnriched(enrichment, via, strategy);
+        const stored = lastEnrichment(this);
+        stored.apply = (parents, sources) => chosen.applyLinked(via, link, enrichment, parents, sources);
+        stored.link = link;
+        return this;
+    }
+    create = (item) => this.inTransaction(() => this.createCore(item));
+    update = (item, byWhere) => this.inTransaction(() => this.updateCore(item, byWhere));
+    delete = (item, byWhere) => this.inTransaction(() => this.deleteCore(item, byWhere));
+    inTransaction = async (write) => {
+        if (!this.useTransaction)
+            return write();
+        const work = new UnitOfWorkTransaction(this.command().connection);
+        await work.begin();
+        try {
+            const result = await write();
+            await work.commit();
+            return result;
+        }
+        catch (error) {
+            await work.abort();
+            throw error;
+        }
+    };
+    createCore = async (item) => {
+        await this.insert(item);
+        if (!this.enriched)
+            return item;
+        await this.write.persist(this.tree, [item], "create");
+        if (this.ids.length !== 1)
+            return item;
+        const id = this.idValue(item);
+        return id === undefined ? item : (await this.readSingleById(id)) ?? item;
+    };
+    updateCore = async (item, byWhere) => {
+        const response = await this.save(item, byWhere);
+        if (this.enriched)
+            await this.write.persist(this.tree, [item], "update");
+        return response;
+    };
+    deleteCore = async (item, byWhere) => {
+        if (this.enriched)
+            await this.write.persist(this.tree, [item], "delete");
+        return this.remove(item, byWhere);
+    };
+    readSingleById = async (id) => this.readSingle(this.byId(id));
+    insert = async (item) => {
+        const record = this.reverseConvert(item);
+        const fields = fieldsOf(record, (col) => !this.ids.includes(col) || assigned(record[col] ?? null), this.cell, this.enrichmentInto);
+        const statement = this.crudStatements.insert(fields);
+        const response = await execute(this.command(), statement, statement.fields);
+        if (this.ids.length === 1 && !fields.some((field) => field.name === this.ids[0]))
+            await this.copyInsertedId(item, fields);
+        return response;
+    };
+    copyInsertedId = async (target, fields) => {
+        void fields;
+        const column = this.ids[0];
+        const statement = this.crudStatements.selectInsertedId(column);
+        const sqlColumn = statement.column;
+        const reader = await executeReader(this.command(), statement);
+        try {
+            if (!(await reader.next()))
+                return;
+            const current = reader.current;
+            if (!current)
+                throw new DatasourceError("Reader current must be a row");
+            const row = identified(named(current, column, sqlColumn), column);
+            const cells = this.rowConverter ? this.rowConverter.convert(row) : row;
+            const converted = this.objectConverter instanceof MetaDataRowTypeConverter
+                ? this.objectConverter.convert(cells, this.type)
+                : this.objectConverter.convert(cells);
+            const value = scalarOf(converted[column]);
+            if (value !== undefined)
+                target[column] = value;
+        }
+        finally {
+            await reader.dispose();
+        }
+    };
+    idValue = (item) => scalarOf(item[this.ids[0]]);
+    save = async (item, byWhere) => {
+        const record = this.reverseConvert(item);
+        const fields = fieldsOf(record, (col) => !this.ids.includes(col), this.cell, this.enrichmentInto);
+        if (fields.length === 0)
+            throw new DatasourceError("Update requires at least one non-Id field");
+        const statement = this.crudStatements.update(fields, byWhere ?? this.idWhere(record), (name, value) => this.cell(name, value, byWhere === undefined));
+        return execute(this.command(), statement, statement.parameters);
+    };
+    remove = async (item, byWhere) => {
+        const record = this.reverseConvert(item);
+        const statement = this.crudStatements.delete(byWhere ?? this.idWhere(record), (name, value) => this.cell(name, value, byWhere === undefined));
+        const listed = statement.where?.parameters ?? [];
+        const parameters = listed.length
+            ? listed
+            : DefaultStatementTextRenderer.instance.render(statement).includes("$")
+                ? fieldsOf(record, () => true, this.cell, this.enrichmentInto)
+                : [];
+        return execute(this.command(), statement, parameters);
+    };
+    byId = (id) => {
+        if (this.ids.length === 0)
+            throw new DatasourceError("ReadSingleById requires an Id column");
+        if (isCells(id))
+            return this.idWhere(id);
+        if (this.ids.length !== 1)
+            throw new DatasourceError("Composite id requires a row keyed by each Id column");
+        return this.idWhere({ [this.ids[0]]: id });
+    };
+    reverseConvert = (item) => {
+        const row = this.objectConverter.reverseConvert(item);
+        return this.rowConverter ? this.rowConverter.reverseConvert(row) : row;
+    };
+    idWhere = (record) => {
+        const parts = this.ids.map((col) => {
+            if (!Object.prototype.hasOwnProperty.call(record, col))
+                throw new DatasourceError(`Missing Id value "${col}"`);
+            return new Operator.Equals(col, record[col]);
+        });
+        return new Where(parts.length === 0
+            ? new Operator.Equals(new Literal(1), new Literal(1))
+            : parts.reduce((left, right) => new Operator.And(left, right)));
+    };
+    enrichmentInto = (name) => enrichmentsOf(this).some((entry) => entry.enrichment.destinationProperty === name);
+}
+const writerOf = (via) => "create" in via && typeof via.create === "function" ? via : undefined;
+const lastEnrichment = (host) => enrichmentsOf(host).at(-1);

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

@@ -0,0 +1,30 @@
+import { defaultId, fieldNamesOf, createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.js";
+import { CRUDRepository } from "./CRUDRepository.js";
+import { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.js";
+import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+const isCrud = (options) => "ids" in options || "write" in options;
+const withIds = (options) => "ids" in options
+    ? options
+    : {
+        ...options,
+        ids: options.type ? defaultId(fieldNamesOf(options.type)) : ["id"],
+    };
+export const repositoryParts = (typeOrConnection, connectionOrOptions) => {
+    const builder = new CRUDRepositoryBuilder();
+    const built = typeof typeOrConnection === "function"
+        ? builder.parts(connectionOrOptions, createCRUDRepositoryOptions(typeOrConnection))
+        : builder.parts(typeOrConnection, withIds(connectionOrOptions));
+    return { built, statements: builder.crudStatements };
+};
+export class CRUDRepositoryBuilder extends ReadonlyRepositoryBuilder {
+    crudStatements;
+    ids = (options) => isCrud(options)
+        ? (options.ids ?? (options.type ? defaultId(fieldNamesOf(options.type)) : ["id"]))
+        : [];
+    statements = (table, columns) => {
+        this.crudStatements = new CRUDRepositoryStatements(table, columns, this.entityMapper, this.propertyMapper);
+        return new ReadonlyRepositoryStatements(table, columns);
+    };
+    build = (connection, options) => new CRUDRepository(connection, options);
+}

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

@@ -1,8 +1,7 @@
-import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
-import type { Cells } from "./converters/Cell.ts";
-import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.ts";
-
+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>;
+    ids?: string[];
+    write?: IWriteEnrichmentStrategy<T>;
 };

package/dist/CRUDRepositoryOptions.js

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

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