@deterministic-code/datasources 0.1.12 → 0.1.15

package/dist/BatchCommandIBulkWriteStrategy.js

@@ -83,7 +83,7 @@ export class BatchCommandIBulkWriteStrategy {
         return { result: null, rowsAffected };
     };
     mappedInsert = (item) => {
-        const record = this.reverse(item);
+        const record = this.repo.fillCreateZeros(this.reverse(item));
         const statement = this.statements().insert(this.fields(record, (col) => listed(this.options.createProperties, col, !this.ids.includes(col) || assigned(record[col] ?? null))));
         return { table: statement.table, fields: statement.fields };
     };

package/dist/BulkCRUDRepository.js

@@ -10,6 +10,8 @@ const isBulkStrategy = (value) => "create" 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 (!connection.isOpen)
+        await connection.open();
     if (!transactional)
         return write();
     const work = new UnitOfWorkTransaction(connection);

package/dist/CRUDRepository.d.ts

@@ -14,6 +14,7 @@ export declare class CRUDRepository<T = Cells> extends ReadonlyRepository<T> imp
     readonly ids: readonly string[];
     private readonly createProperties?;
     private readonly updateProperties?;
+    protected createZeros?: Cells;
     private readonly crudStatements;
     private readonly tree;
     private readonly write;
@@ -36,6 +37,7 @@ export declare class CRUDRepository<T = Cells> extends ReadonlyRepository<T> imp
     private save;
     private remove;
     private byId;
+    fillCreateZeros: (record: Cells) => Cells;
     private reverseConvert;
     private idWhere;
     protected enrichmentInto: (name: string) => boolean;

package/dist/CRUDRepository.js

@@ -6,6 +6,7 @@ import { enrichmentsOf, ReadonlyRepository } from "./ReadonlyRepository.js";
 import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
 import { execute, executeReader } from "./ICommand.js";
 import { DatasourceError } from "./DatasourceError.js";
