@deterministic-code/datasources 0.1.1 → 0.1.3

package/dist/CreateEnrichmentStrategy.js

@@ -0,0 +1,64 @@
+import { DatasourceError } from "./DatasourceError.js";
+export class CreateEnrichmentStrategy {
+    collectChildren(writer, enrichment, parent) {
+        const children = this.payloadOf(parent, enrichment.destinationProperty, enrichment);
+        if (children.length === 0)
+            return children;
+        const key = this.requiredKey(parent, enrichment);
+        for (const child of children)
+            this.stampCell(child, enrichment.relatedKey, key);
+        return children;
+    }
+    getCell = (item, name) => item[name];
+    presentCell = (value) => value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
+    payloadOf = (parent, into, enrichment) => mapPayload(this.getCell(parent, into), enrichment);
+    stampCell = (related, by, key) => {
+        if (key === undefined || key === null || typeof key === "object")
+            return;
+        const current = this.getCell(related, by);
+        if (current !== null && typeof current === "object" && !Array.isArray(current)) {
+            const target = current;
+            const id = "Id" in target ? "Id" : "id";
+            target[id] = key;
+            return;
+        }
+        Object.assign(related, { [by]: key });
+    };
+    relatedIds = (parent, enrichment) => {
+        const ids = [];
+        const seen = new Set();
+        for (const related of this.payloadOf(parent, enrichment.destinationProperty)) {
+            const id = this.getCell(related, enrichment.relatedKey);
+            if (!this.presentCell(id))
+                throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.relatedKey}"`);
+            const key = String(id);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            ids.push(id);
+        }
+        return ids;
+    };
+    requiredKey = (parent, enrichment) => {
+        const key = this.getCell(parent, enrichment.sourceProperty);
+        if (!this.presentCell(key))
+            throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.sourceProperty}"`);
+        return key;
+    };
+}
+const mapPayload = (value, enrichment) => {
+    if (value === undefined || value === null || typeof value === "string")
+        return [];
+    if (Array.isArray(value))
+        return value.filter((item) => item !== null && typeof item === "object");
+    if (enrichment?.type !== "dictionary" || typeof value !== "object")
+        return [];
+    const keyName = mapKeyName(enrichment.relatedKey);
+    const valueName = enrichment.relatedProperty ?? (keyName === "Key" ? "Value" : "value");
+    return Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, cell]) => cell !== null && typeof cell === "object" && !Array.isArray(cell)
+        ? { [keyName]: key, ...cell }
+        : { [keyName]: key, [valueName]: cell });
+};
+const mapKeyName = (relatedKey) => relatedKey.includes("_") || relatedKey[0] !== relatedKey[0]?.toUpperCase() ? "key" : "Key";

package/dist/Datasource.js

