@coffer-org/server 3.2.0 → 3.3.0

package/dist/extend-table.js

@@ -4,9 +4,13 @@ import { encodeJsonAt } from "./mutate.js";
 import { encodeTemporalAt, decodeTemporalAt } from "./temporal.js";
 import { chunk } from "./batch.js";
 import { selectRows } from "./read-rows.js";
+import { injectParts, applyStoredParts } from "./part-injection.js";
 export function extendEntityName(e) {
     return `extend__${e.id}`;
 }
+function extendPartCtx(e, record) {
+    return { record, settings: {}, global: {}, meta: { library: 'extend', shelf: e.id } };
+}
 export async function getExtendRecord(e, baseId, em) {
     const fork = em ?? getEm().fork();
     const name = extendEntityName(e);
@@ -15,7 +19,8 @@ export async function getExtendRecord(e, baseId, em) {
         return undefined;
     const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
     const collections = await readAt(fork, name, e.fields, baseId);
-    return { ...decoded, ...collections };
+    const record = { ...decoded, ...collections };
+    return injectParts(e.fields, record, extendPartCtx(e, record));
 }
 export async function getExtendRecords(e, baseIds, em) {
     const out = new Map();
@@ -34,13 +39,15 @@ export async function getExtendRecords(e, baseIds, em) {
     for (const flat of flats) {
         const id = Number(flat.base_id);
         const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
-        out.set(id, { ...decoded, ...(collectionsById.get(id) ?? {}) });
+        const record = { ...decoded, ...(collectionsById.get(id) ?? {}) };
+        out.set(id, await injectParts(e.fields, record, extendPartCtx(e, record)));
     }
     return out;
 }
 export async function upsertExtendRecord(em, e, baseId, data) {
     const name = extendEntityName(e);
-    const { base, collections } = splitAt(e.fields, data);
+    const withParts = await applyStoredParts(e.fields, data, extendPartCtx(e, data));
+    const { base, collections } = splitAt(e.fields, withParts);
     const flat = encodeJsonAt(e.fields, encodeTemporalAt(e.fields, flattenEmbeddedAt(e.fields, base)));
     await em.upsert(name, { base_id: baseId, ...flat });
     await writeAt(em, name, e.fields, baseId, collections);

package/dist/mutate.js

@@ -9,9 +9,27 @@ import { normalizeFileFields, dropUnchangedFileFields, touchesFileFields } from
 import { notifyRecordsChanged } from "./index-signal.js";
 import { encodeTemporal, decodeTemporal } from "./temporal.js";
 import { splitCollections, writeCollections, deleteCollections, flattenEmbedded, nestEmbedded, readCollections, } from "./collection-io.js";
+import { injectParts, applyStoredParts } from "./part-injection.js";
+const EMPTY_SETTINGS = {};
+const EMPTY_GLOBAL = {};
 function nowIso() {
     return new Date().toISOString();
 }
+function partCtx(m, record) {
+    return {
+        record,
+        settings: EMPTY_SETTINGS,
+        global: EMPTY_GLOBAL,
+        meta: { library: m.library, shelf: m.shelf },
+    };
+}
+async function mergeStoredParts(m, record) {
+    const computed = await applyStoredParts(m.fields, record, partCtx(m, record));
+    if (computed === record)
+        return false;
+    Object.assign(record, computed);
+    return true;
+}
 export function encodeJsonAt(fields, data) {
     const out = { ...data };
     for (const [k, f] of fieldEntries(fields)) {
@@ -67,7 +85,13 @@ export async function getRecord(m, entityName, id, opts = {}) {
     const flat = decodeTemporal(m, row);
     const nested = nestEmbedded(m, flat);
     const collections = await readCollections(fork, m, id);
-    return { ...nested, ...collections };
+    const record = { ...nested, ...collections };
+    return injectParts(m.fields, record, {
+        record,
+        settings: EMPTY_SETTINGS,
+        global: EMPTY_GLOBAL,
+        meta: { library: m.library, shelf: m.shelf },
+    });
 }
 export async function createRecord(m, entityName, input, ctx, afterBase) {
     const parsed = buildZodObject(m).safeParse(input);
@@ -78,6 +102,7 @@ export async function createRecord(m, entityName, input, ctx, afterBase) {
     const fileIssues = normalizeFileFields(m, parsedData);
     if (fileIssues.length)
         throw new ValidationError(fileIssues);
+    await mergeStoredParts(m, parsedData);
     const { base, collections } = splitCollections(m, { ...parsedData });
     const data = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...base, created_at: ts, updated_at: ts })));
     let id;
@@ -88,7 +113,7 @@ export async function createRecord(m, entityName, input, ctx, afterBase) {
         await tx.flush();
         id = entity.id;
         await writeCollections(tx, m, id, collections);
-        const derived = applyDerived(m.fields, { ...parsedData, id });
+        const derived = await applyDerived(m.fields, { ...parsedData, id });
         if (Object.keys(derived).length) {
             await tx.nativeUpdate(entityName, { id }, encodeJson(m, encodeTemporal(m, flattenEmbedded(m, derived))));
             Object.assign(parsedData, derived);
@@ -101,7 +126,13 @@ export async function createRecord(m, entityName, input, ctx, afterBase) {
         });
     });
     notifyRecordsChanged();
-    return { ...parsedData, id, created_at: ts, updated_at: ts };
+    const record = { ...parsedData, id, created_at: ts, updated_at: ts };
+    return injectParts(m.fields, record, {
+        record,
+        settings: EMPTY_SETTINGS,
+        global: EMPTY_GLOBAL,
+        meta: { library: m.library, shelf: m.shelf },
+    });
 }
 export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
     let patch = input;
@@ -146,11 +177,17 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
         }
         if (reqIssues.length)
             throw new ValidationError(reqIssues);
