@coffer-org/server 3.3.0 → 4.0.0

package/dist/compute-unit.d.ts

@@ -0,0 +1,66 @@
+import { type FieldMeta, type FieldView, type ContainerNode, type LayoutEl } from '@coffer-org/sdk/fields';
+import { PartContractError } from './part-errors.ts';
+import { type RefState } from './part-ref.ts';
+import type { PartCtx, PartMemo } from './part-injection.ts';
+export type Row = Record<string, unknown>;
+export interface PartComputeCtx {
+    record: Row;
+    parent: Row;
+    settings: Record<string, unknown>;
+    global: Record<string, unknown>;
+    meta: {
+        library: string;
+        shelf: string;
+    };
+    self: Row;
+    ref(key: string): Promise<Row | null>;
+    now: string;
+    fields(path: string | (string | number)[]): FieldView | null;
+    path: (string | number)[];
+}
+export interface Level {
+    fields: LayoutEl[];
+    scope: Scope;
+    proxy: Row;
+    label: string;
+}
+export interface Scope {
+    st: WalkState;
+    uid: number;
+    obj: Row;
+    units: Map<string, FieldMeta | ContainerNode>;
+    embedded: Map<string, LayoutEl[]>;
+    status: Map<string, 'done'>;
+    proxy: Row;
+    groups: Map<string, Scope>;
+    path: readonly (string | number)[];
+    level: Level;
+}
+export interface WalkState {
+    ctx: PartCtx;
+    mode: 'read' | 'write';
+    memo: PartMemo;
+    refs: RefState | null;
+    selfKey: string | null;
+    recordLevel: Level;
+    now: string;
+}
+export declare function partValue(p: {
+    value?: unknown;
+}, ctx: PartComputeCtx): Promise<unknown>;
+export declare function rethrowLoud(e: unknown): void;
+export declare function isComputeUnit(fm: FieldMeta): boolean;
+export declare function scopeUnits(fields: LayoutEl[]): Map<string, FieldMeta | ContainerNode>;
+export declare function scopeEmbedded(fields: LayoutEl[]): Map<string, LayoutEl[]>;
+export declare function levelRelations(fields: LayoutEl[]): Map<string, FieldMeta>;
+export declare function childScope(scope: Scope, key: string, create?: boolean): Scope | null;
+export declare function newScope(st: WalkState, obj: Row, fields: LayoutEl[], path: readonly (string | number)[], level: Level | null, label: string): Scope;
+export declare function refFor(scope: Scope, key: string, field: string, role: string): Promise<Row | null>;
+export declare function storedRefError(scope: Scope, key: string, field: string, role: string): PartContractError;
+export declare function computeCtxFor(scope: Scope, self: Row, cache: number | undefined, field: string, role: string): PartComputeCtx;
+export declare function completeValue(scope: Scope, key: string, fm: FieldMeta, value: unknown): Promise<unknown>;
+export declare function materializable(fm: FieldMeta): boolean;
+export declare function storedFilled(fm: FieldMeta, value: unknown): boolean;
+export declare function isPlainObject(v: unknown): boolean;
+export declare function isGroupUnit(fm: FieldMeta | ContainerNode): fm is ContainerNode;
+export declare function runFieldUnit(scope: Scope, key: string, fm: FieldMeta | ContainerNode): Promise<void>;

package/dist/compute-unit.js