@@ -0,0 +1,98 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { CRUDRepository } from "./CRUDRepository.js";
+import { ReadonlyRepository } from "./ReadonlyRepository.js";
+import { RepositoryFactory } from "./RepositoryFactory.js";
+import { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.js";
+import { RowTypeConverter } from "./converters/RowTypeConverter.js";
+import { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.js";
+import { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.js";
+export class Datasource {
+    provider;
+    driver;
+    options;
+    connection;
+    repositories = new RepositoryFactory();
+    constructor(provider, driver, options) {
+        this.provider = provider;
+        this.driver = driver;
+        this.options = options;
+        const self = this;
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (typeof prop !== "string" || Reflect.has(target, prop))
+                    return Reflect.get(target, prop, receiver);
+                if (self.repositories.has(prop))
+                    return self.repositories.create(prop, self.defaultConnection());
+                throw new RepositoryNotRegisteredError(prop);
+            },
+        });
+    }
+    defaultConnection = () => (this.connection ??= this.driver.connection(this.options));
+    createConnection = () => Promise.resolve(this.defaultConnection());
+    createCommand = async (connection) => {
+        if (!connection) {
+            connection = this.defaultConnection();
+            if (connection.isOpen)
+                throw new DatasourceError("Connection is already open");
+            await connection.open();
+        }
+        return this.driver.command(connection);
+    };
+    applyCrud = (type, options) => {
+        const built = createCRUDRepositoryOptions(type, this.driver.rowTypeConverters);
+        const types = this.driver.rowTypeConverters;
+        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, columnsOf(type));
+        return {
+            ...(options ?? built),
+            entity: options?.entity ?? built.entity,
+            rowConverter: rows,
+            rowTypeConverters: types,
+            type,
+        };
+    };
+    applyReadonly = (type, options) => {
+        const built = createReadonlyRepositoryMappingOptions(type, this.driver.rowTypeConverters);
+        const types = this.driver.rowTypeConverters;
+        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, columnsOf(type));
+        return {
+            ...(options ?? built),
+            entity: options?.entity ?? built.entity,
+            rowConverter: rows,
+            rowTypeConverters: types,
+            type,
+        };
+    };
+    createRepository(typeOrName, connection, options) {
+        if (typeof typeOrName === "string")
+            return this.repositories.create(typeOrName, connection ?? this.defaultConnection());
+        return new CRUDRepository(connection ?? this.defaultConnection(), this.applyCrud(typeOrName, options));
+    }
+    createReadonlyRepository(typeOrName, connection, options) {
+        if (typeof typeOrName === "string")
+            return this.repositories.createReadonly(typeOrName, connection ?? this.defaultConnection());
+        return new ReadonlyRepository(connection ?? this.defaultConnection(), this.applyReadonly(typeOrName, options));
+    }
+    static create;
+    static get default() {
+        return Datasource.create();
+    }
+}
+const columnsOf = (type) => {
+    const instance = new type();
+    const columns = {};
+    for (const [name, value] of Object.entries(instance)) {
+        if (Array.isArray(value))
+            continue;
+        const canonical = canonicalOf(value);
+        if (canonical)
+            columns[name] = canonical;
+    }
+    return columns;
+};
+const canonicalOf = (value) => typeof value === "boolean"
+    ? "bool"
+    : value instanceof Date
+        ? "datetime"
+        : value instanceof Uint8Array
+            ? "binary"
+            : undefined;

package/dist/DatasourceError.js

@@ -0,0 +1,6 @@
+export class DatasourceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DatasourceError";
+    }
+}

package/dist/DatasourceFactory.js

@@ -0,0 +1,76 @@
+import { Datasource } from "./Datasource.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { DatasourceUrlParser } from "./DatasourceUrlParser.js";
+import { DriverLoader } from "./DriverLoader.js";
+import { DotEnv } from "./dotEnv.js";
+import { ProviderCatalog } from "./ProviderCatalog.js";
+import { ProviderNotInstalledError } from "./ProviderNotInstalledError.js";
+const factories = new Map();
+const get = (options, key) => {
+    const value = options?.[key];
+    return value && value.trim() ? value.trim() : undefined;
+};
+const nonEmpty = (value) => value?.trim() ? value.trim() : undefined;
+const merge = (file, env) => {
+    const options = { ...file };
+    for (const key of ["INSTALLED_PROVIDERS", "DATASOURCE_URL", "PROVIDER"]) {
+        const value = nonEmpty(env[key]);
+        if (value)
+            options[key] = value;
+    }
+    return options;
+};
+const split = (value) => (value ?? "")
+    .split(",")
+    .map((name) => name.trim())
+    .filter((name) => name.length > 0);
+function* installed(options) {
+    const names = new Set();
+    for (const name of split(get(options, "INSTALLED_PROVIDERS"))) {
+        if (names.has(name))
+            continue;
+        names.add(name);
+        yield name;
+    }
+    const url = get(options, "DATASOURCE_URL");
+    if (!url)
+        return;
+    const provider = DatasourceUrlParser.parse(url)?.provider;
+    if (!provider)
+        throw new DatasourceError("DATASOURCE_URL has no provider");
+    if (!names.has(provider))
+        yield provider;
+}
+const registerInstalled = (options) => {
+    for (const name of installed(options)) {
+        const catalog = ProviderCatalog.default[name];
+        if (!catalog)
+            throw new ProviderNotInstalledError(name);
+        if (factories.has(name))
+            continue;
+        DatasourceFactory.register(name, DriverLoader.load(catalog));
+    }
+};
+const resolve = (options) => {
+    const listed = options ?? merge(DotEnv.load(), process.env);
+    if (options === undefined)
+        registerInstalled(listed);
+    const name = get(listed, "PROVIDER")
+        ?? (() => { throw new DatasourceError("Datasource defaults are not specified"); })();
+    const driver = factories.get(name);
+    if (!driver)
+        throw new ProviderNotInstalledError(name);
+    return new Datasource(name, driver, listed);
+};
+export class DatasourceFactory {
+    static defaults = (options) => registerInstalled(options);
+    static register = (provider, driver) => {
+        factories.set(provider, driver);
+    };
+    static create = (options) => resolve(options);
+    create = (options) => resolve(options);
+    static reset = () => {
+        factories.clear();
+    };
+    static registered = () => [...factories.keys()].sort();
+}

