@coffer-org/server 3.4.0 → 5.0.0

package/dist/plugin-runtime.js

@@ -1,4 +1,4 @@
-import { composeRegistry } from '@coffer-org/core/compose';
+import { composeRegistry } from '@coffer-org/sdk/compose';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { initDb, getOrm, getEm } from "./db.js";
 import { syncSchema } from "./schema-sync.js";
@@ -6,13 +6,15 @@ import { systemEntities, buildPluginEntities, shelfTableName } from "./entity-sc
 import { pluginHooks, pluginCtx, HttpError } from "./plugin-hooks.js";
 import { discoverPlugins, loadServerHooks } from "./plugin-discovery.js";
 import { selectRows } from "./read-rows.js";
-import { runMigrations, assertSafeRequired, renameSystemShelfKey } from "./migrations.js";
+import { runMigrations, assertSafeRequired, runSystemMigrations } from "./migrations.js";
 import { runSeeds } from "./seeds.js";
 import { setActiveRegistry } from "./registry-context.js";
 import { migrateEmbeddingVectorsToBlob } from "./embeddings.js";
 import { ensureSearchTable } from "./search-index.js";
 import { startScheduler, stopScheduler } from "./background-scheduler.js";
 import { startSearchIndexer, indexSearchOnce } from "./search-indexer.js";
+import { startOrchestrator, stopOrchestrator, orchestratorStartersTask } from "./orchestrator/index.js";
+import { SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS } from "./system-settings.js";
 const log = getLogger('plugins');
 let stopSearchIndexer;
 let _plugins = null;
@@ -22,9 +24,7 @@ export async function getPlugins() {
 export async function readDisabled() {
     const fork = getEm().fork();
     const rows = await fork.find('_Plugin', { enabled: 0 });
-    const disabled = new Set(rows.map((r) => r.id));
-    disabled.delete('core');
-    return disabled;
+    return new Set(rows.map((r) => r.id));
 }
 let _disabled = null;
 export function getDisabled() {
@@ -33,10 +33,10 @@ export function getDisabled() {
         throw e;
     }));
 }
