@coffer-org/server 1.7.1 → 1.8.0

package/dist/plugins-api.js

@@ -1,4 +1,4 @@
-import { join } from 'node:path';
+import { dirname, join, resolve, sep } from 'node:path';
 import { createReadStream, existsSync, readFileSync } from 'node:fs';
 import { discoverPluginAssets, discoverRuntime } from "./plugin-discovery.js";
 import { getPlugins, readDisabled } from "./plugin-runtime.js";
@@ -16,7 +16,7 @@ export async function buildPluginListResponse(plugins, assets, disabled) {
             packageName: a?.packageName ?? null,
             dependsOn: p.dependsOn,
             enabled: !disabled.has(p.id),
-            vaults: (p.vaults ?? []).map((v) => v.meta.id),
+            libraries: (p.libraries ?? []).map((v) => v.meta.id),
             extends: (p.extends_ ?? []).map((e) => e.id),
             hasSettings: Boolean(p.settings && p.settings.fields.length > 0),
             schema: a?.schema,
@@ -39,20 +39,30 @@ export async function registerPluginsApi(app) {
     });
     app.get('/plugins/:id/:file', async (req, reply) => {
         const { id, file } = req.params;
-        const key = ASSET_KEY[file];
-        if (!key)
-            return reply.code(404).send({ error: 'unknown_asset' });
         const rec = (await discoverPluginAssets()).find((a) => a.id === id);
         if (!rec)
             return reply.code(404).send({ error: 'unknown_plugin' });
-        const pkg = JSON.parse(readFileSync(join(nmRoot(), rec.packageName, 'package.json'), 'utf8'));
-        const rel = pkg.coffer?.[key];
-        if (!rel)
-            return reply.code(404).send({ error: 'asset_not_built' });
-        const abs = join(nmRoot(), rec.packageName, rel);
+        const pkgDir = join(nmRoot(), rec.packageName);
+        const pkg = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8'));
+        const key = ASSET_KEY[file];
+        let abs;
+        if (key) {
+            const rel = pkg.coffer?.[key];
+            if (!rel)
+                return reply.code(404).send({ error: 'asset_not_built' });
+            abs = join(pkgDir, rel);
+        }
+        else {
+            if (!/^[\w.-]+\.(js|css)$/.test(file))
+                return reply.code(404).send({ error: 'unknown_asset' });
+            const distDir = resolve(pkgDir, dirname(pkg.coffer?.web ?? pkg.coffer?.schema ?? 'dist/web.js'));
+            abs = resolve(distDir, file);
+            if (abs !== distDir && !abs.startsWith(distDir + sep))
+                return reply.code(404).send({ error: 'unknown_asset' });
+        }
         if (!existsSync(abs))
             return reply.code(404).send({ error: 'asset_missing' });
-        reply.type(file.endsWith('.css') ? 'text/css' : 'text/javascript');
+        reply.type(abs.endsWith('.css') ? 'text/css' : 'text/javascript');
         return reply.send(createReadStream(abs));
     });
 }

package/dist/records-api.d.ts