package/dist/DatasourceOptions.js

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

package/dist/DatasourceUrl.js

@@ -0,0 +1,28 @@
+export class DatasourceUrl {
+    provider;
+    username;
+    password;
+    host;
+    port;
+    path;
+    schema;
+    options;
+    constructor(provider, username, password, host, port, path, schema, options) {
+        this.provider = provider;
+        this.username = username;
+        this.password = password;
+        this.host = host;
+        this.port = port;
+        this.path = path;
+        this.schema = schema;
+        this.options = options;
+    }
+    get datasource() {
+        if (this.path === "")
+            return undefined;
+        if (!this.path.startsWith("/"))
+            return this.path;
+        const rest = this.path.slice(1);
+        return rest === "" ? undefined : rest;
+    }
+}

package/dist/DatasourceUrlParser.js

@@ -0,0 +1,168 @@
+import { DatasourceUrl } from "./DatasourceUrl.js";
+const empty = {};
+const schemeStart = (c) => (c >= "A" && c <= "Z") || (c >= "a" && c <= "z");
+const schemeChar = (c) => schemeStart(c) || (c >= "0" && c <= "9") || c === "+" || c === "." || c === "-";
+const schemeColon = (url) => {
+    if (!schemeStart(url.charAt(0)))
+        return undefined;
+    let i = 1;
+    while (i < url.length && schemeChar(url[i]))
+        i++;
+    return i < url.length && url[i] === ":" ? i : undefined;
+};
+const hex = (text) => /^[0-9a-fA-F]{2}$/.test(text) ? Number.parseInt(text, 16) : undefined;
+const decode = (text) => {
+    const bytes = [];
+    let decoded = "";
+    const flush = () => {
+        if (bytes.length === 0)
+            return;
+        decoded += new TextDecoder().decode(new Uint8Array(bytes));
+        bytes.length = 0;
+    };
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c !== "%") {
+            const code = text.charCodeAt(i);
+            if (code <= 127)
+                bytes.push(code);
+            else {
+                flush();
+                decoded += c;
+            }
+            continue;
+        }
+        const byte = i + 2 < text.length ? hex(text.slice(i + 1, i + 3)) : undefined;
+        if (byte === undefined)
+            return undefined;
+        bytes.push(byte);
+        i += 2;
+    }
+    flush();
+    return decoded;
+};
+const portOf = (text) => /^[0-9]+$/.test(text) ? Number.parseInt(text, 10) : undefined;
+const userOf = (user) => {
+    const colon = user.indexOf(":");
+    const username = decode(colon < 0 ? user : user.slice(0, colon));
+    if (username === undefined)
+        return undefined;
+    if (colon < 0)
+        return { username: username === "" ? undefined : username, password: undefined };
+    const password = decode(user.slice(colon + 1));
+    if (password === undefined)
+        return undefined;
+    return { username: username === "" ? undefined : username, password };
+};
+const hostLiteral = (hostport) => {
+    const end = hostport.indexOf("]");
+    if (end < 1)
+        return undefined;
+    const host = decode(hostport.slice(1, end));
+    if (host === undefined)
+        return undefined;
+    if (end + 1 === hostport.length)
+        return { host, port: undefined };
+    if (hostport[end + 1] !== ":")
+        return undefined;
+    const port = portOf(hostport.slice(end + 2));
+    return port === undefined ? undefined : { host, port };
+};
+const authorityOf = (authority, hasPath) => {
+    if (authority.length === 0)
+        return { username: undefined, password: undefined, host: undefined, port: undefined, file: undefined };
+    const at = authority.lastIndexOf("@");
+    let hostport = authority;
+    let username;
+    let password;
+    if (at >= 0) {
+        const user = userOf(authority.slice(0, at));
+        if (!user)
+            return undefined;
+        username = user.username;
+        password = user.password;
+        hostport = authority.slice(at + 1);
+    }
+    const base = { username, password, file: undefined };
+    if (hostport.length === 0)
+        return { ...base, host: undefined, port: undefined };
+    if (hostport[0] === "[") {
+        const literal = hostLiteral(hostport);
+        return literal ? { ...base, host: literal.host, port: literal.port } : undefined;
+    }
+    const colon = hostport.lastIndexOf(":");
+    if (colon >= 0) {
+        const port = portOf(hostport.slice(colon + 1));
+        if (port !== undefined) {
+            const name = hostport.slice(0, colon);
+            if (name.length === 0)
+                return { ...base, host: undefined, port };
+            const host = decode(name);
+            return host === undefined ? undefined : { ...base, host, port };
+        }
+    }
+    if (!hasPath && at < 0 && hostport[0] !== ":") {
+        const file = decode(hostport);
+        return file === undefined ? undefined : { ...base, host: undefined, port: undefined, file };
+    }
+    const host = decode(hostport);
+    return host === undefined ? undefined : { ...base, host, port: undefined };
+};
+const queryOf = (query) => {
+    if (query.length === 0)
+        return { schema: undefined, options: empty };
+    const options = {};
+    let schema;
+    for (const part of query.split("&")) {
+        if (part.length === 0)
+            continue;
+        const eq = part.indexOf("=");
+        const key = decode(eq < 0 ? part : part.slice(0, eq));
+        const value = decode(eq < 0 ? "" : part.slice(eq + 1));
+        if (key === undefined || value === undefined)
+            return undefined;
+        if (key === "schema")
+            schema = value;
+        else
+            options[key] = value;
+    }
+    return { schema, options };
+};
+const partsOf = (rest) => {
+    if (!rest.startsWith("//"))
+        return { username: undefined, password: undefined, host: undefined, port: undefined, path: rest };
+    const body = rest.slice(2);
+    const slash = body.indexOf("/");
+    const authority = authorityOf(slash >= 0 ? body.slice(0, slash) : body, slash >= 0);
+    if (!authority)
+        return undefined;
+    return {
+        username: authority.username,
+        password: authority.password,
+        host: authority.host,
+        port: authority.port,
+        path: authority.file ?? (slash >= 0 ? body.slice(slash) : ""),
+    };
+};
+export class DatasourceUrlParser {
+    static parse(url) {
+        if (url === undefined || url.trim() === "")
+            return undefined;
+        const colon = schemeColon(url);
+        if (colon === undefined)
+            return undefined;
+        let rest = url.slice(colon + 1);
+        const hash = rest.indexOf("#");
+        if (hash >= 0)
+            rest = rest.slice(0, hash);
+        const queryAt = rest.indexOf("?");
+        const query = queryAt >= 0 ? rest.slice(queryAt + 1) : "";
+        if (queryAt >= 0)
+            rest = rest.slice(0, queryAt);
+        const parts = partsOf(rest);
+        const parsed = queryOf(query);
+        if (!parts || !parsed)
+            return undefined;
+        return new DatasourceUrl(url.slice(0, colon).toLowerCase(), parts.username, parts.password, parts.host, parts.port, parts.path, parsed.schema, parsed.options);
+    }
+}

