@deterministic-code/datasources 0.1.0 → 0.1.2

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

@@ -0,0 +1,7 @@
+import { CreateEnrichmentStrategy } from "./CreateEnrichmentStrategy.js";
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+export declare class DefaultCreateEnrichmentStrategy<T> extends CreateEnrichmentStrategy<T> {
+    createChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    createLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+}

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

@@ -0,0 +1,19 @@
+import type { Scalar } from "./builders/Scalar.js";
+import type { Enrichment } from "./Enrichment.js";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { Row } from "./Row.js";
+type Props = Record<string, Scalar | object>;
+export declare class DefaultReadonlyEnrichmentStrategy<T extends object> implements IReadonlyEnrichmentStrategy<T> {
+    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>;
+    protected applyObject<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    protected applyList<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    protected applyDictionary<TRelated extends object>(via: IReadonlyRepository<TRelated>, enrichment: Enrichment, parents: T[], sources?: (Row | undefined)[]): Promise<void>;
+    protected sourceKey(parent: T, name: string, sources: (Row | undefined)[] | undefined, index: number): Scalar | object | undefined;
+    protected props: <TItem>(item: TItem) => Props;
+    protected keyOf: (key: Scalar | object) => string;
+    protected lookupKey: (value: Scalar | object | undefined) => Scalar | object | undefined;
+    protected scalar: (value: Scalar | object) => Scalar;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+export declare class DefaultUpdateEnrichmentStrategy<T> extends UpdateEnrichmentStrategy<T> {
+    updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    updateLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+}

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

package/dist/DefaultWriteEnrichmentStrategy.d.ts

@@ -0,0 +1,21 @@
+import type { CreateEnrichmentStrategy } from "./CreateEnrichmentStrategy.js";
+import type { IRepositoryTree } from "./IRepositoryTree.js";
+import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.js";
+import type { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import type { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+import type { WriteMode } from "./WriteMode.js";
+export declare class DefaultWriteEnrichmentStrategy<T> implements IWriteEnrichmentStrategy<T> {
+    protected skipUnloaded: boolean;
+    readonly useTransaction: boolean;
+    private readonly createStrategy;
+    private readonly deleteStrategy;
+    private readonly updateStrategy;
+    constructor(deleteStrategy?: DeleteEnrichmentStrategy<T>, updateStrategy?: UpdateEnrichmentStrategy<T>, createStrategy?: CreateEnrichmentStrategy<T>, useTransaction?: boolean);
+    persist: (tree: IRepositoryTree, items: T[], mode: WriteMode) => Promise<void>;
+    persistBulk: (tree: IRepositoryTree, items: T[], mode: WriteMode) => Promise<void>;
+    private walk;
+    private walkBulk;
+    private persistEntryBulk;
+    private persistEntry;
+    private skip;
+}

package/dist/DefaultWriteEnrichmentStrategy.js

@@ -0,0 +1,135 @@
+import { CascadeDeleteEnrichmentStrategy } from "./CascadeDeleteEnrichmentStrategy.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.js";
+import { EnrichmentPropertyType } from "./EnrichmentPropertyType.js";
+import { DefaultUpdateEnrichmentStrategy } from "./DefaultUpdateEnrichmentStrategy.js";
+import { enrichmentsOf } from "./ReadonlyRepository.js";
+const unloaded = (parent, into) => {
+    const value = parent[into];
+    return value === undefined || value === null;
+};
+const childWriter = (entry, into) => {
+    if (entry.persist)
+        return entry.persist;
+    throw new DatasourceError(`Deep write requires a CRUD repository for "${into}"`);
+};
+const linkWriter = (entry, into) => {
+    if (entry.link)
+        return entry.link;
+    throw new DatasourceError(`Deep write requires a CRUD repository for "${into}"`);
+};
+const dispatch = (mode, runs) => (runs[mode] ??
+    (() => {
+        throw new DatasourceError("Unknown persist mode");
+    }))();
+export class DefaultWriteEnrichmentStrategy {
+    skipUnloaded = false;
+    useTransaction;
+    createStrategy;
+    deleteStrategy;
+    updateStrategy;
+    constructor(deleteStrategy = new CascadeDeleteEnrichmentStrategy(), updateStrategy = new DefaultUpdateEnrichmentStrategy(), createStrategy = new DefaultCreateEnrichmentStrategy(), useTransaction = false) {
+        this.deleteStrategy = deleteStrategy;
+        this.updateStrategy = updateStrategy;
+        this.createStrategy = createStrategy;
+        this.useTransaction = useTransaction;
+    }
+    persist = async (tree, items, mode) => {
+        await this.walk(tree.parent.value, items, mode);
+    };
+    persistBulk = async (tree, items, mode) => {
+        if (mode === "delete")
+            return this.persist(tree, items, mode);
+        await this.walkBulk(tree.parent.value, items, mode);
+    };
+    walk = async (host, parents, mode) => {
+        const entries = enrichmentsOf(host);
+        if (!entries)
+            return;
+        for (const entry of entries)
+            await this.persistEntry(entry, parents, mode);
+    };
+    walkBulk = async (host, parents, mode) => {
+        const entries = enrichmentsOf(host);
+        if (!entries)
+            return;
+        for (const entry of entries)
+            await this.persistEntryBulk(entry, parents, mode);
+    };
+    persistEntryBulk = async (entry, parents, mode) => {
+        const enrichment = entry.enrichment;
+        const type = enrichment.type ?? EnrichmentPropertyType.Object;
+        if (type === EnrichmentPropertyType.Custom)
+            throw new DatasourceError(`Unsupported enrichment type "${type}"`);
+        if (enrichment.association) {
+            const writer = linkWriter(entry, enrichment.destinationProperty);
+            for (const parent of parents) {
+                if (this.skip(parent, enrichment.destinationProperty, mode))
+                    continue;
+                await dispatch(mode, {
+                    create: () => this.createStrategy.createLinked(writer, enrichment, parent),
+                    update: () => this.updateStrategy.updateLinked(writer, enrichment, parent),
+                    delete: () => this.deleteStrategy.deleteLinked(writer, enrichment, parent),
+                });
+            }
+            return;
+        }
+        if (type === EnrichmentPropertyType.List && enrichment.relatedProperty)
+            return;
+        if (type !== EnrichmentPropertyType.List && type !== EnrichmentPropertyType.Dictionary)
+            return;
+        const writer = childWriter(entry, enrichment.destinationProperty);
+        const ready = parents.filter((parent) => !this.skip(parent, enrichment.destinationProperty, mode));
+        const children = ready.flatMap((parent) => this.createStrategy.collectChildren(writer, enrichment, parent));
+        if (children.length === 0)
+            return;
+        const bulk = writer;
+        if (mode === "create") {
+            if (bulk.createBulk)
+                await bulk.createBulk(children);
+            else
+                for (const child of children)
+                    await writer.create(child);
+            return;
+        }
+        if (bulk.updateBulk)
+            await bulk.updateBulk(children);
+        else
+            for (const child of children)
+                await writer.update(child);
+    };
+    persistEntry = async (entry, parents, mode) => {
+        const enrichment = entry.enrichment;
+        const type = enrichment.type ?? EnrichmentPropertyType.Object;
+        if (type === EnrichmentPropertyType.Custom)
+            throw new DatasourceError(`Unsupported enrichment type "${type}"`);
+        if (enrichment.association) {
+            const writer = linkWriter(entry, enrichment.destinationProperty);
+            for (const parent of parents) {
+                if (this.skip(parent, enrichment.destinationProperty, mode))
+                    continue;
+                await dispatch(mode, {
+                    create: () => this.createStrategy.createLinked(writer, enrichment, parent),
+                    update: () => this.updateStrategy.updateLinked(writer, enrichment, parent),
+                    delete: () => this.deleteStrategy.deleteLinked(writer, enrichment, parent),
+                });
+            }
+            return;
+        }
+        if (type === EnrichmentPropertyType.List && enrichment.relatedProperty)
+            return;
+        if (type !== EnrichmentPropertyType.List && type !== EnrichmentPropertyType.Dictionary)
+            return;
+        const writer = childWriter(entry, enrichment.destinationProperty);
+        for (const parent of parents) {
+            if (this.skip(parent, enrichment.destinationProperty, mode))
+                continue;
+            await dispatch(mode, {
+                create: () => this.createStrategy.createChildren(writer, enrichment, parent),
+                update: () => this.updateStrategy.updateChildren(writer, enrichment, parent),
+                delete: () => this.deleteStrategy.deleteChildren(writer, enrichment, parent, async () => { }),
+            });
+        }
+    };
+    skip = (parent, into, mode) => this.skipUnloaded && mode !== "delete" && unloaded(parent, into);
+}

package/dist/DeleteEnrichmentStrategy.d.ts

@@ -0,0 +1,11 @@
+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 DeleteEnrichmentStrategy<T> {
+    abstract deleteChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T, deleteNested: (rows: TChild[]) => Promise<void>): Promise<void>;
+    abstract deleteLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    static load: <TParent, TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: TParent) => Promise<TChild[]>;
+    static childrenWhere: <TParent, TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: TParent) => Where | undefined;
+    static loadLinks: <TChild extends object>(writer: ICRUDRepository<TChild>, column: string, key: Scalar) => Promise<TChild[]>;
+}