+        const target = { ...merged, ...collections };
+        if (await mergeStoredParts(m, target)) {
+            const resplit = splitCollections(m, target);
+            Object.assign(merged, resplit.base);
+            Object.assign(collections, resplit.collections);
+        }
         const dbRow = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...merged, updated_at: ts })));
         await tx.upsert(entityName, dbRow);
         await writeCollections(tx, m, id, collections);
         const allCollections = await readCollections(tx, m, id);
-        const derived = applyDerived(m.fields, { ...merged, ...allCollections });
+        const derived = await applyDerived(m.fields, { ...merged, ...allCollections });
         if (Object.keys(derived).length) {
             await tx.nativeUpdate(entityName, { id }, encodeJson(m, encodeTemporal(m, flattenEmbedded(m, derived))));
             Object.assign(merged, derived);
@@ -158,7 +195,12 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
         const _extends = afterBase ? await afterBase(tx, id) : undefined;
         const after = { ...merged, ...allCollections, updated_at: ts, ...(_extends ? { _extends } : {}) };
         writeEvent(tx, ctx.actor, 'update', `${m.library}/${m.shelf}`, id, existing, after);
-        result = after;
+        result = await injectParts(m.fields, after, {
+            record: after,
+            settings: EMPTY_SETTINGS,
+            global: EMPTY_GLOBAL,
+            meta: { library: m.library, shelf: m.shelf },
+        });
     });
     notifyRecordsChanged();
     return result;
@@ -191,8 +233,14 @@ export async function restoreRecord(m, entityName, id, ctx, afterBase) {
         const nested = nestEmbedded(m, flat);
         const collections = await readCollections(tx, m, id);
         const _extends = afterBase ? await afterBase(tx, id) : undefined;
-        result = { ...nested, ...collections, ...(_extends ? { _extends } : {}) };
-        writeEvent(tx, ctx.actor, 'restore', `${m.library}/${m.shelf}`, id, null, result);
+        const restored = { ...nested, ...collections, ...(_extends ? { _extends } : {}) };
+        writeEvent(tx, ctx.actor, 'restore', `${m.library}/${m.shelf}`, id, null, restored);
+        result = await injectParts(m.fields, restored, {
+            record: restored,
+            settings: EMPTY_SETTINGS,
+            global: EMPTY_GLOBAL,
+            meta: { library: m.library, shelf: m.shelf },
+        });
     });
     notifyRecordsChanged();
     return result;

package/dist/part-injection.d.ts

@@ -0,0 +1,12 @@
+import { type LayoutEl } from '@coffer-org/sdk/fields';
+export interface PartCtx {
+    record: Record<string, unknown>;
+    settings: Record<string, unknown>;
+    global: Record<string, unknown>;
+    meta: {
+        library: string;
+        shelf: string;
+    };
+}
+export declare function injectParts(fields: LayoutEl[], row: Record<string, unknown>, ctx: PartCtx): Promise<Record<string, unknown>>;
+export declare function applyStoredParts(fields: LayoutEl[], row: Record<string, unknown>, ctx: PartCtx): Promise<Record<string, unknown>>;

package/dist/part-injection.js