package/dist/DefaultCreateEnrichmentStrategy.js

@@ -0,0 +1,18 @@
+import { CreateEnrichmentStrategy } from "./CreateEnrichmentStrategy.js";
+import { DatasourceError } from "./DatasourceError.js";
+export class DefaultCreateEnrichmentStrategy extends CreateEnrichmentStrategy {
+    async createChildren(writer, enrichment, parent) {
+        for (const related of this.payloadOf(parent, enrichment.destinationProperty, enrichment)) {
+            this.stampCell(related, enrichment.relatedKey, this.getCell(parent, enrichment.sourceProperty));
+            await writer.create(related);
+        }
+    }
+    async createLinked(writer, enrichment, parent) {
+        const association = enrichment.association;
+        if (!association)
+            throw new DatasourceError("Missing association");
+        const parentKey = this.requiredKey(parent, enrichment);
+        for (const id of this.relatedIds(parent, enrichment))
+            await writer.create({ [association.parent]: parentKey, [association.related]: id });
+    }
+}

package/dist/DefaultReadonlyEnrichmentStrategy.js

@@ -0,0 +1,107 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { EnrichmentPropertyType } from "./EnrichmentPropertyType.js";
+import { Operator, Where } from "./statements/index.js";
+export class DefaultReadonlyEnrichmentStrategy {
+    apply(via, enrichment, parents, sources) {
+        const type = enrichment.type ?? EnrichmentPropertyType.Object;
+        const run = {
+            [EnrichmentPropertyType.List]: () => this.applyList(via, enrichment, parents, sources),
+            [EnrichmentPropertyType.Object]: () => this.applyObject(via, enrichment, parents, sources),
+            [EnrichmentPropertyType.Dictionary]: () => this.applyDictionary(via, enrichment, parents, sources),
+        }[type];
+        return run ? run() : Promise.reject(new DatasourceError(`Unsupported enrichment type "${type}"`));
+    }
+    async applyLinked(via, link, enrichment, parents, sources) {
+        const association = enrichment.association ?? (() => {
+            throw new DatasourceError("Missing association");
+        })();
+        for (const [index, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, enrichment.sourceProperty, sources, index);
+            if (key === undefined || key === null)
+                continue;
+            const related = [];
+            for await (const row of link.read(new Where(new Operator.Equals(association.parent, this.scalar(key))))) {
+                const id = this.props(row)[association.related];
+                if (id === undefined || id === null || typeof id === "object")
+                    continue;
+                const entity = await via.readSingle(new Where(new Operator.Equals(enrichment.relatedKey, id)));
+                if (entity)
+                    related.push(entity);
+            }
+            Object.assign(parent, { [enrichment.destinationProperty]: related });
+        }
+    }
+    async applyObject(via, enrichment, parents, sources) {
+        const cache = new Map();
+        for (const [index, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, enrichment.sourceProperty, sources, index);
+            if (key === undefined || key === null)
+                continue;
+            const cacheKey = this.keyOf(key);
+            if (!cache.has(cacheKey))
+                cache.set(cacheKey, await via.readSingle(new Where(new Operator.Equals(enrichment.relatedKey, this.scalar(key)))));
+            const related = cache.get(cacheKey);
+            if (!related)
+                continue;
+            Object.assign(parent, {
+                [enrichment.destinationProperty]: enrichment.relatedProperty ? this.props(related)[enrichment.relatedProperty] : related,
+            });
+        }
+    }
+    async applyList(via, enrichment, parents, sources) {
+        for (const [index, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, enrichment.sourceProperty, sources, index);
+            if (key === undefined || key === null)
+                continue;
+            const related = [];
+            for await (const item of via.read(new Where(new Operator.Equals(enrichment.relatedKey, this.scalar(key)))))
+                related.push(item);
+            Object.assign(parent, { [enrichment.destinationProperty]: related });
+        }
+    }
+    async applyDictionary(via, enrichment, parents, sources) {
+        const mapKey = mapKeyName(enrichment.relatedKey);
+        for (const [index, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, enrichment.sourceProperty, sources, index);
+            if (key === undefined || key === null)
+                continue;
+            const map = {};
+            for await (const item of via.read(new Where(new Operator.Equals(enrichment.relatedKey, this.scalar(key))))) {
+                const row = this.props(item);
+                const entry = row[mapKey];
+                if (entry === undefined || entry === null || typeof entry === "object")
+                    continue;
+                map[String(entry)] = enrichment.relatedProperty
+                    ? (row[enrichment.relatedProperty] ?? null)
+                    : Object.fromEntries(Object.entries(row).filter(([name]) => name !== mapKey && name !== enrichment.relatedKey && name !== "Id" && name !== "id"));
+            }
+            Object.assign(parent, { [enrichment.destinationProperty]: map });
+        }
+    }
+    sourceKey(parent, name, sources, index) {
+        const cell = sources?.[index]?.[name];
+        const raw = cell !== undefined && cell !== null ? cell : this.props(parent)[name];
+        return this.lookupKey(raw);
+    }
+    props = (item) => item;
+    keyOf = (key) => String(this.lookupKey(key));
+    lookupKey = (value) => {
+        if (value === undefined || value === null || typeof value !== "object")
+            return value;
+        const id = this.props(value).Id ?? this.props(value).id;
+        return id !== undefined && id !== null && typeof id !== "object" ? id : value;
+    };
+    scalar = (value) => {
+        const key = this.lookupKey(value);
+        return key === null ||
+            typeof key === "string" ||
+            typeof key === "number" ||
+            typeof key === "boolean" ||
+            typeof key === "bigint"
+            ? key
+            : (() => {
+                throw new DatasourceError("Enrichment key must be a scalar");
+            })();
+    };
+}
+const mapKeyName = (relatedKey) => relatedKey.includes("_") || relatedKey[0] !== relatedKey[0]?.toUpperCase() ? "key" : "Key";