@@ -0,0 +1,369 @@
+import { hasChildren, isNamedField, isCollectionGroup, isEmbeddedGroup, isStorageGroup, } from '@coffer-org/sdk/fields';
+import { mandatedClientParts } from '@coffer-org/sdk/parts';
+import { PartContractError } from "./part-errors.js";
+import { createRefLoader } from "./part-ref.js";
+import { wholeClockColumn, partClockColumn } from "./cache-clock.js";
+let scopeUid = 0;
+export async function partValue(p, ctx) {
+    return typeof p.value === 'function' ? await p.value(ctx) : p.value;
+}
+export function rethrowLoud(e) {
+    if (e instanceof PartContractError)
+        throw e;
+}
+export function isComputeUnit(fm) {
+    return Boolean(fm.parts?.length) || fm.compute !== undefined;
+}
+const unitsCache = new WeakMap();
+export function scopeUnits(fields) {
+    const cached = unitsCache.get(fields);
+    if (cached)
+        return cached;
+    const out = new Map();
+    const scan = (list) => {
+        for (const it of list) {
+            if (isNamedField(it)) {
+                if (isComputeUnit(it.type))
+                    out.set(it.key, it.type);
+            }
+            else if (hasChildren(it)) {
+                if (isStorageGroup(it) && it.compute !== undefined)
+                    out.set(it.key, it);
+                else if (!isStorageGroup(it))
+                    scan(it.fields);
+            }
+        }
+    };
+    scan(fields);
+    unitsCache.set(fields, out);
+    return out;
+}
+const embeddedCache = new WeakMap();
+export function scopeEmbedded(fields) {
+    const cached = embeddedCache.get(fields);
+    if (cached)
+        return cached;
+    const out = new Map();
+    const scan = (list) => {
+        for (const it of list) {
+            if (!hasChildren(it))
+                continue;
+            if (!isStorageGroup(it))
+                scan(it.fields);
+            else if (isEmbeddedGroup(it))
+                out.set(it.key, it.fields);
+        }
+    };
+    scan(fields);
+    embeddedCache.set(fields, out);
+    return out;
+}
+const relationsCache = new WeakMap();
+export function levelRelations(fields) {
+    const cached = relationsCache.get(fields);
+    if (cached)
+        return cached;
+    const out = new Map();
+    const scan = (list) => {
+        for (const it of list) {
+            if (isNamedField(it)) {
+                if (it.type.relation)
+                    out.set(it.key, it.type);
+            }
+            else if (hasChildren(it) && it.scope === 'hoist')
+                scan(it.fields);
+        }
+    };
+    scan(fields);
+    relationsCache.set(fields, out);
+    return out;
+}
+export function childScope(scope, key, create = false) {
+    const existing = scope.groups.get(key);
+    if (existing)
+        return existing;
+    const sub = scope.embedded.get(key);
+    if (!sub)
+        return null;
+    const cur = scope.obj[key];
+    if (!isPlainObject(cur) && !create)
+        return null;
+    const copy = isPlainObject(cur) ? { ...cur } : {};
+    scope.obj[key] = copy;
+    const child = newScope(scope.st, copy, sub, [...scope.path, key], scope.level, scope.level.label);
+    scope.groups.set(key, child);
+    return child;
+}
+export function newScope(st, obj, fields, path, level, label) {
+    const scope = {
+        st,
+        uid: ++scopeUid,
+        obj,
+        units: scopeUnits(fields),
+        embedded: scopeEmbedded(fields),
+        status: new Map(),
+        path,
+        level: level,
+        proxy: obj,
+        groups: new Map(),
+    };
+    if (!level)
+        scope.level = { fields, scope, proxy: obj, label };
+    return scope;
+}
+function refsOf(st) {
+    if (!st.refs) {
+        st.refs = {
+            chain: st.selfKey ? [st.selfKey] : [],
+            loader: createRefLoader((_m, record) => Promise.resolve(record), st.ctx.em),
+        };
+    }
+    return st.refs;
+}
+function siteOf(field, role) {
+    return role ? `'${field}.${role}'` : `'${field}'`;
+}
+export function refFor(scope, key, field, role) {
+    const level = scope.level;
+    const fm = levelRelations(level.fields).get(key);
+    if (!fm?.relation) {
+        const known = [...levelRelations(level.fields).keys()];
+        throw new PartContractError(`ctx.ref('${key}') in ${scope.st.ctx.meta.library}/${scope.st.ctx.meta.shelf} ${siteOf(field, role)}: ` +
+            `'${key}' is not a relation field of ${level.label} ` +
+            `(relation fields there: ${known.length ? known.map((k) => `'${k}'`).join(', ') : 'none'}). ` +
+            `ctx.ref takes the KEY of a relation declared next to this field, not a path.`);
+    }
+    if (fm.hints?.['multi'] === true || fm.hints?.['multiple'] === true) {
+        throw new PartContractError(`ctx.ref('${key}') in ${scope.st.ctx.meta.library}/${scope.st.ctx.meta.shelf} ${siteOf(field, role)}: ` +
+            `'${key}' is a MULTIPLE relation — ctx.ref resolves one record, not a list.`);
+    }
+    const raw = level.scope.obj[key];
+    if (raw == null || raw === '')
+        return Promise.resolve(null);
+    const id = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(id))
+        return Promise.resolve(null);
+    const refs = refsOf(scope.st);
+    return refs.loader.load(fm.relation.library, fm.relation.shelf, id, refs.chain);
+}
+export function storedRefError(scope, key, field, role) {
+    const { library, shelf } = scope.st.ctx.meta;
+    const noun = role ? 'part' : 'field';
+    return new PartContractError(`ctx.ref('${key}') in ${library}/${shelf} ${siteOf(field, role)}: a computed-AND-STORED ${noun} must not read ` +
+        `another record unless it declares \`cache\`. Its column is written once, at write time, and nothing ` +
+        `recomputes it when the record it read changes — the value would be stale and look authoritative. Declare ` +
+        `\`cache\` on the ${noun} to allow a refreshed cross-record read.`);
+}
+function resolveField(levelObj, fields, path, i) {
+    if (i >= path.length)
+        return null;
+    const seg = path[i];
+    for (const el of fields) {
+        if (isNamedField(el)) {
+            if (typeof seg !== 'string' || el.key !== seg)
+                continue;
+            const fm = el.type;
+            if (i === path.length - 1) {
+                const cacheKey = fm.cache !== undefined ? wholeClockColumn(el.key) : null;
+                return { value: levelObj[el.key], kind: fm.kind, cacheKey, owner: levelObj };
+            }
+            const partSeg = path[i + 1];
+            if (i + 2 !== path.length || typeof partSeg !== 'string')
+                return null;
+            const part = fm.parts?.find((p) => p.key === partSeg);
+            if (!part)
+                return null;
+            const composite = levelObj[el.key];
+            const value = isPlainObject(composite) ? composite[partSeg] : undefined;
+            const cacheKey = part.meta.cache !== undefined ? partClockColumn(el.key, partSeg) : null;
+            return { value, kind: part.meta.kind, cacheKey, owner: levelObj };
+        }
+        if (hasChildren(el)) {
+            const sub = el.fields;
+            if (!isStorageGroup(el)) {
+                const found = resolveField(levelObj, sub, path, i);
+                if (found)
+                    return found;
+                continue;
+            }
+            if (typeof seg !== 'string' || el.key !== seg)
+                continue;
+            if (isCollectionGroup(el)) {
+                const idx = path[i + 1];
+                if (typeof idx !== 'number')
+                    return null;
+                const rows = levelObj[el.key];
+                const row = Array.isArray(rows) ? rows[idx] : undefined;
+                if (!isPlainObject(row))
+                    return null;
+                if (i + 2 === path.length)
+                    return { value: row, kind: el.kind ?? 'group', cacheKey: null, owner: levelObj };
+                return resolveField(row, sub, path, i + 2);
+            }
+            if (i === path.length - 1) {
+                return { value: levelObj[el.key], kind: el.kind ?? 'group', cacheKey: null, owner: levelObj };
+            }
+            const child = levelObj[el.key];
+            if (!isPlainObject(child))
+                return null;
+            return resolveField(child, sub, path, i + 1);
+        }
+    }
+    return null;
+}
+function fieldsFor(st, path) {
+    const segs = typeof path === 'string' ? path.split('.') : path;
+    const found = resolveField(st.recordLevel.proxy, st.recordLevel.fields, segs, 0);
+    if (!found)
+        return null;
+    const rawUpdatedAt = st.recordLevel.proxy['updated_at'];
+    const updatedAt = rawUpdatedAt instanceof Date ? rawUpdatedAt.toISOString() : typeof rawUpdatedAt === 'string' ? rawUpdatedAt : null;
+    const rawComputedAt = found.cacheKey != null ? found.owner[found.cacheKey] : undefined;
+    const computedAt = typeof rawComputedAt === 'number' ? rawComputedAt : null;
+    return { value: found.value, kind: found.kind, updatedAt, computedAt };
+}
+export function computeCtxFor(scope, self, cache, field, role) {
+    const st = scope.st;
+    return {
+        record: st.recordLevel.proxy,
+        parent: scope.level.proxy,
+        settings: st.ctx.settings,
+        global: st.ctx.global,
+        meta: st.ctx.meta,
+        self,
+        ref: cache === undefined
+            ? (key) => {
+                throw storedRefError(scope, key, field, role);
+            }
+            : (key) => refFor(scope, key, field, role),
+        now: st.now,
+        fields: (path) => fieldsFor(st, path),
+        path: role ? [...scope.path, field, role] : [...scope.path, field],
+    };
+}
+export async function completeValue(scope, key, fm, value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const st = scope.st;
+    if (st.mode !== 'write')
+        return value;
+    const self = { ...value };
+    for (const p of fm.parts) {
+        if (p.mode !== 'computedStored')
+            continue;
+        try {
+            self[p.key] = await partValue(p, computeCtxFor(scope, self, p.meta?.cache, key, p.role));
+            if (p.meta?.cache !== undefined)
+                scope.obj[partClockColumn(key, p.key)] = Date.now();
+        }
+        catch (e) {
+            rethrowLoud(e);
+            console.warn(`[part-compute] '${key}.${p.role}' threw`, e);
+        }
+    }
+    return self;
+}
+export function materializable(fm) {
+    const parts = fm.parts ?? [];
+    if (!parts.some((p) => p.mode === 'computedStored'))
+        return false;
+    if (mandatedClientParts(fm.required, parts).length > 0)
+        return false;
+    return true;
+}
+export function storedFilled(fm, value) {
+    if (value == null || typeof value !== 'object')
+        return false;
+    const v = value;
+    return (fm.parts ?? []).some((p) => v[p.key] != null && v[p.key] !== '');
+}
+export function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+export function isGroupUnit(fm) {
+    return hasChildren(fm);
+}
+export async function runFieldUnit(scope, key, fm) {
+    if (isGroupUnit(fm)) {
+        if (scope.st.mode !== 'write')
+            return;
+        let value;
+        try {
+            value = await partValue({ value: fm.compute }, computeCtxFor(scope, {}, undefined, key, ''));
+        }
+        catch (e) {
+            rethrowLoud(e);
+            console.warn(`[part-compute] '${key}' threw`, e);
+            return;
+        }
+        if (isCollectionGroup(fm)) {
+            scope.obj[key] = Array.isArray(value) ? value : [];
+            return;
+        }
+        const child = childScope(scope, key, true);
+        if (value == null) {
+            for (const c of fm.fields)
+                if (isNamedField(c))
+                    child.obj[c.key] = null;
+            return;
+        }
+        if (isPlainObject(value)) {
+            for (const [k, v] of Object.entries(value))
+                child.obj[k] = v;
+        }
+        return;
+    }
+    const wholeFn = fm.compute;
+    if (wholeFn !== undefined && !fm.parts?.length) {
+        if (scope.st.mode !== 'write')
+            return;
+        try {
+            scope.obj[key] = await partValue({ value: wholeFn }, computeCtxFor(scope, {}, fm.cache, key, ''));
+            if (fm.cache !== undefined)
+                scope.obj[wholeClockColumn(key)] = Date.now();
+        }
+        catch (e) {
+            rethrowLoud(e);
+            console.warn(`[part-compute] '${key}' threw`, e);
+        }
+        return;
+    }
+    if (!fm.parts?.length)
+        return;
+    if (wholeFn !== undefined) {
+        if (scope.st.mode !== 'write')
+            return;
+        let value;
+        try {
+            value = await partValue({ value: wholeFn }, computeCtxFor(scope, {}, fm.cache, key, ''));
+            if (fm.cache !== undefined)
+                scope.obj[wholeClockColumn(key)] = Date.now();
+        }
+        catch (e) {
+            rethrowLoud(e);
+            console.warn(`[part-compute] '${key}' threw`, e);
+            return;
+        }
+        scope.obj[key] = value == null ? value : await completeValue(scope, key, fm, value);
+        return;
+    }
+    const value = scope.obj[key];
+    if (value == null) {
+        if (scope.st.mode !== 'write' || fm.hints?.['multiple'] === true || !materializable(fm))
+            return;
+        const made = await completeValue(scope, key, fm, {});
+        if (storedFilled(fm, made))
+            scope.obj[key] = made;
+        return;
+    }
+    if (fm.hints?.['multiple'] === true) {
+        if (!Array.isArray(value))
+            return;
+        const out = [];
+        for (const v of value)
+            out.push(await completeValue(scope, key, fm, v));
+        scope.obj[key] = out;
+        return;
+    }
+    scope.obj[key] = await completeValue(scope, key, fm, value);
+}

