@deterministic-code/datasources 0.1.1 → 0.1.3

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

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

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

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

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.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.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/dist/CRUDRepositoryOptions.js

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

package/dist/CRUDRepositoryStatements.js

@@ -0,0 +1,19 @@
+import { IdentityMapper } from "./mappers/IdentityMapper.js";
+import { StatementMappers } from "./StatementMappers.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 { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+const same = (_name, value) => value;
+export class CRUDRepositoryStatements extends ReadonlyRepositoryStatements {
+    mappings;
+    constructor(table, columns, entityMappers = new IdentityMapper(), propertyMappers = new IdentityMapper()) {
+        super(table, columns);
+        this.mappings = new StatementMappers(entityMappers, propertyMappers);
+    }
+    insert = (fields) => this.mappings.apply(new InsertStatement(this.table, fields), same);
+    update = (fields, where, cell = same) => this.mappings.apply(new UpdateStatement(this.table, fields, where), cell);
+    delete = (where, cell = same) => this.mappings.apply(new DeleteStatement(this.table, where), cell);
+    selectInsertedId = (column) => this.mappings.apply(new SelectInsertedIdStatement(this.table, column), same);
+}

package/dist/CascadeDeleteEnrichmentStrategy.js

@@ -0,0 +1,28 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import { Operator, Where } from "./statements/index.js";
+const get = (item, name) => item[name];
+const present = (value) => value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
+const linkWhere = (association, parentKey, relatedKey) => new Where(new Operator.And(new Operator.Equals(association.parent, parentKey), new Operator.Equals(association.related, relatedKey)));
+export class CascadeDeleteEnrichmentStrategy extends DeleteEnrichmentStrategy {
+    async deleteChildren(writer, enrichment, parent, deleteNested) {
+        const existing = await DeleteEnrichmentStrategy.load(writer, enrichment, parent);
+        await deleteNested(existing);
+        for (const row of existing)
+            await writer.delete(row, DeleteEnrichmentStrategy.childrenWhere(writer, enrichment, parent));
+    }
+    async deleteLinked(writer, enrichment, parent) {
+        const association = enrichment.association;
+        if (!association)
+            throw new DatasourceError("Missing association");
+        const key = get(parent, enrichment.sourceProperty);
+        if (!present(key))
+            return;
+        for (const row of await DeleteEnrichmentStrategy.loadLinks(writer, association.parent, key)) {
+            const id = get(row, association.related);
+            if (!present(id))
+                continue;
+            await writer.delete(row, linkWhere(association, key, id));
+        }
+    }
+}

package/dist/CascadeDeleteUpdateEnrichmentStrategy.js