package/dist/DeleteEnrichmentStrategy.js

@@ -0,0 +1,28 @@
+import { Operator, Where } from "./statements/index.js";
+const get = (item, name) => item[name];
+export class DeleteEnrichmentStrategy {
+    static load = async (writer, enrichment, parent) => {
+        const key = get(parent, enrichment.sourceProperty);
+        if (key === undefined || key === null || typeof key === "object")
+            return [];
+        const items = [];
+        for await (const item of writer.read(new Where(new Operator.Equals(enrichment.relatedKey, key))))
+            items.push(item);
+        return items;
+    };
+    static childrenWhere = (writer, enrichment, parent) => {
+        if (writer.ids.length > 0)
+            return undefined;
+        const key = get(parent, enrichment.sourceProperty);
+        return key === undefined || key === null || typeof key === "object"
+            ? undefined
+            : new Where(new Operator.Equals(enrichment.relatedKey, key));
+    };
+    static loadLinks = async (writer, column, key) => {
+        const items = [];
+        for await (const item of writer.read(new Where(new Operator.Equals(column, key))))
+            items.push(item);
+        return items;
+    };
+}
+;

package/dist/DriverLoader.d.ts

@@ -0,0 +1,5 @@
+import type { IDriver } from "./IDriver.js";
+import type { ProviderCatalog } from "./ProviderCatalog.js";
+export declare class DriverLoader {
+    static load: (catalog: ProviderCatalog) => IDriver;
+}