@@ -0,0 +1,125 @@
+import { isField, isGroup, isCollectionGroup } from '@coffer-org/sdk/fields';
+async function partValue(p, ctx, self) {
+    return typeof p.value === 'function' ? await p.value({ ...ctx, self }) : p.value;
+}
+async function completeOne(key, fm, value, ctx) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const self = { ...value };
+    for (const p of fm.parts) {
+        if (p.mode !== 'pinned' && p.mode !== 'computed')
+            continue;
+        try {
+            self[p.role] = await partValue(p, ctx, self);
+        }
+        catch (e) {
+            console.warn(`[part-injection] '${key}.${p.role}' threw`, e);
+        }
+    }
+    return self;
+}
+async function computeOne(key, fm, value, ctx) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const self = { ...value };
+    const contextOnly = [];
+    for (const p of fm.parts) {
+        if (p.mode !== 'pinned' && p.mode !== 'computed')
+            continue;
+        contextOnly.push(p.role);
+        try {
+            self[p.role] = await partValue(p, ctx, self);
+        }
+        catch (e) {
+            console.warn(`[part-compute] '${key}.${p.role}' threw`, e);
+        }
+    }
+    for (const p of fm.parts) {
+        if (p.mode !== 'computedStored')
+            continue;
+        try {
+            self[p.key] = await partValue(p, ctx, self);
+        }
+        catch (e) {
+            console.warn(`[part-compute] '${key}.${p.role}' threw`, e);
+        }
+    }
+    for (const role of contextOnly)
+        delete self[role];
+    return self;
+}
+async function walkFields(fields, obj, ctx, complete) {
+    const out = { ...obj };
+    for (const it of fields) {
+        if (isField(it)) {
+            const fm = it.type;
+            if (!fm.parts?.length)
+                continue;
+            const value = out[it.key];
+            if (value == null)
+                continue;
+            if (fm.hints?.['multiple'] === true) {
+                if (!Array.isArray(value))
+                    continue;
+                out[it.key] = await Promise.all(value.map((v) => complete(it.key, fm, v, ctx)));
+            }
+            else {
+                out[it.key] = await complete(it.key, fm, value, ctx);
+            }
+        }
+        else if (isGroup(it)) {
+            if (!it.key) {
+                Object.assign(out, await walkFields(it.fields, out, ctx, complete));
+            }
+            else if (isCollectionGroup(it)) {
+                const rows = out[it.key];
+                if (Array.isArray(rows)) {
+                    out[it.key] = await Promise.all(rows.map((row) => row != null && typeof row === 'object'
+                        ? walkFields(it.fields, row, ctx, complete)
+                        : row));
+                }
+            }
+            else {
+                const sub = out[it.key];
+                if (sub != null && typeof sub === 'object' && !Array.isArray(sub)) {
+                    out[it.key] = await walkFields(it.fields, sub, ctx, complete);
+                }
+            }
+        }
+    }
+    return out;
+}
+const partWorkCache = new WeakMap();
+function partWork(fields) {
+    const cached = partWorkCache.get(fields);
+    if (cached !== undefined)
+        return cached;
+    const found = { unstored: false, computedStored: false };
+    for (const it of fields) {
+        if (isField(it)) {
+            for (const p of it.type.parts ?? []) {
+                if (p.mode === 'pinned' || p.mode === 'computed')
+                    found.unstored = true;
+                else if (p.mode === 'computedStored')
+                    found.computedStored = true;
+            }
+        }
+        else if (isGroup(it)) {
+            const sub = partWork(it.fields);
+            found.unstored ||= sub.unstored;
+            found.computedStored ||= sub.computedStored;
+        }
+    }
+    partWorkCache.set(fields, found);
+    return found;
+}
+export async function injectParts(fields, row, ctx) {
+    if (!partWork(fields).unstored)
+        return row;
+    return walkFields(fields, row, ctx, completeOne);
+}
+export async function applyStoredParts(fields, row, ctx) {
+    if (!partWork(fields).computedStored)
+        return row;
+    return walkFields(fields, row, ctx, computeOne);
+}

package/dist/recompute-derived.js

@@ -22,7 +22,7 @@ export async function recomputeDerivedFields(m, entityName) {
         const flat = decodeTemporal(m, row);
         const nested = nestEmbedded(m, flat);
         const collections = await readCollections(fork, m, id);
-        const derived = applyDerived(m.fields, { ...nested, ...collections });
+        const derived = await applyDerived(m.fields, { ...nested, ...collections });
         if (Object.keys(derived).length === 0)
             continue;
         const encoded = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, derived)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -24,8 +24,8 @@
     "postpack": "node ../../scripts/swap-exports.mjs src"
   },
   "dependencies": {
-    "@coffer-org/core": "^3.2.0",
-    "@coffer-org/sdk": "^3.2.0",
+    "@coffer-org/core": "^3.3.0",
+    "@coffer-org/sdk": "^3.3.0",
     "@extractus/oembed-extractor": "^4.1.0",
     "@fastify/cors": "^11.2.0",
     "@fastify/multipart": "^10.0.0",