package/dist/condition-where.js

@@ -8,7 +8,7 @@ export class ConditionCompileError extends Error {
         this.name = 'ConditionCompileError';
     }
 }
-const coerce = (f, v) => typeof v === 'boolean' ? v : coerceFilter(String(v), f.column);
+const coerce = (f, v) => (typeof v === 'boolean' ? v : coerceFilter(String(v), f.column));
 function memberOperator(pred, key, where) {
     if (typeof pred !== 'object' || pred === null)
         return undefined;
@@ -68,8 +68,6 @@ export function conditionToWhere(m, cond) {
             const f = fm[key];
             if (!f)
                 throw new ConditionCompileError(`${where}: unknown field '${key}'`);
-            if (f.virtual)
-                throw new ConditionCompileError(`${where}: '${key}' is virtual and has no column`);
             const memberOp = memberOperator(spec, key, where);
             if (memberOp && !f.hints['multiple']) {
                 throw new ConditionCompileError(`${where}: '${key}' is not a multiple field — '${memberOp}' does not apply`);

package/dist/data-dir.d.ts

@@ -0,0 +1,3 @@
+export declare function dataDir(): string;
+export declare function instanceDir(...segments: string[]): string;
+export declare function carryInto(dst: string, ...legacyDirs: string[]): void;

package/dist/data-dir.js

@@ -0,0 +1,39 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+export function dataDir() {
+    return resolve(process.env.DATA_DIR ?? join(process.cwd(), 'data'));
+}
+export function instanceDir(...segments) {
+    const dir = join(dataDir(), ...segments);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function carryInto(dst, ...legacyDirs) {
+    for (const src of legacyDirs)
+        copyMissing(src, dst);
+}
+function copyMissing(src, dst) {
+    let entries;
+    try {
+        entries = readdirSync(src, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const from = join(src, entry.name);
+        const to = join(dst, entry.name);
+        if (entry.isDirectory()) {
+            copyMissing(from, to);
+            continue;
+        }
+        if (existsSync(to))
+            continue;
+        try {
+            mkdirSync(dst, { recursive: true });
+            copyFileSync(from, to);
+        }
+        catch {
+        }
+    }
+}

package/dist/db.js

@@ -2,6 +2,7 @@ import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { MikroORM, EntityCaseNamingStrategy } from '@mikro-orm/core';
 import { SqliteDriver } from '@mikro-orm/sqlite';
+import { disableColumnRenameDetection } from "./rename-guard.js";
 const SKIP_TABLES = [/^_search(_|$)/];
 let _orm;
 export function getOrm() {
@@ -21,6 +22,7 @@ export async function closeDb() {
     _orm = undefined;
 }
 export async function initDb(entities) {
+    disableColumnRenameDetection();
     const driverName = process.env['DB_DRIVER'] ?? 'sqlite';
     const common = {
         entities,

package/dist/entity-schema.d.ts

@@ -13,6 +13,7 @@ export declare function buildExtendCollectionEntities(e: ExtendDef): EntitySchem
 export declare const EventSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const PluginRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const MigrationRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const MigrationOpRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const SeedRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const EmbeddingSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const PluginStateSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;

package/dist/entity-schema.js

@@ -1,5 +1,7 @@
 import { EntitySchema } from '@mikro-orm/core';
 import { fieldEntries, collectionGroups, storageColumns } from '@coffer-org/sdk/shelf';
+import { cacheClockColumns } from "./cache-clock.js";
+import { SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS } from "./system-settings.js";
 function mikroType(col) {
     if (col === 'integer')
         return 'integer';
@@ -23,8 +25,6 @@ function columnProp(field, nullable) {
 }
 function addFieldProps(properties, fields, plainNullable) {
     for (const [key, field] of fieldEntries(fields)) {
-        if (field.virtual)
-            continue;
         if (field.columns) {
             for (const [col, type] of storageColumns(key, field))
                 properties[col] = { type: mikroType(type), nullable: true };
@@ -33,6 +33,8 @@ function addFieldProps(properties, fields, plainNullable) {
             properties[key] = columnProp(field, plainNullable(field));
         }
     }
+    for (const col of cacheClockColumns(fields))
+        properties[col] = { type: 'integer', nullable: true };
 }
 export function shelfTableName(library, shelf) {
     return `${library}__${shelf}`;
@@ -122,6 +124,25 @@ export const MigrationRowSchema = new EntitySchema({
         version: { type: 'integer', nullable: false },
     },
 });
+export const MigrationOpRowSchema = new EntitySchema({
+    name: '_MigrationOp',
+    tableName: '_migration_ops',
+    properties: {
+        plugin_id: { type: 'text', primary: true },
+        version: { type: 'integer', primary: true },
+        seq: { type: 'integer', primary: true },
+        op: { type: 'text', nullable: false },
+        table_name: { type: 'text', nullable: false },
+        performed: { type: 'integer', nullable: false },
+        rows: { type: 'integer', nullable: true },
+        scanned: { type: 'integer', nullable: true },
+        code: { type: 'text', nullable: true },
+        reason: { type: 'text', nullable: true },
+        empty_targets: { type: 'text', nullable: true },
+        stranded_sources: { type: 'text', nullable: true },
+        applied_at: { type: 'text', nullable: true },
+    },
+});
 export const SeedRowSchema = new EntitySchema({
     name: '_Seed',
     tableName: '_seeds',
@@ -296,6 +317,7 @@ export const systemEntities = [
     EventSchema,
     PluginRowSchema,
     MigrationRowSchema,
+    MigrationOpRowSchema,
     SeedRowSchema,
     EmbeddingSchema,
     PluginStateSchema,
@@ -309,4 +331,5 @@ export const systemEntities = [
     OAuthTokenSchema,
     ThreadMessageSchema,
     ThreadStateSchema,
+    buildSettingsEntitySchema(SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS),
 ];

package/dist/extend-io.d.ts

@@ -1,9 +1,10 @@
 import type { EntityManager } from '@mikro-orm/core';
+import type { PartMemo } from './part-injection.ts';
 export declare function splitBody(body: unknown): {
     base: Record<string, unknown>;
     extData: Record<string, Record<string, unknown>>;
 };
 export declare function deleteExtends(em: EntityManager, library: string, shelf: string, id: number): Promise<void>;
-export declare function readExtends(em: EntityManager, library: string, shelf: string, id: number): Promise<Record<string, unknown>>;
+export declare function readExtends(em: EntityManager, library: string, shelf: string, id: number, memo?: PartMemo): Promise<Record<string, unknown>>;
 export declare function validateExtends(library: string, shelf: string, extData: Record<string, Record<string, unknown>>): void;
-export declare function saveExtends(em: EntityManager, library: string, shelf: string, baseId: number, extData: Record<string, Record<string, unknown>>): Promise<void>;
+export declare function saveExtends(em: EntityManager, library: string, shelf: string, baseId: number, extData: Record<string, Record<string, unknown>>, memo?: PartMemo): Promise<void>;

package/dist/extend-io.js

@@ -20,10 +20,10 @@ export async function deleteExtends(em, library, shelf, id) {
         await deleteExtendRecord(em, e, id);
     }
 }
-export async function readExtends(em, library, shelf, id) {
+export async function readExtends(em, library, shelf, id, memo) {
     const out = {};
     for (const e of getExtendsFor(library, shelf)) {
-        out[e.id] = (await getExtendRecord(e, id, em)) ?? null;
+        out[e.id] = (await getExtendRecord(e, id, em, memo)) ?? null;
     }
     return out;
 }
@@ -41,7 +41,7 @@ export function validateExtends(library, shelf, extData) {
     if (issues.length)
         throw new ValidationError(issues);
 }
-export async function saveExtends(em, library, shelf, baseId, extData) {
+export async function saveExtends(em, library, shelf, baseId, extData, memo) {
     validateExtends(library, shelf, extData);
     for (const e of getExtendsFor(library, shelf)) {
         const data = extData[e.id];
@@ -53,7 +53,7 @@ export async function saveExtends(em, library, shelf, baseId, extData) {
             const fileIssues = normalizeFileFieldsAt(e.fields, row);
             if (fileIssues.length)
                 throw new ValidationError(fileIssues);
-            await upsertExtendRecord(em, e, baseId, row);
+            await upsertExtendRecord(em, e, baseId, row, memo);
         }
     }
 }

package/dist/extend-table.d.ts

@@ -1,9 +1,10 @@
 import type { EntityManager } from '@mikro-orm/core';
 import type { ExtendDef } from '@coffer-org/sdk/extend';
+import { type PartMemo } from './part-injection.ts';
 type Row = Record<string, unknown>;
 export declare function extendEntityName(e: ExtendDef): string;
-export declare function getExtendRecord(e: ExtendDef, baseId: number, em?: EntityManager): Promise<Row | undefined>;
+export declare function getExtendRecord(e: ExtendDef, baseId: number, em?: EntityManager, _memo?: PartMemo): Promise<Row | undefined>;
 export declare function getExtendRecords(e: ExtendDef, baseIds: number[], em?: EntityManager): Promise<Map<number, Row>>;
-export declare function upsertExtendRecord(em: EntityManager, e: ExtendDef, baseId: number, data: Row): Promise<void>;
+export declare function upsertExtendRecord(em: EntityManager, e: ExtendDef, baseId: number, data: Row, memo?: PartMemo): Promise<void>;
 export declare function deleteExtendRecord(em: EntityManager, e: ExtendDef, baseId: number): Promise<void>;
 export {};