package/dist/DriverLoader.js

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+import { createRequire, registerHooks } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { ProviderNotInstalledError } from "./ProviderNotInstalledError.js";
+const require = createRequire(import.meta.url);
+const appRequire = () => createRequire(join(process.cwd(), "package.json"));
+const virtual = new Map();
+const virtualBySource = new Map();
+let typeScriptHook = false;
+let compiling = false;
+let nextVirtual = 0;
+const installTypeScriptHook = () => {
+    if (typeScriptHook)
+        return;
+    const typescript = require("typescript");
+    /* v8 ignore start */
+    registerHooks({
+        resolve: (specifier, context, nextResolve) => {
+            const parentURL = context.parentURL ? virtual.get(context.parentURL) ?? context.parentURL : undefined;
+            const resolved = nextResolve(specifier, parentURL ? { ...context, parentURL } : context);
+            /* v8 ignore next */
+            if (!compiling || !resolved.url.endsWith(".ts"))
+                return resolved;
+            const existing = virtualBySource.get(resolved.url);
+            /* v8 ignore next */
+            if (existing)
+                return { url: existing, shortCircuit: true };
+            const url = pathToFileURL(`${tmpdir()}/datasources-plugin-${nextVirtual++}.mjs`).href;
+            virtual.set(url, resolved.url);
+            virtualBySource.set(resolved.url, url);
+            return { url, shortCircuit: true };
+        },
+        load: (url, context, nextLoad) => {
+            const original = virtual.get(url) ?? (compiling && url.endsWith(".ts") ? url : undefined);
+            /* v8 ignore next */
+            if (!original)
+                return nextLoad(url, context);
+            const filename = fileURLToPath(original);
+            const source = typescript.transpileModule(readFileSync(filename, "utf8"), {
+                compilerOptions: {
+                    module: typescript.ModuleKind.ESNext,
+                    target: typescript.ScriptTarget.ES2022,
+                },
+                fileName: filename,
+            }).outputText;
+            return { format: "module", source, shortCircuit: true };
+        },
+    });
+    /* v8 ignore stop */
+    typeScriptHook = true;
+};
+const instantiate = (catalog) => {
+    compiling = true;
+    try {
+        return instantiateLoaded(catalog);
+    }
+    finally {
+        compiling = false;
+    }
+};
+const instantiateLoaded = (catalog) => {
+    const loaded = appRequire()(catalog.location);
+    const Type = loaded[catalog.module];
+    if (typeof Type !== "function")
+        throw new ProviderNotInstalledError(catalog.name);
+    return new Type();
+};
+export class DriverLoader {
+    static load = (catalog) => {
+        try {
+            return instantiate(catalog);
+        }
+        catch (error) {
+            if (error instanceof ProviderNotInstalledError)
+                throw error;
+            try {
+                installTypeScriptHook();
+                return instantiate(catalog);
+            }
+            catch {
+                throw new ProviderNotInstalledError(catalog.name);
+            }
+        }
+    };
+}