@deterministic-code/datasources 0.1.11 → 0.1.14

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.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))
@@ -56,9 +56,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 +75,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 +93,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 +104,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 +117,9 @@ export class CRUDRepository extends ReadonlyRepository {
     };
     readSingleById = async (id) => this.readSingle(this.byId(id));
     insert = async (item) => {
+        const extras = lookupKeys(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 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 +153,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 +168,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);
     };
@@ -174,7 +183,9 @@ export class CRUDRepository extends ReadonlyRepository {
     };
     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/CRUDRepositoryBuilder.d.ts

@@ -12,7 +12,11 @@ export declare const repositoryParts: <T>(typeOrConnection: Constructable<T> | I
     statements: CRUDRepositoryStatements;
 };
 export declare class CRUDRepositoryBuilder<T = object> extends ReadonlyRepositoryBuilder<T> {
+    private readonly factory;
     crudStatements?: CRUDRepositoryStatements;
+    add(options: CRUDRepositoryOptions<T>): this;
+    add(dialect: string, options: CRUDRepositoryOptions<T>): this;
+    for: (connection: IConnection) => CRUDRepositoryOptions<T>;
     protected ids: (options: ReadonlyRepositoryMappingOptions<T>) => string[];
     protected statements: (table: string, columns: string[]) => ReadonlyRepositoryStatements;
     build: (connection: IConnection, options: CRUDRepositoryOptions<T>) => CRUDRepository<T>;

package/dist/CRUDRepositoryBuilder.js

@@ -3,6 +3,7 @@ import { CRUDRepository } from "./CRUDRepository.js";
 import { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.js";
 import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
 import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+import { RepositoryBuilderOptionsFactory } from "./RepositoryBuilderOptionsFactory.js";
 const isCrud = (options) => "ids" in options || "write" in options;
 const withIds = (options) => "ids" in options
     ? options
@@ -18,7 +19,15 @@ export const repositoryParts = (typeOrConnection, connectionOrOptions) => {
     return { built, statements: builder.crudStatements };
 };
 export class CRUDRepositoryBuilder extends ReadonlyRepositoryBuilder {
+    factory = new RepositoryBuilderOptionsFactory();
     crudStatements;
+    add(dialectOrOptions, options) {
+        typeof dialectOrOptions === "string"
+            ? this.factory.add(dialectOrOptions, options)
+            : this.factory.add(dialectOrOptions);
+        return this;
+    }
+    for = (connection) => this.factory.for(connection.provider);
     ids = (options) => isCrud(options)
         ? (options.ids ?? (options.type ? defaultId(fieldNamesOf(options.type)) : ["id"]))
         : [];

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

@@ -0,0 +1,6 @@
+import type { NestedSelectBuilderOptions } from "./NestedSelectBuilderOptions.js";
+import type { NestedSelectStatement } from "./NestedSelectStatement.js";
+import type { NestedSelectType } from "./NestedSelectType.js";
+export declare class NestedSelectBuilder {
+    build(root: NestedSelectType, options?: NestedSelectBuilderOptions): NestedSelectStatement;
+}

package/dist/NestedSelectBuilder.js

@@ -0,0 +1,63 @@
+import { selectFieldAliases } from "./SelectFieldAliases.js";
+import { Join } from "./statements/Join.js";
+import { SelectStatement } from "./statements/SelectStatement.js";
+export class NestedSelectBuilder {
+    build(root, options) {
+        const stopAt = options?.stopAt ?? [];
+        const fields = [];
+        const joins = [];
+        walk(root, root.name, root.name, "", stopAt, false, fields, joins);
+        const aliases = selectFieldAliases(root.name, fields);
+        const byPath = Object.fromEntries(fields.map((field, i) => [field, aliases[i]]));
+        return {
+            select: new SelectStatement({
+                table: root.name,
+                fields,
+                joins,
+                where: options?.where,
+            }),
+            map: mapOf(root, root.name, "", stopAt, byPath),
+        };
+    }
+}
+const walk = (type, fieldPrefix, joinEntity, stopPrefix, stopAt, outer, fields, joins) => {
+    for (const property of type.properties)
+        fields.push(`${fieldPrefix}.${property}`);
+    for (const relation of type.relations) {
+        const path = stopPrefix.length === 0 ? relation.name : `${stopPrefix}.${relation.name}`;
+        if (stopped(stopAt, path))
+            continue;
+        const list = relation.kind === "list";
+        joins.push(list || outer
+            ? Join.left(relation.target.name, `${joinEntity}.${relation.from}`, `${relation.target.name}.${relation.to}`)
+            : Join.inner(relation.target.name, `${joinEntity}.${relation.from}`, `${relation.target.name}.${relation.to}`));
+        walk(relation.target, `${fieldPrefix}.${relation.target.name}`, relation.target.name, path, stopAt, outer || list, fields, joins);
+    }
+};
+const mapOf = (type, fieldPrefix, stopPrefix, stopAt, aliases) => ({
+    key: aliases[`${fieldPrefix}.${type.key}`],
+    fields: fieldsOf(type, fieldPrefix, stopPrefix, stopAt, aliases),
+});
+const fieldsOf = (type, fieldPrefix, stopPrefix, stopAt, aliases) => {
+    const fields = {};
+    for (const property of type.properties) {
+        const alias = aliases[`${fieldPrefix}.${property}`];
+        fields[alias] = alias;
+    }
+    for (const relation of type.relations) {
+        const path = stopPrefix.length === 0 ? relation.name : `${stopPrefix}.${relation.name}`;
+        if (stopped(stopAt, path))
+            continue;
+        const childPrefix = `${fieldPrefix}.${relation.target.name}`;
+        if (relation.kind === "list") {
+            fields[relation.name] = {
+                key: aliases[`${childPrefix}.${relation.target.key}`],
+                fields: fieldsOf(relation.target, childPrefix, path, stopAt, aliases),
+            };
+            continue;
+        }
+        Object.assign(fields, fieldsOf(relation.target, childPrefix, path, stopAt, aliases));
+    }
+    return fields;
+};
+const stopped = (stopAt, path) => stopAt.some((item) => item === path || path.startsWith(`${item}.`));

package/dist/NestedSelectBuilderOptions.d.ts

@@ -0,0 +1,5 @@
+import type { IWhere } from "./statements/IWhere.js";
+export type NestedSelectBuilderOptions = {
+    where?: IWhere;
+    stopAt?: readonly string[];
+};

package/dist/NestedSelectBuilderOptions.js

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

package/dist/NestedSelectRelation.d.ts

@@ -0,0 +1,9 @@
+import type { NestedSelectRelationKind } from "./NestedSelectRelationKind.js";
+import type { NestedSelectType } from "./NestedSelectType.js";
+export type NestedSelectRelation = {
+    name: string;
+    kind: NestedSelectRelationKind;
+    from: string;
+    to: string;
+    target: NestedSelectType;
+};

package/dist/NestedSelectRelation.js

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

package/dist/NestedSelectRelationKind.d.ts

@@ -0,0 +1 @@
+export type NestedSelectRelationKind = "object" | "list";

package/dist/NestedSelectRelationKind.js

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

package/dist/NestedSelectStatement.d.ts

@@ -0,0 +1,10 @@
+import type { TypeMapGroup } from "./mappers/TypeMapGroup.js";
+import type { SelectStatement } from "./statements/SelectStatement.js";
+export type NestedSelectMapField = string | TypeMapGroup<Record<string, string>>;
+export type NestedSelectStatement = {
+    select: SelectStatement;
+    map: {
+        key: string;
+        fields: Record<string, NestedSelectMapField>;
+    };
+};

package/dist/NestedSelectStatement.js

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

package/dist/NestedSelectType.d.ts

@@ -0,0 +1,7 @@
+import type { NestedSelectRelation } from "./NestedSelectRelation.js";
+export type NestedSelectType = {
+    name: string;
+    key: string;
+    properties: readonly string[];
+    relations: readonly NestedSelectRelation[];
+};

package/dist/NestedSelectType.js

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

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

@@ -0,0 +1,8 @@
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+export declare class RepositoryBuilderOptionsFactory<T = object> {
+    private fallback?;
+    private readonly items;
+    add(options: CRUDRepositoryOptions<T>): this;
+    add(dialect: string, options: CRUDRepositoryOptions<T>): this;
+    for: (provider: string) => CRUDRepositoryOptions<T>;
+}

package/dist/RepositoryBuilderOptionsFactory.js

@@ -0,0 +1,12 @@
+import { DatasourceError } from "./DatasourceError.js";
+export class RepositoryBuilderOptionsFactory {
+    fallback;
+    items = new Map();
+    add(dialectOrOptions, options) {
+        typeof dialectOrOptions === "string"
+            ? this.items.set(dialectOrOptions, options)
+            : (this.fallback = dialectOrOptions);
+        return this;
+    }
+    for = (provider) => this.items.get(provider) ?? this.fallback ?? (() => { throw new DatasourceError("repository options required"); })();
+}

package/dist/SelectFieldAliases.d.ts

@@ -0,0 +1,14 @@
+export type PathParts = {
+    owner: string;
+    last: string;
+    root: boolean;
+};
+export declare const selectFieldAliases: (table: string, fields: readonly string[], aliases?: readonly (string | undefined)[]) => (string | undefined)[];
+export declare const applySelectFieldAlias: (field: string, alias?: string) => string;
+export declare const pathOf: (field: string, table: string) => PathParts | undefined;
+export declare const functionOf: (field: string) => {
+    name: string;
+    inner: string;
+} | undefined;
+export declare const asIndexOf: (field: string) => number;
+export declare const segments: (name: string) => string[];