@@ -0,0 +1,25 @@
+import { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+export class CascadeDeleteUpdateEnrichmentStrategy extends UpdateEnrichmentStrategy {
+    create = new DefaultCreateEnrichmentStrategy();
+    async updateChildren(writer, enrichment, parent) {
+        for (const row of await DeleteEnrichmentStrategy.load(writer, enrichment, parent))
+            await writer.delete(row, DeleteEnrichmentStrategy.childrenWhere(writer, enrichment, parent));
+        await this.create.createChildren(writer, enrichment, parent);
+    }
+    async updateLinked(writer, enrichment, parent) {
+        const association = enrichment.association;
+        if (!association)
+            throw new DatasourceError("Missing association");
+        const parentKey = this.requiredKey(parent, enrichment);
+        for (const row of await DeleteEnrichmentStrategy.loadLinks(writer, association.parent, parentKey)) {
+            const id = this.getCell(row, association.related);
+            if (!this.presentCell(id))
+                continue;
+            await writer.delete(row, this.linkWhere(association, parentKey, id));
+        }
+        await this.create.createLinked(writer, enrichment, parent);
+    }
+}

package/dist/CommandMiddlewareHost.js

@@ -0,0 +1,73 @@
+import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.js";
+import { Native } from "./statements/Native.js";
+import { StatementParser } from "./statements/StatementParser.js";
+const asError = (error) => error instanceof Error ? error : new Error(String(error));
+const resultOf = (value) => value instanceof Date ||
+    value instanceof Uint8Array ||
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean" ||
+    typeof value === "bigint"
+    ? value
+    : String(value);
+const isResponse = (value) => "rowsAffected" in value && typeof value.rowsAffected === "number";
+const logged = (value, rows) => rows.length > 0 || value === null || typeof value !== "object" || !isResponse(value)
+    ? rows
+    : [{ result: resultOf(value.result), rowsAffected: value.rowsAffected }];
+export class CommandMiddlewareHost {
+    middlewares = [];
+    addMiddleware(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+    execute(text, parameters) {
+        if (!text.trim())
+            throw new Error("empty command");
+        return this.executeStatement(StatementParser.parse(text), parameters);
+    }
+    executeReader(text, parameters) {
+        if (!text.trim())
+            throw new Error("empty command");
+        return this.executeReaderStatement(StatementParser.parse(text), parameters);
+    }
+    executeStatement(statement, parameters) {
+        return this.executeNative(new Native(DefaultStatementTextRenderer.instance.render(statement)), parameters);
+    }
+    executeReaderStatement(statement, parameters) {
+        return this.executeReaderNative(new Native(DefaultStatementTextRenderer.instance.render(statement)), parameters);
+    }
+    executeNative(_text, _parameters) {
+        throw new Error("executeNative");
+    }
+    executeReaderNative(_text, _parameters) {
+        throw new Error("executeReaderNative");
+    }
+    async run(text, params, fn) {
+        let q = text.trim();
+        let p = params;
+        for (const middleware of this.middlewares) {
+            const rewritten = await middleware.beforeCommand(q, p);
+            if (rewritten) {
+                q = rewritten.text;
+                p = rewritten.params;
+            }
+        }
+        const start = performance.now();
+        try {
+            const { value, rows } = await fn(q, p);
+            const elapsedMs = performance.now() - start;
+            for (const middleware of this.middlewares) {
+                await middleware.afterCommand(q, p, logged(value, rows), elapsedMs);
+            }
+            return value;
+        }
+        catch (error) {
+            const elapsedMs = performance.now() - start;
+            for (const middleware of this.middlewares) {
+                await middleware.afterCommand(q, p, [], elapsedMs, asError(error));
+            }
+            throw error;
+        }
+    }
+}

package/dist/ConsoleCommandMiddleware.js

@@ -0,0 +1,45 @@
+export const formatElapsed = (elapsedMs) => elapsedMs < 1
+    ? `${Math.round(elapsedMs * 1000)}μs`
+    : `${Math.round(elapsedMs)}ms`;
+const cellOf = (value) => value === null
+    ? "null"
+    : value instanceof Date
+        ? value.toISOString()
+        : value instanceof Uint8Array
+            ? Buffer.from(value).toString("base64")
+            : typeof value === "bigint"
+                ? String(value)
+                : typeof value === "boolean"
+                    ? value ? "True" : "False"
+                    : typeof value === "string"
+                        ? value
+                        : String(value);
+const paramsOf = (params) => `{${(params ?? []).map((param) => `${param.name}: ${cellOf(param.value)}`).join(", ")}}`;
+const rowsOf = (rows) => rows
+    .map((row) => `{${Object.entries(row).sort(([left], [right]) => left < right ? -1 : 1).map(([key, value]) => `${key}: ${cellOf(value)}`).join(", ")}}`)
+    .join(", ");
+export class ConsoleCommandMiddleware {
+    write;
+    now;
+    options;
+    constructor(write = (line) => {
+        console.log(line);
+    }, now = () => new Date(), options = {}) {
+        this.write = write;
+        this.now = now;
+        this.options = options;
+    }
+    beforeCommand = (text, params) => {
+        this.write(this.line("Start", text));
+        if (this.verbose())
+            this.write(this.line("Request", paramsOf(params)));
+    };
+    afterCommand = (text, _params, results, elapsedMs) => {
+        const options = { ...this.options, elapsedMs: formatElapsed(elapsedMs) };
+        this.write(`${this.line("Finish", text)} ${options.elapsedMs}`);
+        if (this.verbose())
+            this.write(this.line("AfterCommand", rowsOf(results)));
+    };
+    verbose = () => this.options.isVerbose === "true" || this.options.isVerbose === "1";
+    line = (phase, text) => `[${this.now().toISOString()}]-[datasource][${phase}]-[${text}]`;
+}