-export async function getPluginSettings(pluginId) {
+export async function getPluginSettings(groupId) {
     try {
         const fork = getEm().fork();
-        const [row] = await selectRows(fork, `_settings__${pluginId}`, { plugin_id: pluginId }, { limit: 1 });
+        const [row] = await selectRows(fork, `_settings__${groupId}`, { plugin_id: groupId }, { limit: 1 });
         if (!row)
             return {};
         return row;
@@ -61,6 +61,12 @@ export async function requireSettings(pluginId, keys) {
     }
     return out;
 }
+function systemSettingsGroupInput() {
+    return { id: SYSTEM_SETTINGS_ID, fields: SYSTEM_SETTINGS.fields };
+}
+async function composeAll(disabled) {
+    return composeRegistry(await getPlugins(), { disabled, settingsGroups: [systemSettingsGroupInput()] });
+}
 async function seedPluginRows() {
     const fork = getEm().fork();
     const existing = new Set((await fork.find('_Plugin', {})).map((r) => r.id));
@@ -74,8 +80,9 @@ async function seedPluginRows() {
 }
 export async function initStorage() {
     await initDb(systemEntities);
-    await renameSystemShelfKey(getEm().fork());
+    await runSystemMigrations(getEm().fork());
     await syncSchema();
+    await runSystemMigrations(getEm().fork());
     await migrateEmbeddingVectorsToBlob();
     await getEm().fork().getConnection().execute('DROP TABLE IF EXISTS "_folders"');
     await seedPluginRows();
@@ -98,11 +105,12 @@ export async function initStorage() {
 }
 export async function initPlugins() {
     const disabled = await initStorage();
-    const reg = composeRegistry(await getPlugins(), { disabled });
+    const reg = await composeAll(disabled);
     setActiveRegistry(reg);
     Object.assign(pluginHooks, await loadServerHooks());
     await runSeeds({ em: getEm().fork(), plugins: reg.order, hooks: pluginHooks });
-    const bgTasks = [];
+    startOrchestrator();
+    const bgTasks = [orchestratorStartersTask];
     for (const p of reg.order) {
         const h = pluginHooks[p.id];
         try {
@@ -139,7 +147,7 @@ export async function teardownPlugins() {
     stopScheduler();
     Object.assign(pluginHooks, await loadServerHooks());
     const disabled = await readDisabled();
-    const reg = composeRegistry(await getPlugins(), { disabled });
+    const reg = await composeAll(disabled);
     for (const p of [...reg.order].reverse()) {
         const h = pluginHooks[p.id];
         if (!h?.teardown)
@@ -152,6 +160,7 @@ export async function teardownPlugins() {
             log.warn(`${p.id}: teardown ✗ ${e.message}`);
         }
     }
+    stopOrchestrator();
 }
 export async function teardownPlugin(id) {
     const h = pluginHooks[id];

package/dist/plugin-updates.d.ts

@@ -18,11 +18,11 @@ export interface AllUpdateTarget {
     to: string;
 }
 export declare function resolveAllUpdateTargets(assets: PluginAssetRecord[], latestById: Map<string, string | null>): AllUpdateTarget[];
-export declare function resolveBaseTargets(assets: PluginAssetRecord[], runtime: {
+export declare function resolveBaseTargets(runtime: {
     packageName: string;
     installedVersion: string;
     local: boolean;
-} | null, coreLatest: string | null, runtimeLatest: string | null): AllUpdateTarget[];
+} | null, runtimeLatest: string | null): AllUpdateTarget[];
 export interface RuntimeUpdateTarget {
     packageName: string;
     from: string;

package/dist/plugin-updates.js

@@ -1,8 +1,8 @@
 import { execFile } from 'node:child_process';
-import { isNewerVersion } from '@coffer-org/core/version';
+import { isNewerVersion } from '@coffer-org/sdk/version';
 import { getPluginState, setPluginState } from "./plugin-state.js";
 const TTL_MS = 60 * 60 * 1000;
-const STATE_PLUGIN = 'core';
+const STATE_NAMESPACE = 'system';
 const stateKey = (pkgName) => `update-check:${pkgName}`;
 function readCache(raw) {
     if (!raw)
@@ -18,7 +18,7 @@ export async function checkLatestVersion(pkgName, opts = {}) {
     const key = stateKey(pkgName);
     let cached = null;
     try {
-        cached = readCache(await getPluginState(STATE_PLUGIN, key));
+        cached = readCache(await getPluginState(STATE_NAMESPACE, key));
         if (!opts.force && cached && Date.now() - cached.checkedAt < TTL_MS)
             return cached.latestVersion;
         const res = await fetch(`https://registry.npmjs.org/${pkgName}/latest`, { signal: AbortSignal.timeout(5000) });
@@ -27,7 +27,7 @@ export async function checkLatestVersion(pkgName, opts = {}) {
         const data = (await res.json());
         if (!data.version)
             return cached?.latestVersion ?? null;
-        await setPluginState(STATE_PLUGIN, key, JSON.stringify({ latestVersion: data.version, checkedAt: Date.now() }));
+        await setPluginState(STATE_NAMESPACE, key, JSON.stringify({ latestVersion: data.version, checkedAt: Date.now() }));
         return data.version;
     }
     catch {
@@ -51,15 +51,9 @@ export function resolveAllUpdateTargets(assets, latestById) {
         return [{ id: rec.id, packageName: rec.packageName, from: rec.version, to: latest }];
     });
 }
-export function resolveBaseTargets(assets, runtime, coreLatest, runtimeLatest) {
-    const core = assets.find((a) => a.id === 'core');
+export function resolveBaseTargets(runtime, runtimeLatest) {
     const rt = resolveRuntimeTarget(runtime, runtimeLatest);
-    return [
-        ...(core && !core.local && coreLatest && isNewerVersion(coreLatest, core.version)
-            ? [{ id: 'core', packageName: core.packageName, from: core.version, to: coreLatest }]
-            : []),
-        ...(rt ? [{ id: 'runtime', packageName: rt.packageName, from: rt.from, to: rt.to }] : []),
-    ];
+    return rt ? [{ id: 'runtime', packageName: rt.packageName, from: rt.from, to: rt.to }] : [];
 }
 export function resolveRuntimeTarget(runtime, latestVersion) {
     if (!runtime || runtime.local)

package/dist/public-url.js

@@ -1,4 +1,5 @@
 import { getPluginSettings } from "./plugin-runtime.js";
+import { SYSTEM_SETTINGS_ID } from "./system-settings.js";
 const CACHE_TTL_MS = 30_000;
 let cached = null;
 export function invalidatePublicUrlCache() {
@@ -12,7 +13,7 @@ async function configuredBase() {
         return cached.value;
     let value = '';
     try {
-        value = normalize((await getPluginSettings('core'))['publicUrl']);
+        value = normalize((await getPluginSettings(SYSTEM_SETTINGS_ID))['publicUrl']);
     }
     catch {
         value = '';

package/dist/recompute-derived.d.ts

@@ -1,6 +1,7 @@
 import type { ShelfDef } from '@coffer-org/sdk/shelf';
+import type { ExtendDef } from '@coffer-org/sdk/extend';
 export interface RecomputeResult {
     scanned: number;
     changed: number;
 }
-export declare function recomputeDerivedFields(m: ShelfDef, entityName: string): Promise<RecomputeResult>;
+export declare function recomputeDerivedFields(m: ShelfDef, entityName: string, extends_?: ExtendDef[]): Promise<RecomputeResult>;

package/dist/recompute-derived.js

@@ -1,60 +1,137 @@
 import { collectionGroups } from '@coffer-org/sdk/shelf';
-import { derivedEntries, applyDerived } from '@coffer-org/sdk/derive';
 import { applyStoredParts, hasStoredPartWork } from "./part-injection.js";
+import { extendEntityName } from "./extend-table.js";
 import { getEm } from "./db.js";
 import { selectRows } from "./read-rows.js";
-import { encodeJson } from "./mutate.js";
-import { encodeTemporal, decodeTemporal } from "./temporal.js";
-import { flattenEmbedded, nestEmbedded, readCollections } from "./collection-io.js";
-function sameValue(a, b) {
-    if (a instanceof Date && b instanceof Date)
-        return a.getTime() === b.getTime();
-    if (a instanceof Date || b instanceof Date)
-        return false;
-    return a === b;
-}
+import { encodeJson, encodeJsonAt } from "./mutate.js";
+import { encodeTemporal, decodeTemporal, encodeTemporalAt, decodeTemporalAt } from "./temporal.js";
+import { flattenEmbedded, nestEmbedded, readCollectionsWithMeta, flattenEmbeddedAt, nestEmbeddedAt, readAtWithMeta, } from "./collection-io.js";
+import { levelClockColumnsByOwner } from "./cache-clock.js";
+import { sameValue } from "./value-compare.js";
 function partCtx(m) {
     return { settings: {}, global: {}, meta: { library: m.library, shelf: m.shelf } };
 }
-function changedTopLevel(m, before, after) {
-    const collKeys = new Set(collectionGroups(m.fields).map((c) => c.key));
+function extendCtx(e) {
+    return { settings: {}, global: {}, meta: { library: 'extend', shelf: e.id } };
+}
+function changedKeys(fields, before, after) {
+    const collKeys = new Set(collectionGroups(fields).map((c) => c.key));
+    const clocksByOwner = levelClockColumnsByOwner(fields);
+    const clockKeys = new Set([...clocksByOwner.values()].flat());
     const out = {};
     for (const [k, v] of Object.entries(after)) {
-        if (collKeys.has(k))
+        if (collKeys.has(k) || clockKeys.has(k))
             continue;
         if (JSON.stringify(before[k] ?? null) !== JSON.stringify(v ?? null))
             out[k] = v;
     }
+    for (const [owner, cols] of clocksByOwner) {
+        if (!(owner in out))
+            continue;
+        for (const col of cols) {
+            if (after[col] !== undefined)
+                out[col] = after[col];
+        }
+    }
     return out;
 }
-export async function recomputeDerivedFields(m, entityName) {
-    const storedParts = hasStoredPartWork(m.fields);
-    if (derivedEntries(m.fields).length === 0 && !storedParts)
+async function recomputeCollectionRows(em, tablePrefix, fields, before, after, meta) {
+    let anyChanged = false;
+    for (const c of collectionGroups(fields)) {
+        const table = `${tablePrefix}__${c.key}`;
+        const childFields = c.group.fields;
+        const beforeRows = before[c.key] ?? [];
+        const afterRows = after[c.key] ?? [];
+        const metas = meta[c.key] ?? [];
+        for (let i = 0; i < beforeRows.length; i++) {
+            const rm = metas[i];
+            const b = beforeRows[i];
+            const a = afterRows[i];
+            if (!rm || !b || !a)
+                continue;
+            const patch = changedKeys(childFields, b, a);
+            if (Object.keys(patch).length > 0) {
+                const encodedPatch = encodeJsonAt(childFields, flattenEmbeddedAt(childFields, patch));
+                const encodedBefore = encodeJsonAt(childFields, flattenEmbeddedAt(childFields, b));
+                const dirty = {};
+                for (const [k, v] of Object.entries(encodedPatch)) {
+                    if (!sameValue(encodedBefore[k], v))
+                        dirty[k] = v;
+                }
+                if (Object.keys(dirty).length > 0) {
+                    await em.nativeUpdate(table, { id: rm.id }, dirty);
+                    anyChanged = true;
+                }
+            }
+            if (await recomputeCollectionRows(em, table, childFields, b, a, rm.nested))
+                anyChanged = true;
+        }
+    }
+    return anyChanged;
+}
+async function recomputeExtendRow(em, e, baseId) {
+    const table = extendEntityName(e);
+    const [flat] = (await selectRows(em, table, { base_id: baseId }, { limit: 1 }));
+    if (!flat)
+        return false;
+    const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
+    const { collections, meta } = await readAtWithMeta(em, table, e.fields, baseId);
+    const hydrated = { ...decoded, ...collections };
+    const withParts = await applyStoredParts(e.fields, hydrated, extendCtx(e));
+    let changed = false;
+    const patch = changedKeys(e.fields, hydrated, withParts);
+    if (Object.keys(patch).length > 0) {
+        const encoded = encodeJsonAt(e.fields, encodeTemporalAt(e.fields, flattenEmbeddedAt(e.fields, patch)));
+        const dirty = {};
+        for (const [k, v] of Object.entries(encoded)) {
+            if (!sameValue(flat[k], v))
+                dirty[k] = v;
+        }
+        if (Object.keys(dirty).length > 0) {
+            await em.nativeUpdate(table, { base_id: baseId }, dirty);
+            changed = true;
+        }
+    }
+    if (await recomputeCollectionRows(em, table, e.fields, collections, withParts, meta))
+        changed = true;
+    return changed;
+}
+export async function recomputeDerivedFields(m, entityName, extends_ = []) {
+    const hasExtendWork = extends_.some((e) => hasStoredPartWork(e.fields));
+    if (!hasStoredPartWork(m.fields) && !hasExtendWork)
         return { scanned: 0, changed: 0 };
     const fork = getEm().fork();
     const rows = await selectRows(fork, entityName, {}, { orderBy: { id: 'asc' } });
-    let changed = 0;
+    const changedIds = new Set();
     for (const row of rows) {
         const id = row['id'];
         const flat = decodeTemporal(m, row);
         const nested = nestEmbedded(m, flat);
-        const collections = await readCollections(fork, m, id);
+        const { collections, meta } = await readCollectionsWithMeta(fork, m, id);
         const hydrated = { ...nested, ...collections };
-        const withParts = storedParts ? await applyStoredParts(m.fields, hydrated, partCtx(m)) : hydrated;
-        const partPatch = storedParts ? changedTopLevel(m, hydrated, withParts) : {};
-        const derived = await applyDerived(m.fields, withParts);
-        if (Object.keys(derived).length === 0 && Object.keys(partPatch).length === 0)
-            continue;
-        const encoded = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...partPatch, ...derived })));
-        const dirty = {};
-        for (const [k, v] of Object.entries(encoded)) {
-            if (!sameValue(row[k], v))
-                dirty[k] = v;
+        const withParts = await applyStoredParts(m.fields, hydrated, partCtx(m));
+        const partPatch = changedKeys(m.fields, hydrated, withParts);
+        if (Object.keys(partPatch).length > 0) {
+            const encoded = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, partPatch)));
+            const dirty = {};
+            for (const [k, v] of Object.entries(encoded)) {
+                if (!sameValue(row[k], v))
+                    dirty[k] = v;
+            }
+            if (Object.keys(dirty).length > 0) {
+                await fork.nativeUpdate(entityName, { id }, dirty);
+                changedIds.add(id);
+            }
+        }
+        if (await recomputeCollectionRows(fork, entityName, m.fields, collections, withParts, meta)) {
+            changedIds.add(id);
+        }
+        for (const e of extends_) {
+            if (!hasStoredPartWork(e.fields))
+                continue;
+            if (await recomputeExtendRow(fork, e, id))
+                changedIds.add(id);
         }
-        if (Object.keys(dirty).length === 0)
-            continue;
-        await fork.nativeUpdate(entityName, { id }, dirty);
-        changed += 1;
     }
-    return { scanned: rows.length, changed };
+    return { scanned: rows.length, changed: changedIds.size };
 }

package/dist/records-api.js

@@ -1,5 +1,5 @@
-import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor, magnitudeSub, } from '@coffer-org/sdk/shelf';
-import { tokenize, matchScoreFolded, foldText } from '@coffer-org/core/search';
+import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor, magnitudeSub, resolveColumnKey, } from '@coffer-org/sdk/shelf';
+import { tokenize, matchScoreFolded, foldText } from '@coffer-org/sdk/search';
 import { getActiveRegistry, getShelf, getExtendsFor } from "./registry-context.js";
 import { selectRows } from "./read-rows.js";
 import { shelfTableName } from "./entity-schema.js";
@@ -10,6 +10,7 @@ import { splitBody, saveExtends, deleteExtends, validateExtends, readExtends } f
 import { createRecord, updateRecord, getRecord, deleteRecord, restoreRecord, purgeRecord } from "./mutate.js";
 import { newPartMemo } from "./part-injection.js";
 import { deleteRecordActivity } from "./record-activity.js";
+import { stripClockKeys } from "./cache-clock.js";
 export class UnknownShelfError extends Error {
 }
 export class SingleShelfError extends Error {
@@ -95,26 +96,19 @@ export class FilterError extends Error {
 function resolveFilterKey(m, fm, k) {
     const direct = fm[k];
     if (direct) {
-        if (direct.virtual)
-            return undefined;
         if (!direct.columns)
             return { column: k, type: direct.column };
         const sub = magnitudeSub(direct);
         if (sub === undefined)
-            throw new FilterError(`${m.library}/${m.shelf}: '${k}' is a composite whose parts are all computed or pinned — it owns no column to filter on`);
+            throw new FilterError(`${m.library}/${m.shelf}: '${k}' is a composite with no stored part — it owns no column to filter on`);
         return { column: `${k}__${sub}`, type: direct.columns[sub] };
     }
-    const cut = k.lastIndexOf('__');
-    if (cut <= 0)
+    const owner = resolveColumnKey(fm, k);
+    if (!owner)
         return undefined;
-    const base = fm[k.slice(0, cut)];
-    if (!base?.columns)
-        return undefined;
-    const part = k.slice(cut + 2);
-    const type = base.columns[part];
-    if (type === undefined)
-        throw new FilterError(`${m.library}/${m.shelf}: '${k}' names no part of composite '${k.slice(0, cut)}' (parts: ${Object.keys(base.columns).join(', ')})`);
-    return { column: k, type };
+    if (owner.kind === 'unknown-sub')
+        throw new FilterError(`${m.library}/${m.shelf}: '${k}' names no part of composite '${owner.key}' (parts: ${Object.keys(owner.field.columns).join(', ')})`);
+    return { column: k, type: owner.field.columns[owner.sub] };
 }
 function buildWhere(m, filterParams) {
     const where = {};
@@ -179,8 +173,12 @@ async function listRecords(library, shelf, query = {}, opts = {}) {
     let rows = await selectRows(fork, ename, where, findOpts);
     if (tokens.length > 0)
         rows = rows.filter((row) => rowMatch(m, row, tokens) !== null);
-    if (projected)
+    if (projected) {
         rows = rows.map((row) => pickCols(row, projected));
+    }
+    else {
+        rows = rows.map((row) => stripClockKeys(row));
+    }
     const decoded = rows.map((r) => decodeTemporal(m, r));
     if (!withExt)
         return decoded;

package/dist/registry-context.d.ts

@@ -1,4 +1,4 @@
-import type { Registry } from '@coffer-org/core/compose';
+import type { Registry } from '@coffer-org/sdk/compose';
 export declare function setActiveRegistry(reg: Registry): void;
 export declare function getActiveRegistry(): Registry;
 export declare const getShelf: Registry['getShelf'];

package/dist/registry-context.js

@@ -1,5 +1,8 @@
+import { buildMutateGraph } from '@coffer-org/sdk/mutate-graph';
 let active = null;
 export function setActiveRegistry(reg) {
+    if (!reg.mutateGraph)
+        reg.mutateGraph = buildMutateGraph(reg);
     active = reg;
 }
 function current() {

package/dist/search-index.js

@@ -1,5 +1,5 @@
 import { textSearchKeys, titleKey } from '@coffer-org/sdk/shelf';
-import { foldText } from '@coffer-org/core/search';
+import { foldText } from '@coffer-org/sdk/search';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { getEm } from "./db.js";
 import { getDialect } from "./dialect.js";

package/dist/search-indexer.d.ts

@@ -1,4 +1,4 @@
-export declare const SEARCH_STATE_PLUGIN = "core";
+export declare const SEARCH_STATE_NAMESPACE = "system";
 export declare const SEARCH_CURSOR_KEY = "fts_last_event_id";
 export declare function indexSearchOnce(batch?: number): Promise<number>;
 export declare function startSearchIndexer(batch?: number): () => void;

package/dist/search-indexer.js

@@ -5,13 +5,13 @@ import { getShelf } from "./registry-context.js";
 import { onRecordsChanged } from "./index-signal.js";
 import { ftsAvailable, foldedTextFor, upsertSearchRow, deleteSearchRow } from "./search-index.js";
 const log = getLogger('search-indexer');
-export const SEARCH_STATE_PLUGIN = 'core';
+export const SEARCH_STATE_NAMESPACE = 'system';
 export const SEARCH_CURSOR_KEY = 'fts_last_event_id';
 const DEFAULT_BATCH = 5000;
 export async function indexSearchOnce(batch = DEFAULT_BATCH) {
     if (!ftsAvailable())
         return 0;
-    const last = Number((await getPluginState(SEARCH_STATE_PLUGIN, SEARCH_CURSOR_KEY)) ?? '0');
+    const last = Number((await getPluginState(SEARCH_STATE_NAMESPACE, SEARCH_CURSOR_KEY)) ?? '0');
     const rows = await listEventsSince(last, batch);
     if (rows.length === 0)
         return 0;
@@ -52,7 +52,7 @@ export async function indexSearchOnce(batch = DEFAULT_BATCH) {
             await upsertSearchRow(p.shelf, p.recordId, p.folded);
     }
     const lastId = rows[rows.length - 1].id;
-    await setPluginState(SEARCH_STATE_PLUGIN, SEARCH_CURSOR_KEY, String(lastId));
+    await setPluginState(SEARCH_STATE_NAMESPACE, SEARCH_CURSOR_KEY, String(lastId));
     log.debug(`indexed ${byRef.size} record(s) from ${rows.length} event(s), cursor → ${lastId}`);
     return rows.length;
 }

package/dist/settings-groups.d.ts

@@ -0,0 +1,14 @@
+import type { LayoutEl } from '@coffer-org/sdk/fields';
+import type { PluginManifest } from '@coffer-org/sdk/plugin';
+import { SYSTEM_SETTINGS_ID } from './system-settings.ts';
+export interface SettingsGroup {
+    id: string;
+    label: string;
+    fields: LayoutEl[];
+}
+export { SYSTEM_SETTINGS_ID };
+export declare function groupsFromPlugins(plugins: PluginManifest[]): SettingsGroup[];
+export declare function systemSettingsGroup(): SettingsGroup;
+export declare function groupsWithSystem(plugins: PluginManifest[]): SettingsGroup[];
+export declare function settingsGroups(): Promise<SettingsGroup[]>;
+export declare function findSettingsGroup(id: string): Promise<SettingsGroup | undefined>;

package/dist/settings-groups.js

@@ -0,0 +1,25 @@
+import { getPlugins } from "./plugin-runtime.js";
+import { SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS } from "./system-settings.js";
+export { SYSTEM_SETTINGS_ID };
+export function groupsFromPlugins(plugins) {
+    return plugins
+        .filter((p) => p.settings && p.settings.fields.length > 0)
+        .map((p) => ({ id: p.id, label: p.settings.label, fields: p.settings.fields }));
+}
+export function systemSettingsGroup() {
+    return { id: SYSTEM_SETTINGS_ID, label: SYSTEM_SETTINGS.label, fields: SYSTEM_SETTINGS.fields };
+}
+export function groupsWithSystem(plugins) {
+    const fromPlugins = groupsFromPlugins(plugins);
+    const clash = fromPlugins.find((g) => g.id === SYSTEM_SETTINGS_ID);
+    if (clash) {
+        throw new Error(`[settings] a plugin declares settings under the reserved group id '${SYSTEM_SETTINGS_ID}'`);
+    }
+    return [systemSettingsGroup(), ...fromPlugins];
+}
+export async function settingsGroups() {
+    return groupsWithSystem(await getPlugins());
+}
+export async function findSettingsGroup(id) {
+    return (await settingsGroups()).find((g) => g.id === id);
+}

package/dist/settings-write.d.ts

@@ -9,10 +9,10 @@ export interface SettingsFieldInfo {
     options?: string[];
 }
 export declare function describeSettingsFields(fields: LayoutEl[]): SettingsFieldInfo[];
-export declare function buildSettingsBody(pluginId: string, fields: LayoutEl[], incoming: Record<string, unknown>, existing: Record<string, unknown>): Record<string, unknown>;
-export declare function writePluginSettings(em: EntityManager, pluginId: string, incoming: Record<string, unknown>, actor: string, plugins?: PluginManifest[]): Promise<Record<string, unknown>>;
-export declare function listSettings(plugins?: PluginManifest[]): Promise<{
-    plugin: string;
+export declare function buildSettingsBody(groupId: string, fields: LayoutEl[], incoming: Record<string, unknown>, existing: Record<string, unknown>, label?: string): Record<string, unknown>;
+export declare function writePluginSettings(em: EntityManager, groupId: string, incoming: Record<string, unknown>, actor: string, pluginsOverride?: PluginManifest[]): Promise<Record<string, unknown>>;
+export declare function listSettings(pluginsOverride?: PluginManifest[]): Promise<{
+    group: string;
     label: string;
     fields: SettingsFieldInfo[];
     values: Record<string, unknown>;

package/dist/settings-write.js

@@ -1,8 +1,9 @@
 import { fieldEntries, buildZodObject } from '@coffer-org/sdk/shelf';
 import { preserveTree, maskTree } from "./field-masking.js";
 import { ValidationError, NotFoundError, toIssue } from "./mutate.js";
-import { getPlugins, getPluginSettings } from "./plugin-runtime.js";
+import { getPluginSettings } from "./plugin-runtime.js";
 import { invalidatePublicUrlCache } from "./public-url.js";
+import { groupsFromPlugins, settingsGroups, findSettingsGroup, SYSTEM_SETTINGS_ID } from "./settings-groups.js";
 export function describeSettingsFields(fields) {
     return fieldEntries(fields).map(([key, f]) => ({
         key,
@@ -12,38 +13,35 @@ export function describeSettingsFields(fields) {
         ...(f.options ? { options: f.options.map((o) => o.value) } : {}),
     }));
 }
-function settingsShelf(pluginId, fields) {
-    return { library: '_settings', shelf: pluginId, label: `${pluginId}.plugin.label`, fields };
+function settingsShelf(groupId, fields, label = `${groupId}.plugin.label`) {
+    return { library: '_settings', shelf: groupId, label, fields };
 }
-export function buildSettingsBody(pluginId, fields, incoming, existing) {
+export function buildSettingsBody(groupId, fields, incoming, existing, label) {
     const body = preserveTree(fields, incoming, existing);
-    const parsed = buildZodObject(settingsShelf(pluginId, fields)).safeParse(body);
+    const parsed = buildZodObject(settingsShelf(groupId, fields, label)).safeParse(body);
     if (!parsed.success)
         throw new ValidationError(parsed.error.issues.map(toIssue));
     return parsed.data;
 }
-function withSettings(plugins) {
-    return plugins.filter((p) => p.settings && p.settings.fields.length > 0);
-}
-export async function writePluginSettings(em, pluginId, incoming, actor, plugins) {
-    const all = plugins ?? (await getPlugins());
-    const p = all.find((x) => x.id === pluginId);
-    if (!p || !p.settings || p.settings.fields.length === 0) {
+export async function writePluginSettings(em, groupId, incoming, actor, pluginsOverride) {
+    const group = pluginsOverride
+        ? groupsFromPlugins(pluginsOverride).find((g) => g.id === groupId)
+        : await findSettingsGroup(groupId);
+    if (!group)
         throw new NotFoundError();
-    }
-    const fields = p.settings.fields;
-    const existing = await getPluginSettings(pluginId);
-    const data = buildSettingsBody(pluginId, fields, incoming, existing);
-    const row = { plugin_id: pluginId, ...data };
-    await em.upsert(`_settings__${pluginId}`, row);
-    if (pluginId === 'core')
+    const fields = group.fields;
+    const existing = await getPluginSettings(groupId);
+    const data = buildSettingsBody(groupId, fields, incoming, existing, group.label);
+    const row = { plugin_id: groupId, ...data };
+    await em.upsert(`_settings__${groupId}`, row);
+    if (groupId === SYSTEM_SETTINGS_ID)
         invalidatePublicUrlCache();
     const masked = maskTree(fields, row);
     em.create('_Event', {
         ts: new Date().toISOString(),
         actor,
         op: 'settings',
-        type: pluginId,
+        type: groupId,
         record_id: null,
         before: JSON.stringify(maskTree(fields, existing)),
         after: JSON.stringify(masked),
@@ -51,13 +49,12 @@ export async function writePluginSettings(em, pluginId, incoming, actor, plugins
     await em.flush();
     return masked;
 }
-export async function listSettings(plugins) {
-    const all = withSettings(plugins ?? (await getPlugins()));
+export async function listSettings(pluginsOverride) {
+    const groups = pluginsOverride ? groupsFromPlugins(pluginsOverride) : await settingsGroups();
     const out = [];
-    for (const p of all) {
-        const fields = p.settings.fields;
-        const values = maskTree(fields, await getPluginSettings(p.id));
-        out.push({ plugin: p.id, label: p.settings.label, fields: describeSettingsFields(fields), values });
+    for (const g of groups) {
+        const values = maskTree(g.fields, await getPluginSettings(g.id));
+        out.push({ group: g.id, label: g.label, fields: describeSettingsFields(g.fields), values });
     }
     return out;
 }

package/dist/system-settings.d.ts

@@ -0,0 +1,3 @@
+import { type SettingsDef } from '@coffer-org/sdk/settings';
+export declare const SYSTEM_SETTINGS_ID = "system";
+export declare const SYSTEM_SETTINGS: SettingsDef;