package/dist/DefaultUpdateEnrichmentStrategy.js

@@ -0,0 +1,41 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+export class DefaultUpdateEnrichmentStrategy extends UpdateEnrichmentStrategy {
+    async updateChildren(writer, enrichment, parent) {
+        const existing = await DeleteEnrichmentStrategy.load(writer, enrichment, parent);
+        const rows = this.payloadOf(parent, enrichment.destinationProperty, enrichment);
+        for (const related of rows)
+            this.stampCell(related, enrichment.relatedKey, this.getCell(parent, enrichment.sourceProperty));
+        const keys = this.namesOf(writer, rows[0] ?? existing[0] ?? {});
+        const keep = new Set(rows.filter((row) => this.hasKey(row, keys)).map((row) => this.keyOf(row, keys)));
+        for (const row of existing.filter((row) => !keep.has(this.keyOf(row, keys))))
+            await writer.delete(row, DeleteEnrichmentStrategy.childrenWhere(writer, enrichment, parent));
+        for (const related of rows)
+            this.hasKey(related, keys) && existing.some((row) => this.keyOf(row, keys) === this.keyOf(related, keys))
+                ? await writer.update(related)
+                : await writer.create(related);
+    }
+    async updateLinked(writer, enrichment, parent) {
+        const association = enrichment.association;
+        if (!association)
+            throw new DatasourceError("Missing association");
+        const parentKey = this.requiredKey(parent, enrichment);
+        const existing = await DeleteEnrichmentStrategy.loadLinks(writer, association.parent, parentKey);
+        const wanted = this.relatedIds(parent, enrichment);
+        const keep = new Set(wanted.map((id) => String(id)));
+        for (const row of existing) {
+            const id = this.getCell(row, association.related);
+            if (this.presentCell(id) && keep.has(String(id)))
+                continue;
+            if (!this.presentCell(id))
+                continue;
+            await writer.delete(row, this.linkWhere(association, parentKey, id));
+        }
+        for (const id of wanted) {
+            if (existing.some((row) => String(this.getCell(row, association.related) ?? "") === String(id)))
+                continue;
+            await writer.create({ [association.parent]: parentKey, [association.related]: id });
+        }
+    }
+}