+import { lookupKeys, mergeLookups } from "./CreateEnrichmentStrategy.js";
 import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.js";
 import { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.js";
 import { RepositoryTree } from "./RepositoryTree.js";
@@ -13,10 +14,9 @@ import { RepositoryTreeNode } from "./RepositoryTreeNode.js";
 const assigned = (value) => value !== null && value !== "" && value !== 0 && value !== 0n;
 const listed = (list, col, fallback) => list === undefined ? fallback : list.includes(col);
 const writable = (key, columns, column) => columns.length === 0 || columns.includes(key) || columns.some((name) => column(name) === key);
-const fieldsOf = (record, include, cell, enrichmentInto, columns, column) => Object.entries(record)
+const fieldsOf = (record, include, extras, cell, enrichmentInto, columns, column) => Object.entries(record)
     .filter(([key, value]) => include(key) &&
-    writable(key, columns, column) &&
-    !enrichmentInto(key) &&
+    (extras.has(key) || (writable(key, columns, column) && !enrichmentInto(key))) &&
     value !== null &&
     value !== undefined)
     .sort(([left], [right]) => left.localeCompare(right))
@@ -37,6 +37,7 @@ export class CRUDRepository extends ReadonlyRepository {
     ids;
     createProperties;
     updateProperties;
+    createZeros;
     crudStatements;
     tree;
     write;
@@ -56,9 +57,11 @@ export class CRUDRepository extends ReadonlyRepository {
     }
     addEnriched(enrichment, via, strategy) {
         super.addEnriched(enrichment, via, strategy);
+        const stored = lastEnrichment(this);
+        stored.via = via;
         const writer = writerOf(via);
         if (writer)
-            lastEnrichment(this).persist = writer;
+            stored.persist = writer;
         return this;
     }
     addLinked(enrichment, via, link, strategy) {
@@ -73,9 +76,12 @@ export class CRUDRepository extends ReadonlyRepository {
     update = (item, byWhere) => this.inTransaction(() => this.updateCore(item, byWhere));
     delete = (item, byWhere) => this.inTransaction(() => this.deleteCore(item, byWhere));
     inTransaction = async (write) => {
+        const connection = this.command().connection;
+        if (!connection.isOpen)
+            await connection.open();
         if (!this.useTransaction)
             return write();
-        const work = new UnitOfWorkTransaction(this.command().connection);
+        const work = new UnitOfWorkTransaction(connection);
         await work.begin();
         try {
             const result = await write();
@@ -88,6 +94,7 @@ export class CRUDRepository extends ReadonlyRepository {
         }
     };
     createCore = async (item) => {
+        await this.write.resolveLookups?.(this.tree, [item]);
         await this.insert(item);
         if (!this.enriched)
             return item;
@@ -98,6 +105,7 @@ export class CRUDRepository extends ReadonlyRepository {
         return id === undefined ? item : (await this.readSingleById(id)) ?? item;
     };
     updateCore = async (item, byWhere) => {
+        await this.write.resolveLookups?.(this.tree, [item]);
         const response = await this.save(item, byWhere);
         if (this.enriched)
             await this.write.persist(this.tree, [item], "update");
@@ -110,8 +118,9 @@ export class CRUDRepository extends ReadonlyRepository {
     };
     readSingleById = async (id) => this.readSingle(this.byId(id));
     insert = async (item) => {
-        const record = this.reverseConvert(item);
-        const fields = fieldsOf(record, (col) => listed(this.createProperties, col, !this.ids.includes(col) || assigned(record[col] ?? null)), this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column);
+        const extras = lookupKeys(item);
+        const record = this.fillCreateZeros(this.reverseConvert(item));
+        const fields = fieldsOf(record, (col) => extras.has(col) || listed(this.createProperties, col, !this.ids.includes(col) || assigned(record[col] ?? null)), extras, this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column);
         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]))
@@ -145,8 +154,9 @@ export class CRUDRepository extends ReadonlyRepository {
     };
     idValue = (item) => scalarOf(item[this.ids[0]]);
     save = async (item, byWhere) => {
+        const extras = lookupKeys(item);
         const record = this.reverseConvert(item);
-        const fields = fieldsOf(record, (col) => listed(this.updateProperties, col, !this.ids.includes(col)), this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column);
+        const fields = fieldsOf(record, (col) => extras.has(col) || listed(this.updateProperties, col, !this.ids.includes(col)), extras, this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column);
         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));
@@ -159,7 +169,7 @@ export class CRUDRepository extends ReadonlyRepository {
         const parameters = listed.length
             ? listed
             : DefaultStatementTextRenderer.instance.render(statement).includes("$")
-                ? fieldsOf(record, () => true, this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column)
+                ? fieldsOf(record, () => true, new Set(), this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column)
                 : [];
         return execute(this.command(), statement, parameters);
     };
@@ -172,9 +182,12 @@ export class CRUDRepository extends ReadonlyRepository {
             throw new DatasourceError("Composite id requires a row keyed by each Id column");
         return this.idWhere({ [this.ids[0]]: id });
     };
+    fillCreateZeros = (record) => this.createZeros === undefined ? record : { ...this.createZeros, ...record };
     reverseConvert = (item) => {
         const row = this.objectConverter.reverseConvert(item);
-        return this.rowConverter ? this.rowConverter.reverseConvert(row) : row;
+        const converted = this.rowConverter ? this.rowConverter.reverseConvert(row) : row;
+        mergeLookups(item, converted);
+        return converted;
     };
     idWhere = (record) => {
         const parts = this.ids.map((col) => {

package/dist/CreateEnrichmentStrategy.d.ts

@@ -1,13 +1,20 @@
 import type { Enrichment } from "./Enrichment.js";
 import type { ICRUDRepository } from "./ICRUDRepository.js";
 import type { Scalar } from "./builders/Scalar.js";
+import type { Cells } from "./converters/Cell.js";
+import type { StoredEnrichment } from "./StoredEnrichment.js";
+export declare const mergeLookups: (item: object, record: Cells) => void;
+export declare const lookupKeys: (item: object) => Set<string>;
 export declare abstract class CreateEnrichmentStrategy<T> {
     abstract createChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
     abstract createLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
-    collectChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): TChild[];
+    resolveLookups(entries: readonly StoredEnrichment<T>[], items: T[]): Promise<void>;
+    collectChildren<TChild extends object>(_writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): TChild[];
+    protected keyOf: (value: Scalar | object | undefined) => Scalar | object | undefined;
     protected getCell: <TItem>(item: TItem, name: string) => Scalar | object | undefined;
     protected presentCell: (value: Scalar | object | undefined) => value is Scalar;
     protected payloadOf: <TChild extends object, TParent>(parent: TParent, into: string, enrichment?: Enrichment) => TChild[];
+    protected stamp: <TItem extends object>(related: TItem, by: string, key: Scalar | object | undefined) => void;
     protected stampCell: <TItem extends object>(related: TItem, by: string, key: Scalar | object | undefined) => void;
     protected relatedIds: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar[];
     protected requiredKey: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar;

package/dist/CreateEnrichmentStrategy.js

@@ -1,6 +1,38 @@
 import { DatasourceError } from "./DatasourceError.js";
+import { Operator, Where } from "./statements/index.js";
+const lookups = new WeakMap();
+export const mergeLookups = (item, record) => {
+    const extras = lookups.get(item);
+    if (extras)
+        Object.assign(record, extras);
+};
+export const lookupKeys = (item) => new Set(Object.keys(lookups.get(item) ?? {}));
 export class CreateEnrichmentStrategy {
-    collectChildren(writer, enrichment, parent) {
+    async resolveLookups(entries, items) {
+        for (const item of items) {
+            for (const entry of entries) {
+                const { enrichment } = entry;
+                if ((enrichment.type ?? "object") !== "object" || enrichment.association || !enrichment.relatedProperty)
+                    continue;
+                const name = this.getCell(item, enrichment.destinationProperty);
+                if (!this.presentCell(name))
+                    continue;
+                if (this.presentCell(this.keyOf(this.getCell(item, enrichment.sourceProperty))))
+                    continue;
+                const via = entry.via ?? entry.persist;
+                if (!via)
+                    continue;
+                const found = await via.readSingle(new Where(new Operator.Equals(enrichment.relatedProperty, name)));
+                if (!found)
+                    throw new DatasourceError(`Unknown ${enrichment.destinationProperty} "${String(name)}"`);
+                const id = this.getCell(found, enrichment.relatedKey);
+                if (!this.presentCell(id))
+                    throw new DatasourceError(`Unknown ${enrichment.destinationProperty} "${String(name)}"`);
+                this.stamp(item, enrichment.sourceProperty, id);
+            }
+        }
+    }
+    collectChildren(_writer, enrichment, parent) {
         const children = this.payloadOf(parent, enrichment.destinationProperty, enrichment);
         if (children.length === 0)
             return children;
@@ -9,10 +41,16 @@ export class CreateEnrichmentStrategy {
             this.stampCell(child, enrichment.relatedKey, key);
         return children;
     }
+    keyOf = (value) => {
+        if (value === undefined || value === null || typeof value !== "object")
+            return value;
+        const id = value.Id ?? value.id;
+        return id === undefined || typeof id === "object" ? undefined : id;
+    };
     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) => {
+    stamp = (related, by, key) => {
         if (key === undefined || key === null || typeof key === "object")
             return;
         const current = this.getCell(related, by);
@@ -22,8 +60,15 @@ export class CreateEnrichmentStrategy {
             target[id] = key;
             return;
         }
-        Object.assign(related, { [by]: key });
+        if (by in related) {
+            Object.assign(related, { [by]: key });
+            return;
+        }
+        const extras = lookups.get(related) ?? {};
+        extras[by] = key;
+        lookups.set(related, extras);
     };
+    stampCell = (related, by, key) => this.stamp(related, by, key);
     relatedIds = (parent, enrichment) => {
         const ids = [];
         const seen = new Set();

package/dist/DefaultWriteEnrichmentStrategy.d.ts

@@ -11,6 +11,7 @@ export declare class DefaultWriteEnrichmentStrategy<T> implements IWriteEnrichme
     private readonly deleteStrategy;
     private readonly updateStrategy;
     constructor(deleteStrategy?: DeleteEnrichmentStrategy<T>, updateStrategy?: UpdateEnrichmentStrategy<T>, createStrategy?: CreateEnrichmentStrategy<T>, useTransaction?: boolean);
+    resolveLookups: (tree: IRepositoryTree, items: T[]) => Promise<void>;
     persist: (tree: IRepositoryTree, items: T[], mode: WriteMode) => Promise<void>;
     persistBulk: (tree: IRepositoryTree, items: T[], mode: WriteMode) => Promise<void>;
     private walk;

package/dist/DefaultWriteEnrichmentStrategy.js

@@ -8,14 +8,15 @@ const unloaded = (parent, into) => {
     const value = parent[into];
     return value === undefined || value === null;
 };
+const asRelated = (writer) => writer;
 const childWriter = (entry, into) => {
     if (entry.persist)
-        return entry.persist;
+        return asRelated(entry.persist);
     throw new DatasourceError(`Deep write requires a CRUD repository for "${into}"`);
 };
 const linkWriter = (entry, into) => {
     if (entry.link)
-        return entry.link;
+        return asRelated(entry.link);
     throw new DatasourceError(`Deep write requires a CRUD repository for "${into}"`);
 };
 const dispatch = (mode, runs) => (runs[mode] ??
@@ -34,6 +35,11 @@ export class DefaultWriteEnrichmentStrategy {
         this.createStrategy = createStrategy;
         this.useTransaction = useTransaction;
     }
+    resolveLookups = async (tree, items) => {
+        const entries = enrichmentsOf(tree.parent.value);
+        if (entries)
+            await this.createStrategy.resolveLookups(entries, items);
+    };
     persist = async (tree, items, mode) => {
         await this.walk(tree.parent.value, items, mode);
     };

package/dist/DriverLoader.d.ts

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

package/dist/DriverLoader.js

@@ -1,118 +1,15 @@
-import { readFileSync } from "node:fs";
-import { createRequire, registerHooks } from "node:module";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { join } from "node:path";
 import { ProviderNotInstalledError } from "./ProviderNotInstalledError.js";
-const require = createRequire(import.meta.url);
-const requirers = () => [
-    createRequire(join(process.cwd(), "package.json")),
-    ...(process.argv[1] ? [createRequire(process.argv[1])] : []),
-    require,
-];
-const missingModule = (error) => error instanceof Error &&
-    "code" in error &&
-    (error.code === "MODULE_NOT_FOUND" ||
-        error.code === "ERR_MODULE_NOT_FOUND" ||
-        error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED");
-const virtual = new Map();
-const virtualBySource = new Map();
-let typeScriptHook = false;
-let compiling = false;
-let compilingRoot = "";
-let nextVirtual = 0;
-/* v8 ignore start */
-const underRoot = (url) => {
-    if (!url.startsWith("file:"))
-        return false;
-    const path = fileURLToPath(url);
-    return path === compilingRoot || path.startsWith(`${compilingRoot}/`);
-};
-/* v8 ignore stop */
-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") || !underRoot(resolved.url))
-                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") && underRoot(url) ? 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;
-        compilingRoot = "";
-    }
-};
-const instantiateLoaded = (catalog) => {
-    let last;
-    for (const req of requirers()) {
+export class DriverLoader {
+    static load(catalog) {
         try {
-            compilingRoot = dirname(req.resolve(catalog.location));
-            const loaded = req(catalog.location);
+            const loaded = createRequire(join(process.cwd(), "package.json"))(catalog.location);
             const Type = loaded[catalog.module];
-            if (typeof Type !== "function")
-                throw new ProviderNotInstalledError(catalog.name);
-            return new Type();
+            return typeof Type === "function" ? new Type() : (() => { throw new ProviderNotInstalledError(catalog.name); })();
         }
         catch (error) {
-            last = error;
-            if (error instanceof ProviderNotInstalledError || !missingModule(error))
-                throw error;
+            throw error instanceof ProviderNotInstalledError ? error : new ProviderNotInstalledError(catalog.name);
         }
     }
-    throw last instanceof ProviderNotInstalledError ? last : new ProviderNotInstalledError(catalog.name);
-};
-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);
-            }
-        }
-    };
 }

package/dist/IWriteEnrichmentStrategy.d.ts

@@ -4,4 +4,5 @@ export interface IWriteEnrichmentStrategy<T> {
     readonly useTransaction: boolean;
     persist(tree: IRepositoryTree, items: T[], mode: WriteMode): Promise<void>;
     persistBulk?(tree: IRepositoryTree, items: T[], mode: WriteMode): Promise<void>;
+    resolveLookups?(tree: IRepositoryTree, items: T[]): Promise<void>;
 }

package/dist/ReadonlyRepository.d.ts

@@ -18,7 +18,7 @@ export type Sourced<T> = {
     item: T;
     source?: Row;
 };
-export declare const enrichmentsOf: (host: object) => readonly StoredEnrichment[] | undefined;
+export declare const enrichmentsOf: <T>(host: object) => readonly StoredEnrichment<T>[] | undefined;
 export declare const isBuilt: <T>(value: IConnection | BuiltRepository<T>) => value is BuiltRepository<T>;
 export declare const builtOf: <T>(typeOrConnectionOrBuilt: Constructable<T> | IConnection | BuiltRepository<T>, connectionOrOptions?: IConnection | ReadonlyRepositoryMappingOptions<T>) => BuiltRepository<T> | undefined;
 export declare class ReadonlyRepository<T> implements IReadonlyRepository<T>, IEnriched<T> {
@@ -42,6 +42,7 @@ export declare class ReadonlyRepository<T> implements IReadonlyRepository<T>, IE
     readSingle(query?: ReadQuery, parameters?: Parameter[], options?: ReadonlyRepositoryMappingOptions<T>): Promise<T | undefined>;
     protected get enriched(): boolean;
     protected command: () => ICommand;
+    private ensureOpen;
     protected column: (property: string) => string;
     protected cell: (property: string, value: Cell, fieldsApplied: boolean, options?: ReadonlyRepositoryMappingOptions<T>) => Cell;
     private entries;

package/dist/ReadonlyRepository.js

@@ -56,7 +56,7 @@ export class ReadonlyRepository {
     };
     addEnriched(enrichment, via, strategy) {
         const chosen = strategy ?? new DefaultReadonlyEnrichmentStrategy();
-        this.entries().push(new StoredEnrichment(enrichment, (parents, sources) => chosen.apply(via, enrichment, parents, sources)));
+        this.entries().push(new StoredEnrichment(enrichment, (parents, sources) => chosen.apply(via, enrichment, parents, sources), undefined, undefined, via));
         return this;
     }
     async *read(query, parameters, options) {
@@ -72,6 +72,13 @@ export class ReadonlyRepository {
         return this.entries().length > 0;
     }
     command = () => this.middlewares.reduce((command, middleware) => command.addMiddleware(middleware), this.connection.createCommand());
+    ensureOpen = async () => {
+        const connection = this.connection;
+        if (!connection)
+            throw new DatasourceError("Connection required");
+        if (!connection.isOpen)
+            await connection.open();
+    };
     column = (property) => this.statementMappers.column(property);
     cell = (property, value, fieldsApplied, options) => {
         const objects = options?.objectConverter ?? this.objectConverter;
@@ -107,6 +114,7 @@ export class ReadonlyRepository {
         : objects.convert(row);
     async *readItems(query, parameters, mappers, rows, objects) {
         const statement = query ?? this.readonlyStatements.select();
+        await this.ensureOpen();
         const reader = await executeReader(this.command(), statement, parameters);
         try {
             while (await reader.next()) {

package/dist/StoredEnrichment.d.ts

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

package/dist/StoredEnrichment.js

@@ -3,10 +3,12 @@ export class StoredEnrichment {
     apply;
     persist;
     link;
-    constructor(enrichment, apply, persist, link) {
+    via;
+    constructor(enrichment, apply, persist, link, via) {
         this.enrichment = enrichment;
         this.apply = apply;
         this.persist = persist;
         this.link = link;
+        this.via = via;
     }
 }

package/dist/converters/DefaultValueConverter.js

@@ -131,7 +131,7 @@ export class DefaultValueConverter {
             const match = entry.reverse.exec(native);
             if (match === null)
                 continue;
-            const arg = match[1] ?? "";
+            const arg = match.slice(1).find((group) => group !== undefined) ?? "";
             return entry.specText === undefined ? name : entry.specText(arg);
         }
         throw new Error(`Native default '${native}' is not a valid ${specType} default`);
@@ -148,15 +148,17 @@ export class DefaultValueConverter {
                 String: token(numeric, (arg) => arg, numeric.spec),
             };
         };
+        const quote = opts.quote ?? quoted;
+        const quoteReverse = opts.quoteReverse ?? quotedReverse;
         const quotedString = {
-            String: token(spec.string.String, quoted, quotedReverse),
-            Numeric: token(spec.string.String, quoted, quotedReverse),
+            String: token(spec.string.String, quote, quoteReverse),
+            Numeric: token(spec.string.String, quote, quoteReverse),
         };
         const dictionary = {
             string: quotedString,
             character: {
-                String: token(spec.character.String, quoted, quotedReverse),
-                Numeric: token(spec.character.String, quoted, quotedReverse),
+                String: token(spec.character.String, quote, quoteReverse),
+                Numeric: token(spec.character.String, quote, quoteReverse),
             },
             boolean: {
                 Boolean: token(spec.boolean.Boolean, (arg) => (arg === "true" ? opts.booleanOn : opts.booleanOff), new RegExp(`^(${escapeRe(opts.booleanOn)}|${escapeRe(opts.booleanOff)})$`)),

package/dist/converters/DefaultValueOptions.d.ts

@@ -6,4 +6,6 @@ export type DefaultValueOptions = {
     booleanOff: string;
     hex: (arg: string) => string;
     hexReverse: RegExp;
+    quote?: (arg: string) => string;
+    quoteReverse?: RegExp;
 };

package/dist/statements/ConditionRenderer.js

@@ -6,6 +6,8 @@ export class ConditionRenderer {
     }
     render = (condition) => condition.accept(this);
     visit(where) {
-        return where instanceof Where ? this.expressions.render(where.condition) : where.rawText;
+        return where instanceof Where || where.constructor.name === "Where"
+            ? this.expressions.render(where.condition)
+            : where.rawText;
     }
 }

package/dist/statements/CreateTableStatementTextRenderer.d.ts

@@ -1,6 +1,7 @@
 import type { Column } from "./Column.js";
 import type { CreateTableStatement } from "./CreateTableStatement.js";
 import type { ITableConstraint } from "./ITableConstraint.js";
+import type { NotNull } from "./NotNull.js";
 export declare class CreateTableStatementTextRenderer {
     render(statement: CreateTableStatement): string;
     protected quote(name: string): string;
@@ -11,7 +12,7 @@ export declare class CreateTableStatementTextRenderer {
     protected column(column: Column): string;
     protected constraint(constraint: ITableConstraint): string;
     private parts;
-    private notNullSql;
+    protected notNullSql(value?: NotNull): string;
     private foreignKey;
     private quoted;
     private actionSql;

package/dist/statements/ExpressionRenderer.js

@@ -4,69 +4,70 @@ import { Literal } from "./Literal.js";
 import { Operator } from "./Operator.js";
 import { Subquery } from "./Subquery.js";
 import { Where } from "./Where.js";
+const is = (value, type, name) => value instanceof type || value.constructor.name === name;
 export class ExpressionRenderer {
     text;
     constructor(text) {
         this.text = text;
     }
     render = (expression) => {
-        if (expression instanceof Where)
+        if (is(expression, Where, "Where"))
             return this.render(expression.condition);
-        if (expression instanceof Identifier)
+        if (is(expression, Identifier, "Identifier"))
             return expression.name;
-        if (expression instanceof Literal)
+        if (is(expression, Literal, "Literal"))
             return inline(expression.value);
-        if (expression instanceof ArrayExpression)
+        if (is(expression, ArrayExpression, "ArrayExpression"))
             return expression.elements.map((e) => this.render(e)).join(", ");
-        if (expression instanceof Operator.Not)
+        if (is(expression, Operator.Not, "Not"))
             return `NOT (${this.render(expression.argument)})`;
-        if (expression instanceof Operator.IsNull)
+        if (is(expression, Operator.IsNull, "IsNull"))
             return `${this.render(expression.argument)} IS NULL`;
-        if (expression instanceof Operator.IsNotNull)
+        if (is(expression, Operator.IsNotNull, "IsNotNull"))
             return `${this.render(expression.argument)} IS NOT NULL`;
-        if (expression instanceof Operator.Exists)
+        if (is(expression, Operator.Exists, "Exists"))
             return `EXISTS ${this.render(expression.argument)}`;
-        if (expression instanceof Subquery)
+        if (is(expression, Subquery, "Subquery"))
             return `(${this.text.render(expression.query)})`;
-        if (expression instanceof Operator.In &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof ArrayExpression)
+        if (is(expression, Operator.In, "In") &&
+            is(expression.left, Identifier, "Identifier") &&
+            is(expression.right, ArrayExpression, "ArrayExpression"))
             return expression.right.elements.length === 0
                 ? "1 = 0"
                 : `${expression.left.name} IN (${slots(expression.left.name, expression.right.elements.length)})`;
-        if (expression instanceof Operator.In &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof Subquery)
+        if (is(expression, Operator.In, "In") &&
+            is(expression.left, Identifier, "Identifier") &&
+            is(expression.right, Subquery, "Subquery"))
             return `${expression.left.name} IN ${this.render(expression.right)}`;
-        if (expression instanceof Operator.NotIn &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof ArrayExpression)
+        if (is(expression, Operator.NotIn, "NotIn") &&
+            is(expression.left, Identifier, "Identifier") &&
+            is(expression.right, ArrayExpression, "ArrayExpression"))
             return expression.right.elements.length === 0
                 ? "1 = 1"
                 : `${expression.left.name} NOT IN (${slots(expression.left.name, expression.right.elements.length)})`;
-        if (expression instanceof Operator.NotIn &&
-            expression.left instanceof Identifier &&
-            expression.right instanceof Subquery)
+        if (is(expression, Operator.NotIn, "NotIn") &&
+            is(expression.left, Identifier, "Identifier") &&
+            is(expression.right, Subquery, "Subquery"))
             return `${expression.left.name} NOT IN ${this.render(expression.right)}`;
-        if ((expression instanceof Operator.Between || expression instanceof Operator.NotBetween) &&
-            expression.value instanceof Identifier &&
-            expression.low instanceof Literal &&
-            expression.high instanceof Literal) {
-            const word = expression instanceof Operator.NotBetween ? "NOT BETWEEN" : "BETWEEN";
+        if ((is(expression, Operator.Between, "Between") || is(expression, Operator.NotBetween, "NotBetween")) &&
+            is(expression.value, Identifier, "Identifier") &&
+            is(expression.low, Literal, "Literal") &&
+            is(expression.high, Literal, "Literal")) {
+            const word = is(expression, Operator.NotBetween, "NotBetween") ? "NOT BETWEEN" : "BETWEEN";
             return `${expression.value.name} ${word} $${parameterName(expression.value.name)}_0 AND $${parameterName(expression.value.name)}_1`;
         }
-        if (expression instanceof Operator.Between)
+        if (is(expression, Operator.Between, "Between"))
             return `${this.render(expression.value)} BETWEEN ${this.render(expression.low)} AND ${this.render(expression.high)}`;
-        if (expression instanceof Operator.NotBetween)
+        if (is(expression, Operator.NotBetween, "NotBetween"))
             return `${this.render(expression.value)} NOT BETWEEN ${this.render(expression.low)} AND ${this.render(expression.high)}`;
-        if (expression instanceof Operator.And)
+        if (is(expression, Operator.And, "And"))
             return `${this.wrap(expression.left, true)} AND ${this.wrap(expression.right, true)}`;
-        if (expression instanceof Operator.Or)
+        if (is(expression, Operator.Or, "Or"))
             return `${this.wrap(expression.left, false)} OR ${this.wrap(expression.right, false)}`;
-        const operands = expression instanceof Operator ? pair(expression) : undefined;
-        if (operands && operands.left instanceof Identifier && operands.right instanceof Literal)
+        const operands = pair(expression);
+        if (operands && is(operands.left, Identifier, "Identifier") && is(operands.right, Literal, "Literal"))
             return `${operands.left.name} ${symbol(expression)} $${parameterName(operands.left.name)}`;
-        if (operands && operands.left instanceof Literal && operands.right instanceof Literal)
+        if (operands && is(operands.left, Literal, "Literal") && is(operands.right, Literal, "Literal"))
             return `${inline(operands.left.value)} ${symbol(expression)} ${inline(operands.right.value)}`;
         if (operands)
             return `${this.render(operands.left)} ${symbol(expression)} ${this.render(operands.right)}`;
@@ -74,23 +75,34 @@ export class ExpressionRenderer {
     };
     wrap = (child, and) => needsParens(child, and) ? `(${this.render(child)})` : this.render(child);
 }
-const symbol = (op) => op instanceof Operator.Equals
-    ? "="
-    : op instanceof Operator.NotEquals
-        ? "<>"
-        : op instanceof Operator.GreaterThan
-            ? ">"
-            : op instanceof Operator.LessThan
-                ? "<"
-                : op instanceof Operator.GreaterThanOrEqual
-                    ? ">="
-                    : op instanceof Operator.LessThanOrEqual
-                        ? "<="
-                        : op instanceof Operator.Like
-                            ? "LIKE"
-                            : op instanceof Operator.NotLike
-                                ? "NOT LIKE"
-                                : "IN";
+const symbols = {
+    Equals: "=",
+    NotEquals: "<>",
+    GreaterThan: ">",
+    LessThan: "<",
+    GreaterThanOrEqual: ">=",
+    LessThanOrEqual: "<=",
+    Like: "LIKE",
+    NotLike: "NOT LIKE",
+};
+const symbol = (op) => symbols[op.constructor.name] ??
+    (is(op, Operator.Equals, "Equals")
+        ? "="
+        : is(op, Operator.NotEquals, "NotEquals")
+            ? "<>"
+            : is(op, Operator.GreaterThan, "GreaterThan")
+                ? ">"
+                : is(op, Operator.LessThan, "LessThan")
+                    ? "<"
+                    : is(op, Operator.GreaterThanOrEqual, "GreaterThanOrEqual")
+                        ? ">="
+                        : is(op, Operator.LessThanOrEqual, "LessThanOrEqual")
+                            ? "<="
+                            : is(op, Operator.Like, "Like")
+                                ? "LIKE"
+                                : is(op, Operator.NotLike, "NotLike")
+                                    ? "NOT LIKE"
+                                    : "IN");
 const inline = (value) => value === null
     ? "null"
     : typeof value === "boolean"
@@ -98,24 +110,24 @@ const inline = (value) => value === null
         : typeof value === "string"
             ? `'${value.replace(/'/g, "''")}'`
             : String(value);
-const needsParens = (child, and) => child instanceof Where
+const needsParens = (child, and) => is(child, Where, "Where")
     ? needsParens(child.condition, and)
-    : child instanceof Operator.Not ||
-        child instanceof Operator.In ||
-        child instanceof Operator.NotIn ||
-        (child instanceof Operator.And && !and) ||
-        (child instanceof Operator.Or && and);
-const pair = (expression) => expression instanceof Operator.Equals ||
-    expression instanceof Operator.NotEquals ||
-    expression instanceof Operator.GreaterThan ||
-    expression instanceof Operator.LessThan ||
-    expression instanceof Operator.GreaterThanOrEqual ||
-    expression instanceof Operator.LessThanOrEqual ||
-    expression instanceof Operator.And ||
-    expression instanceof Operator.Or ||
-    expression instanceof Operator.In ||
-    expression instanceof Operator.Like ||
-    expression instanceof Operator.NotLike
+    : is(child, Operator.Not, "Not") ||
+        is(child, Operator.In, "In") ||
+        is(child, Operator.NotIn, "NotIn") ||
+        (is(child, Operator.And, "And") && !and) ||
+        (is(child, Operator.Or, "Or") && and);
+const pair = (expression) => is(expression, Operator.Equals, "Equals") ||
+    is(expression, Operator.NotEquals, "NotEquals") ||
+    is(expression, Operator.GreaterThan, "GreaterThan") ||
+    is(expression, Operator.LessThan, "LessThan") ||
+    is(expression, Operator.GreaterThanOrEqual, "GreaterThanOrEqual") ||
+    is(expression, Operator.LessThanOrEqual, "LessThanOrEqual") ||
+    is(expression, Operator.And, "And") ||
+    is(expression, Operator.Or, "Or") ||
+    is(expression, Operator.In, "In") ||
+    is(expression, Operator.Like, "Like") ||
+    is(expression, Operator.NotLike, "NotLike")
     ? expression
     : undefined;
 const parameterName = (name) => parts(name)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources",
-  "version": "0.1.12",
+  "version": "0.1.15",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",