@@ -1,4 +1,4 @@
-import type { ModuleDef } from '@coffer-org/sdk/module';
+import type { ShelfDef } from '@coffer-org/sdk/shelf';
 export declare class UnknownTypeError extends Error {
 }
 export type RecordListQuery = {
@@ -7,13 +7,13 @@ export type RecordListQuery = {
     [field: string]: string | number | undefined;
 };
 export declare function coerceFilter(v: string, column: string): unknown;
-export declare function withExtends(record: Record<string, unknown>, vault: string, module: string): Promise<Record<string, unknown>>;
-export declare function rowMatch(mdef: ModuleDef, row: Record<string, unknown>, tokens: string[]): {
+export declare function withExtends(record: Record<string, unknown>, library: string, shelf: string): Promise<Record<string, unknown>>;
+export declare function rowMatch(mdef: ShelfDef, row: Record<string, unknown>, tokens: string[]): {
     score: number;
     snippet: string;
 } | null;
-export declare function recordList(vault: string, type: string, query?: RecordListQuery): Promise<Record<string, unknown>[]>;
-export declare function recordGet(vault: string, type: string, id: number): Promise<Record<string, unknown> | null>;
-export declare function recordCreate(vault: string, type: string, body: unknown, actor?: string): Promise<Record<string, unknown>>;
-export declare function recordUpdate(vault: string, type: string, id: number, body: unknown, actor?: string): Promise<Record<string, unknown>>;
-export declare function recordDelete(vault: string, type: string, id: number, actor?: string): Promise<void>;
+export declare function recordList(library: string, type: string, query?: RecordListQuery): Promise<Record<string, unknown>[]>;
+export declare function recordGet(library: string, type: string, id: number): Promise<Record<string, unknown> | null>;
+export declare function recordCreate(library: string, type: string, body: unknown, actor?: string): Promise<Record<string, unknown>>;
+export declare function recordUpdate(library: string, type: string, id: number, body: unknown, actor?: string): Promise<Record<string, unknown>>;
+export declare function recordDelete(library: string, type: string, id: number, actor?: string): Promise<void>;

package/dist/records-api.js

@@ -1,20 +1,20 @@
-import { fieldMap, textSearchKeys, titleKey, recordTitle } from '@coffer-org/sdk/module';
+import { fieldMap, textSearchKeys, titleKey, recordTitle } from '@coffer-org/sdk/shelf';
 import { tokenize, matchScoreFolded, foldText } from '@coffer-org/core/search';
 import { serialize } from '@mikro-orm/core';
-import { getModule, getExtendsFor } from "./registry-context.js";
-import { moduleTableName } from "./entity-schema.js";
+import { getShelf, getExtendsFor } from "./registry-context.js";
+import { shelfTableName } from "./entity-schema.js";
 import { getExtendRecord } from "./extend-table.js";
 import { getEm } from "./db.js";
 import { decodeTemporal, dtStringToDate } from "./temporal.js";
-import { splitBody, saveExtends, deleteExtends, validateExtends } from "./extend-io.js";
+import { splitBody, saveExtends, deleteExtends, validateExtends, readExtends } from "./extend-io.js";
 import { createRecord, updateRecord, getRecord, deleteRecord } from "./mutate.js";
 export class UnknownTypeError extends Error {
 }
-function resolve(vault, type) {
-    const m = getModule(vault, type);
+function resolve(library, type) {
+    const m = getShelf(library, type);
     if (!m)
-        throw new UnknownTypeError(`unknown_type ${vault}/${type}`);
-    return { m, ename: moduleTableName(m.vault, m.module) };
+        throw new UnknownTypeError(`unknown_type ${library}/${type}`);
+    return { m, ename: shelfTableName(m.library, m.shelf) };
 }
 export function coerceFilter(v, column) {
     if (column === 'integer' || column === 'real') {
@@ -27,8 +27,8 @@ export function coerceFilter(v, column) {
         return dtStringToDate(v);
     return v;
 }
-export async function withExtends(record, vault, module) {
-    const matchedExtends = getExtendsFor(vault, module);
+export async function withExtends(record, library, shelf) {
+    const matchedExtends = getExtendsFor(library, shelf);
     if (!matchedExtends.length)
         return record;
     const _extends = {};
@@ -54,8 +54,8 @@ export function rowMatch(mdef, row, tokens) {
     const snippet = raw.length > 120 ? raw.slice(0, 120) + '…' : raw;
     return { score, snippet };
 }
-export async function recordList(vault, type, query = {}) {
-    const { m, ename } = resolve(vault, type);
+export async function recordList(library, type, query = {}) {
+    const { m, ename } = resolve(library, type);
     const { q, ...filterParams } = query;
     const where = {};
     const fm = fieldMap(m.fields);
@@ -82,35 +82,38 @@ export async function recordList(vault, type, query = {}) {
     if (tokens.length > 0)
         rows = rows.filter((row) => rowMatch(m, row, tokens) !== null);
     const decoded = rows.map((r) => decodeTemporal(m, r));
-    return Promise.all(decoded.map((row) => withExtends(row, vault, type)));
+    return Promise.all(decoded.map((row) => withExtends(row, library, type)));
 }
-export async function recordGet(vault, type, id) {
-    const { m, ename } = resolve(vault, type);
+export async function recordGet(library, type, id) {
+    const { m, ename } = resolve(library, type);
     if (m.standalone === false)
         return null;
     const row = await getRecord(m, ename, id);
     if (!row)
         return null;
-    return withExtends(row, vault, type);
+    return withExtends(row, library, type);
 }
-export async function recordCreate(vault, type, body, actor = 'gui') {
-    const { m, ename } = resolve(vault, type);
+export async function recordCreate(library, type, body, actor = 'gui') {
+    const { m, ename } = resolve(library, type);
     const { base, extData } = splitBody(body);
-    validateExtends(vault, type, extData);
-    const row = await createRecord(m, ename, base, { actor });
-    await saveExtends(vault, type, row.id, extData);
-    return withExtends(row, vault, type);
+    validateExtends(library, type, extData);
+    const row = await createRecord(m, ename, base, { actor }, async (tx, id) => {
+        await saveExtends(tx, library, type, id, extData);
+        return readExtends(tx, library, type, id);
+    });
+    return withExtends(row, library, type);
 }
-export async function recordUpdate(vault, type, id, body, actor = 'gui') {
-    const { m, ename } = resolve(vault, type);
+export async function recordUpdate(library, type, id, body, actor = 'gui') {
+    const { m, ename } = resolve(library, type);
     const { base, extData } = splitBody(body);
-    validateExtends(vault, type, extData);
-    const row = await updateRecord(m, ename, id, base, { actor });
-    await saveExtends(vault, type, id, extData);
-    return withExtends(row, vault, type);
+    validateExtends(library, type, extData);
+    const row = await updateRecord(m, ename, id, base, { actor }, async (tx) => {
+        await saveExtends(tx, library, type, id, extData);
+        return readExtends(tx, library, type, id);
+    });
+    return withExtends(row, library, type);
 }
-export async function recordDelete(vault, type, id, actor = 'gui') {
-    const { m, ename } = resolve(vault, type);
-    await deleteRecord(m, ename, id, { actor });
-    await deleteExtends(vault, type, id);
+export async function recordDelete(library, type, id, actor = 'gui') {
+    const { m, ename } = resolve(library, type);
+    await deleteRecord(m, ename, id, { actor }, (tx) => deleteExtends(tx, library, type, id));
 }

package/dist/registry-context.d.ts

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

package/dist/registry-context.js

@@ -10,5 +10,5 @@ function current() {
 export function getActiveRegistry() {
     return current();
 }
-export const getModule = (vault, module) => current().getModule(vault, module);
-export const getExtendsFor = (vault, module) => current().getExtendsFor(vault, module);
+export const getShelf = (library, shelf) => current().getShelf(library, shelf);
+export const getExtendsFor = (library, shelf) => current().getExtendsFor(library, shelf);

package/dist/schema-api.js

@@ -1,11 +1,11 @@
-import { moduleToClient } from '@coffer-org/sdk/module';
+import { shelfToClient } from '@coffer-org/sdk/shelf';
 import { extendToClient } from '@coffer-org/sdk/extend';
 import { getActiveRegistry } from "./registry-context.js";
 export function buildClientSchema() {
-    const { vaults, extends_ } = getActiveRegistry();
-    return vaults.map((v) => ({
+    const { libraries, extends_ } = getActiveRegistry();
+    return libraries.map((v) => ({
         ...v.meta,
-        modules: v.modules.map(moduleToClient),
-        extends: extends_.filter((e) => e.attachTo.some((r) => r.vault === v.meta.id)).map(extendToClient),
+        shelves: v.shelves.map(shelfToClient),
+        extends: extends_.filter((e) => e.attachTo.some((r) => r.library === v.meta.id)).map(extendToClient),
     }));
 }

package/dist/settings-write.d.ts

@@ -0,0 +1,19 @@
+import type { LayoutEl } from '@coffer-org/sdk/fields';
+import type { EntityManager } from '@mikro-orm/core';
+import type { PluginManifest } from '@coffer-org/sdk/plugin';
+export interface SettingsFieldInfo {
+    key: string;
+    kind: string;
+    label?: string;
+    required: boolean;
+    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;
+    label: string;
+    fields: SettingsFieldInfo[];
+    values: Record<string, unknown>;
+}[]>;

package/dist/settings-write.js

@@ -0,0 +1,60 @@
+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";
+export function describeSettingsFields(fields) {
+    return fieldEntries(fields).map(([key, f]) => ({
+        key,
+        kind: f.kind,
+        label: f.label,
+        required: f.required === true,
+        ...(f.options ? { options: f.options.map((o) => o.value) } : {}),
+    }));
+}
+function settingsShelf(pluginId, fields) {
+    return { library: '_settings', shelf: pluginId, label: `${pluginId}.plugin.label`, fields };
+}
+export function buildSettingsBody(pluginId, fields, incoming, existing) {
+    const body = preserveTree(fields, incoming, existing);
+    const parsed = buildZodObject(settingsShelf(pluginId, fields)).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) {
+        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);
+    const masked = maskTree(fields, row);
+    em.create('_Event', {
+        ts: new Date().toISOString(),
+        actor,
+        op: 'settings',
+        type: pluginId,
+        record_id: null,
+        before: JSON.stringify(maskTree(fields, existing)),
+        after: JSON.stringify(masked),
+    });
+    await em.flush();
+    return masked;
+}
+export async function listSettings(plugins) {
+    const all = withSettings(plugins ?? (await getPlugins()));
+    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 });
+    }
+    return out;
+}

package/dist/temporal.d.ts

@@ -1,5 +1,5 @@
-import type { ModuleDef } from '@coffer-org/sdk/module';
+import type { ShelfDef } from '@coffer-org/sdk/shelf';
 export declare function dtStringToDate(s: string): Date;
 export declare function dateToDtString(d: Date): string;
-export declare function encodeTemporal(m: ModuleDef, row: Record<string, unknown>): Record<string, unknown>;
-export declare function decodeTemporal(m: ModuleDef, row: Record<string, unknown>): Record<string, unknown>;
+export declare function encodeTemporal(m: ShelfDef, row: Record<string, unknown>): Record<string, unknown>;
+export declare function decodeTemporal(m: ShelfDef, row: Record<string, unknown>): Record<string, unknown>;

package/dist/temporal.js

@@ -1,4 +1,4 @@
-import { fieldMap } from '@coffer-org/sdk/module';
+import { fieldMap } from '@coffer-org/sdk/shelf';
 export function dtStringToDate(s) {
     return new Date(`${s}:00Z`);
 }

package/dist/thread-store.d.ts

@@ -0,0 +1,20 @@
+export interface StoredMsg {
+    msgId: string;
+    role: 'user' | 'assistant';
+    sender: string | null;
+    text: string;
+    ts: number;
+    replyToId: string | null;
+}
+export declare function getThreadMessage(connector: string, chatId: string, msgId: string): Promise<StoredMsg | null>;
+export declare function putThreadMessage(m: {
+    connector: string;
+    chatId: string;
+    msgId: string;
+    role: 'user' | 'assistant';
+    sender?: string | null;
+    text: string;
+    ts: number;
+    replyToId: string | null;
+}): Promise<void>;
+export declare function pruneThreadMessages(connector: string, cutoffTs: number): Promise<void>;

package/dist/thread-store.js

@@ -0,0 +1,27 @@
+import { getEm } from "./db.js";
+function toStored(r) {
+    return { msgId: r.msg_id, role: r.role, sender: r.sender, text: r.text, ts: r.ts, replyToId: r.reply_to_id };
+}
+export async function getThreadMessage(connector, chatId, msgId) {
+    const em = getEm().fork();
+    const row = (await em.findOne('_ThreadMessage', { connector, chat_id: chatId, msg_id: msgId }));
+    return row ? toStored(row) : null;
+}
+export async function putThreadMessage(m) {
+    const em = getEm().fork();
+    await em.upsert('_ThreadMessage', {
+        connector: m.connector,
+        chat_id: m.chatId,
+        msg_id: m.msgId,
+        role: m.role,
+        sender: m.sender ?? null,
+        text: m.text,
+        ts: m.ts,
+        reply_to_id: m.replyToId,
+    });
+    await em.flush();
+}
+export async function pruneThreadMessages(connector, cutoffTs) {
+    const em = getEm().fork();
+    await em.nativeDelete('_ThreadMessage', { connector, ts: { $lt: cutoffTs } });
+}

package/dist/uploads.d.ts

@@ -2,3 +2,4 @@ export declare function uploadsDir(): string;
 export declare function seedAsset(absPath: string): {
     name: string;
 };
+export declare function seedAssetPath(metaUrl: string): (rel: string) => string;

package/dist/uploads.js

@@ -1,5 +1,6 @@
 import { copyFileSync, mkdirSync } from 'node:fs';
 import { basename, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 export function uploadsDir() {
     const dir = process.env.UPLOADS ?? join(process.cwd(), 'data', 'uploads');
     mkdirSync(dir, { recursive: true });
@@ -10,3 +11,6 @@ export function seedAsset(absPath) {
     copyFileSync(absPath, join(uploadsDir(), name));
     return { name };
 }
+export function seedAssetPath(metaUrl) {
+    return (rel) => fileURLToPath(new URL(`../../seed/assets/${rel}`, metaUrl));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -24,14 +24,14 @@
     "postpack": "node ../../scripts/swap-exports.mjs src"
   },
   "dependencies": {
-    "@coffer-org/core": "^1.3.0",
-    "@coffer-org/sdk": "^1.4.0",
+    "@coffer-org/core": "^1.4.0",
+    "@coffer-org/sdk": "^1.5.0",
     "@extractus/oembed-extractor": "^4.1.0",
     "@fastify/cors": "^11.2.0",
     "@fastify/multipart": "^10.0.0",
     "@fastify/static": "^9.1.3",
-    "@mikro-orm/core": "^7.1.4",
-    "@mikro-orm/sqlite": "^7.1.4",
+    "@mikro-orm/core": "^7.1.6",
+    "@mikro-orm/sqlite": "^7.1.6",
     "fastify": "^5.2.1",
     "open-graph-scraper": "^6.11.0",
     "pino": "^9.14.0",
@@ -39,6 +39,6 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@mikro-orm/postgresql": "7.1.4"
+    "@mikro-orm/postgresql": "^7.1.6"
   }
 }