@coffer-org/server 1.14.0 → 2.1.0

package/dist/migrations.js

@@ -179,8 +179,31 @@ export function makeTable(em, table) {
                 throw e;
             }
         },
+        async dropColumn(column) {
+            const info = await introspectTable(em, table);
+            if (!info.exists || !info.columns.has(column))
+                return;
+            if (dialectOf(em) === 'sqlite') {
+                const idxList = (await conn.execute(`PRAGMA index_list(${q(table)})`));
+                for (const idx of idxList) {
+                    const info = (await conn.execute(`PRAGMA index_info(${q(idx.name)})`));
+                    if (!info.some((c) => c.name === column))
+                        continue;
+                    const meta = (await conn.execute(`SELECT sql FROM sqlite_master WHERE type='index' AND name=?`, [
+                        idx.name,
+                    ]));
+                    const sql = meta[0]?.sql;
+                    if (sql !== null)
+                        await conn.execute(`DROP INDEX ${q(idx.name)}`);
+                }
+            }
+            await conn.execute(`ALTER TABLE ${T} DROP COLUMN ${q(column)}`);
+        },
     };
 }
+export async function renameSystemShelfKey(em) {
+    await makeTable(em, '_embeddings').renameColumn('type', 'shelf_key');
+}
 export function validateMigrations(pluginId, list) {
     const versions = list.map((m) => m.version).sort((a, b) => a - b);
     versions.forEach((v, i) => {

package/dist/mutate.d.ts

@@ -1,6 +1,7 @@
 import type { EntityManager } from '@mikro-orm/core';
 import type { ShelfDef } from '@coffer-org/sdk/shelf';
 import { z } from 'zod';
+export declare function encodeJson(m: ShelfDef, data: Record<string, unknown>): Record<string, unknown>;
 export interface MutateCtx {
     actor: string;
 }

package/dist/mutate.js

@@ -3,13 +3,14 @@ import { buildZodObject, buildZodObjectPartial, fieldEntries } from '@coffer-org
 import { isJsonStored, decodeVmsg } from '@coffer-org/sdk/fields';
 import { resolveFlag } from '@coffer-org/sdk/condition';
 import { getEm } from "./db.js";
+import { normalizeFileFields, dropUnchangedFileFields, touchesFileFields } from "./file-fields.js";
 import { notifyRecordsChanged } from "./index-signal.js";
 import { encodeTemporal, decodeTemporal } from "./temporal.js";
 import { splitCollections, writeCollections, deleteCollections, flattenEmbedded, nestEmbedded, readCollections, } from "./collection-io.js";
 function nowIso() {
     return new Date().toISOString();
 }
-function encodeJson(m, data) {
+export function encodeJson(m, data) {
     const out = { ...data };
     for (const [k, f] of fieldEntries(m.fields)) {
         if (isJsonStored(f) && out[k] !== null && out[k] !== undefined && typeof out[k] === 'object') {
@@ -70,6 +71,9 @@ export async function createRecord(m, entityName, input, ctx, afterBase) {
         throw new ValidationError(parsed.error.issues.map(toIssue));
     const ts = nowIso();
     const parsedData = parsed.data;
+    const fileIssues = normalizeFileFields(m, parsedData);
+    if (fileIssues.length)
+        throw new ValidationError(fileIssues);
     const { base, collections } = splitCollections(m, { ...parsedData });
     const data = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...base, created_at: ts, updated_at: ts })));
     let id;
@@ -91,7 +95,16 @@ export async function createRecord(m, entityName, input, ctx, afterBase) {
     return { ...parsedData, id, created_at: ts, updated_at: ts };
 }
 export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
-    const parsed = buildZodObjectPartial(m).safeParse(input);
+    let patch = input;
+    if (touchesFileFields(m, input)) {
+        const prior = await getEm()
+            .fork()
+            .findOne(entityName, { id });
+        if (!prior)
+            throw new NotFoundError();
+        patch = dropUnchangedFileFields(m, input, serialize(prior));
+    }
+    const parsed = buildZodObjectPartial(m).safeParse(patch);
     if (!parsed.success)
         throw new ValidationError(parsed.error.issues.map(toIssue));
     let result;
@@ -105,6 +118,9 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
         const existing = nestEmbedded(m, existingFlat);
         const ts = nowIso();
         const { base, collections } = splitCollections(m, { ...parsed.data });
+        const fileIssues = normalizeFileFields(m, base);
+        if (fileIssues.length)
+            throw new ValidationError(fileIssues);
         const merged = { ...existing, ...base };
         const reqIssues = [];
         for (const [key, f] of fieldEntries(m.fields)) {

package/dist/plugin-hooks.d.ts

@@ -13,6 +13,7 @@ export interface TableOps {
         transform?: (old: unknown) => unknown;
     }): Promise<void>;
     convert(c: ColumnConversion): Promise<void>;
+    dropColumn(column: string): Promise<void>;
 }
 export interface MigrationCtx {
     table(name: string): TableOps;
@@ -47,6 +48,16 @@ export declare class HttpError extends Error {
     status: number;
     constructor(status: number, message: string);
 }
+export interface ActionCaller {
+    id: string;
+    role: AuthRole;
+}
+export type PluginUserAction = (body: Record<string, unknown>, caller: ActionCaller) => Promise<unknown>;
+export type PluginStreamAction = (body: Record<string, unknown>, ctx: {
+    caller: ActionCaller;
+    emit: (event: string, data: unknown) => void;
+    signal: AbortSignal;
+}) => Promise<void>;
 export interface PluginHooks {
     migrations?: Migration[];
     seed?: Seed[];
@@ -55,5 +66,7 @@ export interface PluginHooks {
     agent?: AgentContribution;
     backgroundTasks?: import('./background-scheduler.ts').BackgroundTask[];
     actions?: Record<string, PluginAction>;
+    userActions?: Record<string, PluginUserAction>;
+    streamActions?: Record<string, PluginStreamAction>;
 }
 export declare const pluginHooks: Record<string, PluginHooks>;

package/dist/plugin-runtime.d.ts

@@ -2,6 +2,7 @@ import { type Registry } from '@coffer-org/core/compose';
 import type { PluginManifest } from '@coffer-org/sdk/plugin';
 export declare function getPlugins(): Promise<PluginManifest[]>;
 export declare function readDisabled(): Promise<Set<string>>;
+export declare function getDisabled(): Promise<Set<string>>;
 export declare function getPluginSettings(pluginId: string): Promise<Record<string, unknown>>;
 export declare function requireSettings<K extends string>(pluginId: string, keys: readonly K[]): Promise<Record<K, string>>;
 export declare function initStorage(): Promise<Set<string>>;

package/dist/plugin-runtime.js

@@ -6,12 +6,15 @@ import { syncSchema } from "./schema-sync.js";
 import { systemEntities, buildPluginEntities, shelfTableName } from "./entity-schema.js";
 import { pluginHooks, pluginCtx, HttpError } from "./plugin-hooks.js";
 import { discoverPlugins, loadServerHooks } from "./plugin-discovery.js";
-import { runMigrations, assertSafeRequired } from "./migrations.js";
+import { runMigrations, assertSafeRequired, renameSystemShelfKey } 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";
 const log = getLogger('plugins');
+let stopSearchIndexer;
 let _plugins = null;
 export async function getPlugins() {
     return (_plugins ??= await discoverPlugins());
@@ -23,6 +26,13 @@ export async function readDisabled() {
     disabled.delete('core');
     return disabled;
 }
+let _disabled = null;
+export function getDisabled() {
+    return (_disabled ??= readDisabled().catch((e) => {
+        _disabled = null;
+        throw e;
+    }));
+}
 export async function getPluginSettings(pluginId) {
     try {
         const fork = getEm().fork();
@@ -66,11 +76,13 @@ async function seedPluginRows() {
 }
 export async function initStorage() {
     await initDb(systemEntities);
+    await renameSystemShelfKey(getEm().fork());
     await syncSchema();
     await migrateEmbeddingVectorsToBlob();
     await getEm().fork().getConnection().execute('DROP TABLE IF EXISTS "_folders"');
     await seedPluginRows();
     const disabled = await readDisabled();
+    _disabled = Promise.resolve(disabled);
     const active = (await getPlugins()).filter((p) => !disabled.has(p.id));
     const hooks = await loadServerHooks();
     await runMigrations({
@@ -83,6 +95,7 @@ export async function initStorage() {
     if (pluginEntities.length)
         getOrm().discoverEntity(pluginEntities);
     await syncSchema();
+    await ensureSearchTable();
     return disabled;
 }
 export async function initPlugins() {
@@ -107,6 +120,14 @@ export async function initPlugins() {
             throw err;
         }
     }
+    stopSearchIndexer = startSearchIndexer();
+    bgTasks.push({
+        name: 'core:search-index',
+        intervalMs: 300_000,
+        run: async () => {
+            await indexSearchOnce();
+        },
+    });
     startScheduler(bgTasks);
     if (bgTasks.length)
         log.debug(`scheduler: ${bgTasks.length} background task(s): ${bgTasks.map((t) => t.name).join(' ')}`);
@@ -115,6 +136,8 @@ export async function initPlugins() {
     return reg;
 }
 export async function teardownPlugins() {
+    stopSearchIndexer?.();
+    stopSearchIndexer = undefined;
     stopScheduler();
     Object.assign(pluginHooks, await loadServerHooks());
     const disabled = await readDisabled();

package/dist/plugin-user-api.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import { type PluginHooks } from './plugin-hooks.ts';
+export declare function registerPluginAdminApi(app: FastifyInstance, requireAdmin: (req: FastifyRequest, reply: FastifyReply) => boolean, hooks?: Record<string, PluginHooks>, disabledSet?: () => Promise<Set<string>>): void;
+export declare function registerPluginUserApi(app: FastifyInstance, hooks?: Record<string, PluginHooks>, disabledSet?: () => Promise<Set<string>>): void;

package/dist/plugin-user-api.js

@@ -0,0 +1,92 @@
+import { pluginHooks, HttpError } from "./plugin-hooks.js";
+import { getDisabled } from "./plugin-runtime.js";
+import { ValidationError } from "./mutate.js";
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('plugin-user-api');
+const HEARTBEAT_MS = 15_000;
+function caller(req) {
+    return { id: String(req.user.id), role: req.user.role };
+}
+function openSse(raw, signal) {
+    raw.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive',
+        'x-accel-buffering': 'no',
+    });
+    return (event, data) => {
+        if (signal.aborted || raw.destroyed)
+            return;
+        raw.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+    };
+}
+function actionError(e, reply) {
+    if (e instanceof ValidationError) {
+        const detail = e.issues.map((i) => `${i.path.join('.') || i.field}: ${i.code}`).join('; ');
+        return reply.code(422).send({ error: `Validation error — ${detail}`, issues: e.issues });
+    }
+    if (e instanceof HttpError)
+        return reply.code(e.status).send({ error: e.message });
+    return reply.code(400).send({ error: e.message });
+}
+export function registerPluginAdminApi(app, requireAdmin, hooks = pluginHooks, disabledSet = getDisabled) {
+    app.post('/api/plugins/:id/:action', async (req, reply) => {
+        if (!requireAdmin(req, reply))
+            return;
+        const { id, action } = req.params;
+        const fn = (await disabledSet()).has(id) ? undefined : hooks[id]?.actions?.[action];
+        if (!fn)
+            return reply.code(404).send({ error: `unknown action ${id}/${action}` });
+        try {
+            return await fn((req.body ?? {}));
+        }
+        catch (e) {
+            return actionError(e, reply);
+        }
+    });
+}
+export function registerPluginUserApi(app, hooks = pluginHooks, disabledSet = getDisabled) {
+    async function isOff(id) {
+        return (await disabledSet()).has(id);
+    }
+    app.post('/api/plugins/:id/user/:action', async (req, reply) => {
+        const { id, action } = req.params;
+        const fn = (await isOff(id)) ? undefined : hooks[id]?.userActions?.[action];
+        if (!fn)
+            return reply.code(404).send({ error: `unknown user action ${id}/${action}` });
+        try {
+            return await fn((req.body ?? {}), caller(req));
+        }
+        catch (e) {
+            return actionError(e, reply);
+        }
+    });
+    app.post('/api/plugins/:id/user/:action/stream', async (req, reply) => {
+        const { id, action } = req.params;
+        const fn = (await isOff(id)) ? undefined : hooks[id]?.streamActions?.[action];
+        if (!fn)
+            return reply.code(404).send({ error: `unknown stream action ${id}/${action}` });
+        reply.hijack();
+        const ctl = new AbortController();
+        reply.raw.on('close', () => ctl.abort());
+        const emit = openSse(reply.raw, ctl.signal);
+        const beat = setInterval(() => {
+            if (ctl.signal.aborted || reply.raw.destroyed)
+                return clearInterval(beat);
+            reply.raw.write(':\n\n');
+        }, HEARTBEAT_MS);
+        beat.unref?.();
+        try {
+            await fn((req.body ?? {}), { caller: caller(req), emit, signal: ctl.signal });
+        }
+        catch (e) {
+            log.error(`stream action ${id}/${action} failed: ${e.message}`);
+            emit('error', { message: e.message });
+        }
+        finally {
+            clearInterval(beat);
+            if (!ctl.signal.aborted && !reply.raw.destroyed)
+                reply.raw.end();
+        }
+    });
+}

package/dist/public-url.d.ts

@@ -1,4 +1,5 @@
 import type { FastifyRequest } from 'fastify';
 export declare function invalidatePublicUrlCache(): void;
+export declare function configuredPublicUrl(): Promise<string>;
 export declare function baseUrl(req: FastifyRequest): Promise<string>;
 export declare function mcpResource(req: FastifyRequest): Promise<string>;

package/dist/public-url.js

@@ -22,8 +22,11 @@ async function configuredBase() {
     cached = { value, readAt: Date.now() };
     return value;
 }
+export async function configuredPublicUrl() {
+    return configuredBase();
+}
 export async function baseUrl(req) {
-    const configured = await configuredBase();
+    const configured = await configuredPublicUrl();
     if (configured)
         return configured;
     const proto = req.headers['x-forwarded-proto']?.split(',')[0]?.trim() ?? req.protocol;

package/dist/records-api.d.ts

@@ -1,5 +1,5 @@
 import type { ShelfDef } from '@coffer-org/sdk/shelf';
-export declare class UnknownTypeError extends Error {
+export declare class UnknownShelfError extends Error {
 }
 export type RecordListQuery = {
     q?: string;
@@ -9,7 +9,11 @@ export type RecordListQuery = {
 export type RecordListOpts = {
     view?: 'list' | 'full';
     extends?: boolean;
+    limit?: number;
+    offset?: number;
+    orderBy?: Record<string, 'ASC' | 'DESC'>;
 };
+export declare const MAX_PAGE = 500;
 export declare function coerceFilter(v: string, column: string): unknown;
 export declare function withExtends(record: Record<string, unknown>, library: string, shelf: string): Promise<Record<string, unknown>>;
 export declare function withExtendsMany(rows: Record<string, unknown>[], library: string, shelf: string): Promise<Record<string, unknown>[]>;
@@ -17,8 +21,14 @@ export declare function rowMatch(mdef: ShelfDef, row: Record<string, unknown>, t
     score: number;
     snippet: string;
 } | null;
-export declare function recordList(library: string, type: string, query?: RecordListQuery, opts?: RecordListOpts): 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>;
+export declare function recordCount(library: string, shelf: string, query?: RecordListQuery): Promise<number>;
+export declare function recordList(library: string, shelf: string, query?: RecordListQuery, opts?: RecordListOpts): Promise<Record<string, unknown>[]>;
+export declare function isPagedRequest(limit?: string, offset?: string): boolean;
+export declare function recordListPage(library: string, shelf: string, query?: RecordListQuery, opts?: RecordListOpts): Promise<{
+    rows: Record<string, unknown>[];
+    total: number;
+}>;
+export declare function recordGet(library: string, shelf: string, id: number): Promise<Record<string, unknown> | null>;
+export declare function recordCreate(library: string, shelf: string, body: unknown, actor?: string): Promise<Record<string, unknown>>;
+export declare function recordUpdate(library: string, shelf: string, id: number, body: unknown, actor?: string): Promise<Record<string, unknown>>;
+export declare function recordDelete(library: string, shelf: string, id: number, actor?: string): Promise<void>;

package/dist/records-api.js

@@ -8,8 +8,9 @@ import { getEm } from "./db.js";
 import { decodeTemporal, dtStringToDate } from "./temporal.js";
 import { splitBody, saveExtends, deleteExtends, validateExtends, readExtends } from "./extend-io.js";
 import { createRecord, updateRecord, getRecord, deleteRecord } from "./mutate.js";
-export class UnknownTypeError extends Error {
+export class UnknownShelfError extends Error {
 }
+export const MAX_PAGE = 500;
 function pickCols(row, cols) {
     const out = {};
     for (const c of cols)
@@ -17,10 +18,10 @@ function pickCols(row, cols) {
             out[c] = row[c];
     return out;
 }
-function resolve(library, type) {
-    const m = getShelf(library, type);
+function resolve(library, shelf) {
+    const m = getShelf(library, shelf);
     if (!m)
-        throw new UnknownTypeError(`unknown_type ${library}/${type}`);
+        throw new UnknownShelfError(`unknown_shelf ${library}/${shelf}`);
     return { m, ename: shelfTableName(m.library, m.shelf) };
 }
 export function coerceFilter(v, column) {
@@ -77,10 +78,7 @@ export function rowMatch(mdef, row, tokens) {
     const snippet = raw.length > 120 ? raw.slice(0, 120) + '…' : raw;
     return { score, snippet };
 }
-export async function recordList(library, type, query = {}, opts = {}) {
-    const { view = 'full', extends: withExt = true } = opts;
-    const { m, ename } = resolve(library, type);
-    const { q, ...filterParams } = query;
+function buildWhere(m, filterParams) {
     const where = {};
     const fm = fieldMap(m.fields);
     for (const [k, v] of Object.entries(filterParams)) {
@@ -90,23 +88,46 @@ export async function recordList(library, type, query = {}, opts = {}) {
         if (fieldDef && !fieldDef.virtual)
             where[k] = coerceFilter(String(v), fieldDef.column);
     }
-    if (filterParams.id) {
-        const ids = String(filterParams.id)
+    if (filterParams['id']) {
+        const ids = String(filterParams['id'])
             .split(',')
             .map((s) => Number(s.trim()))
             .filter((n) => !Number.isNaN(n));
         if (ids.length)
             where['id'] = ids.length === 1 ? ids[0] : { $in: ids };
     }
+    return where;
+}
+export async function recordCount(library, shelf, query = {}) {
+    const { m, ename } = resolve(library, shelf);
+    const { q: _q, ...filterParams } = query;
+    const where = buildWhere(m, filterParams);
+    if (m.standalone === false && Object.keys(where).length === 0)
+        return 0;
+    return getEm().fork().count(ename, where);
+}
+export async function recordList(library, shelf, query = {}, opts = {}) {
+    const { view = 'full', extends: withExt = true } = opts;
+    const { m, ename } = resolve(library, shelf);
+    const { q, ...filterParams } = query;
+    const where = buildWhere(m, filterParams);
     if (m.standalone === false && Object.keys(where).length === 0)
         return [];
     const fork = getEm().fork();
     const tokens = typeof q === 'string' && q ? tokenize(q) : [];
     const projected = view === 'list' ? storageColumnsFor(m, listKeys(m)) : null;
-    const findOpts = projected
-        ? { fields: tokens.length ? [...new Set([...projected, ...storageColumnsFor(m, textSearchKeys(m))])] : projected }
+    const fields = projected
+        ? tokens.length
+            ? [...new Set([...projected, ...storageColumnsFor(m, textSearchKeys(m))])]
+            : projected
         : undefined;
-    let rows = (await fork.find(ename, where, findOpts)).map((r) => serialize(r));
+    const sqlSlice = tokens.length === 0 && opts.limit !== undefined;
+    const findOpts = {
+        ...(fields ? { fields } : {}),
+        ...(opts.orderBy ? { orderBy: opts.orderBy } : {}),
+        ...(sqlSlice ? { limit: opts.limit, offset: Math.max(0, opts.offset ?? 0) } : {}),
+    };
+    let rows = (await fork.find(ename, where, (Object.keys(findOpts).length ? findOpts : undefined))).map((r) => serialize(r));
     if (tokens.length > 0)
         rows = rows.filter((row) => rowMatch(m, row, tokens) !== null);
     if (projected)
@@ -114,38 +135,61 @@ export async function recordList(library, type, query = {}, opts = {}) {
     const decoded = rows.map((r) => decodeTemporal(m, r));
     if (!withExt)
         return decoded;
-    return withExtendsMany(decoded, library, type);
+    return withExtendsMany(decoded, library, shelf);
+}
+export function isPagedRequest(limit, offset) {
+    return [limit, offset].some((v) => v !== undefined && v.trim() !== '' && Number.isFinite(Number(v)));
+}
+export async function recordListPage(library, shelf, query = {}, opts = {}) {
+    const rawLimit = Number.isFinite(opts.limit) ? Math.trunc(opts.limit) : MAX_PAGE;
+    const limit = Math.min(Math.max(1, rawLimit), MAX_PAGE);
+    const rawOffset = Number.isFinite(opts.offset) ? Math.trunc(opts.offset) : 0;
+    const offset = Math.max(0, rawOffset);
+    const hasQ = typeof query.q === 'string' && query.q.length > 0;
+    const orderBy = opts.orderBy ?? { id: 'ASC' };
+    if (hasQ) {
+        const all = await recordList(library, shelf, query, {
+            ...opts,
+            orderBy,
+            limit: undefined,
+            offset: undefined,
+        });
+        return { rows: all.slice(offset, offset + limit), total: all.length };
+    }
+    const rows = await recordList(library, shelf, query, { ...opts, orderBy, limit, offset });
+    const total = await recordCount(library, shelf, query);
+    return { rows, total };
 }
-export async function recordGet(library, type, id) {
-    const { m, ename } = resolve(library, type);
+export async function recordGet(library, shelf, id) {
+    const { m, ename } = resolve(library, shelf);
     if (m.standalone === false)
         return null;
     const row = await getRecord(m, ename, id);
     if (!row)
         return null;
-    return withExtends(row, library, type);
+    return withExtends(row, library, shelf);
 }
-export async function recordCreate(library, type, body, actor = 'gui') {
-    const { m, ename } = resolve(library, type);
+export async function recordCreate(library, shelf, body, actor = 'gui') {
+    const { m, ename } = resolve(library, shelf);
     const { base, extData } = splitBody(body);
-    validateExtends(library, type, extData);
+    validateExtends(library, shelf, 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);
+        await saveExtends(tx, library, shelf, id, extData);
+        return readExtends(tx, library, shelf, id);
     });
-    return withExtends(row, library, type);
+    return withExtends(row, library, shelf);
 }
-export async function recordUpdate(library, type, id, body, actor = 'gui') {
-    const { m, ename } = resolve(library, type);
+export async function recordUpdate(library, shelf, id, body, actor = 'gui') {
+    const { m, ename } = resolve(library, shelf);
     const { base, extData } = splitBody(body);
-    validateExtends(library, type, extData);
+    validateExtends(library, shelf, 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);
+        await saveExtends(tx, library, shelf, id, extData);
+        return readExtends(tx, library, shelf, id);
     });
-    return withExtends(row, library, type);
+    return withExtends(row, library, shelf);
 }
-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));
+export async function recordDelete(library, shelf, id, actor = 'gui') {
+    const { m, ename } = resolve(library, shelf);
+    await deleteRecord(m, ename, id, { actor }, (tx) => deleteExtends(tx, library, shelf, id));
 }

package/dist/search-index.d.ts

@@ -0,0 +1,10 @@
+import type { ShelfDef } from '@coffer-org/sdk/shelf';
+export declare const SEARCH_SEPARATOR = "\n";
+export declare const MIN_FTS_QUERY_LENGTH = 3;
+export declare function ftsAvailable(): boolean;
+export declare function foldedTextFor(m: ShelfDef, record: Record<string, unknown>): string;
+export declare function buildFtsMatchQuery(tokens: string[]): string;
+export declare function ensureSearchTable(): Promise<void>;
+export declare function upsertSearchRow(shelf: string, recordId: number, folded: string): Promise<void>;
+export declare function deleteSearchRow(shelf: string, recordId: number): Promise<void>;
+export declare function ftsCandidates(tokens: string[]): Promise<Map<string, number[]> | null>;

package/dist/search-index.js

@@ -0,0 +1,100 @@
+import { textSearchKeys, titleKey } from '@coffer-org/sdk/shelf';
+import { foldText } from '@coffer-org/core/search';
+import { getLogger } from '@coffer-org/sdk/logger';
+import { getEm } from "./db.js";
+import { getDialect } from "./dialect.js";
+import { flattenEmbedded } from "./collection-io.js";
+import { encodeJson } from "./mutate.js";
+const log = getLogger('search-index');
+export const SEARCH_SEPARATOR = '\n';
+export const MIN_FTS_QUERY_LENGTH = 3;
+let ftsUnsupported = false;
+export function ftsAvailable() {
+    if (ftsUnsupported)
+        return false;
+    try {
+        return getDialect() === 'sqlite';
+    }
+    catch {
+        return false;
+    }
+}
+export function foldedTextFor(m, record) {
+    const row = encodeJson(m, flattenEmbedded(m, record));
+    const keys = [...new Set([...textSearchKeys(m), titleKey(m)])].filter(Boolean);
+    return keys
+        .map((k) => String(row[k] ?? ''))
+        .filter((s) => s.length > 0)
+        .map(foldText)
+        .join(SEARCH_SEPARATOR);
+}
+export function buildFtsMatchQuery(tokens) {
+    return tokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(' AND ');
+}
+export async function ensureSearchTable() {
+    if (!ftsAvailable())
+        return;
+    try {
+        await getEm()
+            .fork()
+            .getConnection()
+            .execute(`CREATE VIRTUAL TABLE IF NOT EXISTS "_search" USING fts5(
+           shelf UNINDEXED,
+           record_id UNINDEXED,
+           folded,
+           tokenize='trigram'
+         )`);
+    }
+    catch (e) {
+        ftsUnsupported = true;
+        log.warn(`FTS5 index unavailable, global search falls back to the scan — ${e.message}`);
+    }
+}
+export async function upsertSearchRow(shelf, recordId, folded) {
+    if (!ftsAvailable())
+        return;
+    const conn = getEm().fork().getConnection();
+    await conn.execute('DELETE FROM "_search" WHERE shelf = ? AND record_id = ?', [shelf, recordId]);
+    if (!folded)
+        return;
+    await conn.execute('INSERT INTO "_search" (shelf, record_id, folded) VALUES (?, ?, ?)', [
+        shelf,
+        recordId,
+        folded,
+    ]);
+}
+export async function deleteSearchRow(shelf, recordId) {
+    if (!ftsAvailable())
+        return;
+    await getEm()
+        .fork()
+        .getConnection()
+        .execute('DELETE FROM "_search" WHERE shelf = ? AND record_id = ?', [shelf, recordId]);
+}
+export async function ftsCandidates(tokens) {
+    const out = new Map();
+    if (!ftsAvailable() || tokens.length === 0)
+        return null;
+    if (tokens.some((t) => t.length < MIN_FTS_QUERY_LENGTH))
+        return null;
+    try {
+        const rows = (await getEm()
+            .fork()
+            .getConnection()
+            .execute('SELECT shelf, record_id FROM "_search" WHERE "_search" MATCH ?', [
+            buildFtsMatchQuery(tokens),
+        ]));
+        for (const r of rows) {
+            const list = out.get(r.shelf);
+            if (list)
+                list.push(Number(r.record_id));
+            else
+                out.set(r.shelf, [Number(r.record_id)]);
+        }
+    }
+    catch (e) {
+        log.warn(`MATCH failed — ${e.message}`);
+        return null;
+    }
+    return out;
+}

package/dist/search-indexer.d.ts

@@ -0,0 +1,4 @@
+export declare const SEARCH_STATE_PLUGIN = "core";
+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;