@coffer-org/server 2.3.2 → 2.5.0

package/dist/entity-schema.d.ts

@@ -16,6 +16,7 @@ export declare const MigrationRowSchema: EntitySchema<any, never, import("@mikro
 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>>;
+export declare const RecordActivitySchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const ThreadMessageSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare function buildPluginEntities(plugins: PluginManifest[]): EntitySchema[];
 export declare const MsgLogSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;

package/dist/entity-schema.js

@@ -42,6 +42,7 @@ export function buildEntitySchema(m) {
         id: { type: 'integer', primary: true, autoincrement: true },
         created_at: { type: 'text' },
         updated_at: { type: 'text' },
+        deleted_at: { type: 'text', nullable: true },
     };
     addFieldProps(properties, m.fields, (f) => !f.required);
     const name = shelfTableName(m.library, m.shelf);
@@ -151,6 +152,19 @@ export const PluginStateSchema = new EntitySchema({
         value: { type: 'text' },
     },
 });
+export const RecordActivitySchema = new EntitySchema({
+    name: '_RecordActivity',
+    tableName: '_record_activity',
+    properties: {
+        user_id: { type: 'integer', primary: true },
+        library: { type: 'text', primary: true },
+        shelf: { type: 'text', primary: true },
+        record_id: { type: 'integer', primary: true },
+        favorite: { type: 'integer' },
+        view_count: { type: 'integer' },
+        last_viewed_at: { type: 'text', nullable: true },
+    },
+});
 export const ThreadMessageSchema = new EntitySchema({
     name: '_ThreadMessage',
     tableName: '_thread_message',
@@ -267,7 +281,7 @@ export const OAuthTokenSchema = new EntitySchema({
 });
 export const systemEntities = [
     EventSchema, PluginRowSchema, MigrationRowSchema, SeedRowSchema,
-    EmbeddingSchema, PluginStateSchema, MsgLogSchema,
+    EmbeddingSchema, PluginStateSchema, RecordActivitySchema, MsgLogSchema,
     UserSchema, SessionSchema, ApiTokenSchema,
     OAuthClientSchema, OAuthCodeSchema, OAuthTokenSchema,
     ThreadMessageSchema,

package/dist/index.js

@@ -24,7 +24,7 @@ import { baseUrl } from "./public-url.js";
 import { discoverPluginAssets, discoverRuntime } from "./plugin-discovery.js";
 import { checkLatestVersion, resolveUpdateTarget, resolveAllUpdateTargets, resolveBaseTargets, resolveRuntimeTarget, runNpmInstall, } from "./plugin-updates.js";
 import { buildClientSchema } from "./schema-api.js";
-import { recordList, recordListPage, isPagedRequest, recordGet, recordCreate, recordUpdate, recordDelete, UnknownShelfError, } from "./records-api.js";
+import { recordList, recordListPage, isPagedRequest, recordGet, recordCreate, recordUpdate, recordDelete, recordRestore, recordPurge, recordTrashList, UnknownShelfError, } from "./records-api.js";
 import { maskTree, preserveTree } from "./field-masking.js";
 import { writePluginSettings } from "./settings-write.js";
 import { rootLogger, getLogger } from "./log.js";
@@ -34,6 +34,7 @@ import { verifyUploadTicket } from "./upload-ticket.js";
 import { setPluginState } from "./plugin-state.js";
 import { SEARCH_STATE_PLUGIN, SEARCH_CURSOR_KEY } from "./search-indexer.js";
 import { globalSearch } from "./global-search.js";
+import { applySmartRanking, getRecordActivity, markRecordViewed, setRecordFavorite } from "./record-activity.js";
 const ENV_FILE = join(process.cwd(), '.env');
 if (existsSync(ENV_FILE))
     process.loadEnvFile(ENV_FILE);
@@ -363,6 +364,48 @@ function maskRecordRow(library, shelf, row) {
     }
     return out;
 }
+function tracksRecordActivity(req) {
+    const marker = req.headers['x-coffer-automated'];
+    const value = Array.isArray(marker) ? marker[0] : marker;
+    return value?.toLowerCase().trim() !== 'true';
+}
+app.get('/api/trash', async (_req, reply) => {
+    const rows = await recordTrashList();
+    return rows.map((entry) => ({ ...entry, record: maskRecordRow(entry.library, entry.shelf, entry.record) }));
+});
+app.post('/api/trash/:library/:shelf/:id/restore', async (req, reply) => {
+    const { library, shelf, id } = req.params;
+    const rid = Number(id);
+    if (isNaN(rid))
+        return reply.code(400).send({ error: 'invalid_id' });
+    try {
+        await recordRestore(library, shelf, rid);
+        return { ok: true };
+    }
+    catch (e) {
+        if (e instanceof UnknownShelfError || e instanceof NotFoundError)
+            return reply.code(404).send({ error: 'not_found' });
+        throw e;
+    }
+});
+app.delete('/api/trash/:library/:shelf/:id', async (req, reply) => {
+    const { library, shelf, id } = req.params;
+    const rid = Number(id);
+    if (isNaN(rid))
+        return reply.code(400).send({ error: 'invalid_id' });
+    if (req.body?.confirmed !== true) {
+        return reply.code(400).send({ error: 'explicit_confirmation_required' });
+    }
+    try {
+        await recordPurge(library, shelf, rid);
+        return reply.code(204).send();
+    }
+    catch (e) {
+        if (e instanceof UnknownShelfError || e instanceof NotFoundError)
+            return reply.code(404).send({ error: 'not_found' });
+        throw e;
+    }
+});
 app.get('/api/:library/:shelf', async (req, reply) => {
     const { library, shelf } = req.params;
     const { _fields, _extends, limit, offset, ...query } = req.query;
@@ -373,14 +416,19 @@ app.get('/api/:library/:shelf', async (req, reply) => {
     };
     try {
         if (!paged) {
-            const rows = await recordList(library, shelf, query, opts);
+            let rows = await recordList(library, shelf, query, opts);
+            if (req.user && tracksRecordActivity(req))
+                rows = await applySmartRanking(req.user.id, library, shelf, rows);
             return rows.map((r) => maskRecordRow(library, shelf, r));
         }
-        const page = await recordListPage(library, shelf, query, {
+        let page = await recordListPage(library, shelf, query, {
             ...opts,
             limit: limit === undefined ? undefined : Number(limit),
             offset: offset === undefined ? undefined : Number(offset),
         });
+        if (req.user && tracksRecordActivity(req)) {
+            page = { ...page, rows: await applySmartRanking(req.user.id, library, shelf, page.rows) };
+        }
         return { rows: page.rows.map((r) => maskRecordRow(library, shelf, r)), total: page.total };
     }
     catch (e) {
@@ -389,6 +437,43 @@ app.get('/api/:library/:shelf', async (req, reply) => {
         throw e;
     }
 });
+app.get('/api/:library/:shelf/:id/activity', async (req, reply) => {
+    const { library, shelf, id } = req.params;
+    const rid = Number(id);
+    if (isNaN(rid))
+        return reply.code(400).send({ error: 'invalid_id' });
+    try {
+        const row = await recordGet(library, shelf, rid);
+        if (!row)
+            return reply.code(404).send({ error: 'not_found' });
+        return { activity: await getRecordActivity(req.user.id, library, shelf, rid) };
+    }
+    catch (e) {
+        if (e instanceof UnknownShelfError)
+            return reply.code(404).send({ error: 'unknown_shelf' });
+        throw e;
+    }
+});
+app.patch('/api/:library/:shelf/:id/activity', async (req, reply) => {
+    const { library, shelf, id } = req.params;
+    const rid = Number(id);
+    if (isNaN(rid))
+        return reply.code(400).send({ error: 'invalid_id' });
+    const body = (req.body ?? {});
+    if (typeof body.favorite !== 'boolean')
+        return reply.code(400).send({ error: 'favorite_must_be_boolean' });
+    try {
+        const row = await recordGet(library, shelf, rid);
+        if (!row)
+            return reply.code(404).send({ error: 'not_found' });
+        return { activity: await setRecordFavorite(req.user.id, library, shelf, rid, body.favorite) };
+    }
+    catch (e) {
+        if (e instanceof UnknownShelfError)
+            return reply.code(404).send({ error: 'unknown_shelf' });
+        throw e;
+    }
+});
 app.get('/api/:library/:shelf/:id', async (req, reply) => {
     const { library, shelf, id } = req.params;
     const rid = Number(id);
@@ -398,7 +483,11 @@ app.get('/api/:library/:shelf/:id', async (req, reply) => {
         const row = await recordGet(library, shelf, rid);
         if (!row)
             return reply.code(404).send({ error: 'not_found' });
-        return maskRecordRow(library, shelf, row);
+        const masked = maskRecordRow(library, shelf, row);
+        if (req.user && tracksRecordActivity(req)) {
+            return { ...masked, _activity: await markRecordViewed(req.user.id, library, shelf, rid) };
+        }
+        return masked;
     }
     catch (e) {
         if (e instanceof UnknownShelfError)

package/dist/mcp-local.d.ts

@@ -14,4 +14,7 @@ export declare class LocalClient implements CofferClientApi {
     createRecord(library: string, shelf: string, fields: Record<string, unknown>): Promise<unknown>;
     updateRecord(library: string, shelf: string, id: number, fields: Record<string, unknown>): Promise<unknown>;
     deleteRecord(library: string, shelf: string, id: number): Promise<unknown>;
+    listTrash(): Promise<unknown>;
+    restoreRecord(library: string, shelf: string, id: number): Promise<unknown>;
+    purgeRecord(library: string, shelf: string, id: number): Promise<unknown>;
 }

package/dist/mcp-local.js

@@ -1,5 +1,5 @@
 import { ValidationError, NotFoundError } from '@coffer-org/mcp/client';
-import { recordList, recordListPage, recordGet, recordCreate, recordUpdate, recordDelete, UnknownShelfError, } from "./records-api.js";
+import { recordList, recordListPage, recordGet, recordCreate, recordUpdate, recordDelete, UnknownShelfError, recordTrashList, recordRestore, recordPurge, } from "./records-api.js";
 import { ValidationError as ServerValidationError } from "./mutate.js";
 import { buildClientSchema } from "./schema-api.js";
 export function mapError(e) {
@@ -63,4 +63,30 @@ export class LocalClient {
             mapError(e);
         }
     }
+    async listTrash() {
+        try {
+            return await recordTrashList();
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+    async restoreRecord(library, shelf, id) {
+        try {
+            await recordRestore(library, shelf, id);
+            return null;
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+    async purgeRecord(library, shelf, id) {
+        try {
+            await recordPurge(library, shelf, id);
+            return null;
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
 }

package/dist/mcp-tools.js

@@ -265,7 +265,9 @@ export async function buildDomainSections() {
         "some are collections (nested rows — an array). Extends add extra field-sets to a shelf's records, shown only when a " +
         'condition holds (the "when …" notes below); in a fetched record they sit under `_extends`. ' +
         'Read: list_libraries → describe_shelf → list_records/get_record. Write: create_record/update_record (call describe_shelf first); ' +
-        'to remove a record use delete_record — do not blank its fields.';
+        'delete_record moves a record to reversible trash — do not blank fields. Before editing, read the complete record and patch only requested fields. ' +
+        'For duplicates, read both records completely, compare fields/collections/extends/attachments, recommend the less complete record for trash, and offer a field-by-field merge first. ' +
+        'Use list_trash and restore_record for recovery; purge_record is irreversible and requires explicit confirmation.';
     const rules = (await collectPluginInstructions()).map(({ id, instructions }) => `## ${id}\n${instructions}`);
     const site = await frontendInstructions();
     return [
@@ -281,6 +283,7 @@ export function buildMcpInstructions(sections) {
         'Use the tools to read and write this data: call list_libraries to see what exists, describe_shelf before create_record/update_record, then list_records / get_record to read. When a search_records tool is available, use it for semantic lookup.',
         'The per-library notes below name the shelves and the rules — not every field. For exact field names, types, and which are required, call describe_shelf(library, shelf) rather than guessing from the notes.',
         'Record field values may be JSON-encoded (e.g. quantity {"value":2000,"unit":"ml"}) — parse them.',
+        'Action safety: read a complete record before editing or deleting it. update_record must be the smallest patch and must preserve unmentioned fields. delete_record moves the record to reversible trash; never blank fields to simulate deletion. For suspected duplicates, read both complete records, compare fields/collections/extends/attachments, identify the less complete record, and offer a field-by-field merge before moving anything to trash. Use list_trash/restore_record for recovery; purge_record is irreversible and requires explicit confirmation.',
         'File fields (file/document/audio/video/image/media/avatar/cover/poster) hold a file uploaded to this server, ' +
             'never a remote URL: {"name":"<filename from POST /api/upload>"}. Writing a URL is rejected. ' +
             'To store a picture found on the web, download it locally first, then create_upload_ticket → POST /api/upload → write the returned name. ' +

package/dist/msg-log.d.ts

@@ -8,4 +8,14 @@ export interface MsgLogRow {
     tokensOut: number | null;
     ms: number | null;
 }
+export interface MsgLogDiagnosticRow {
+    id: number;
+    ts: string;
+    connector: string;
+    role: 'user' | 'assistant';
+    tokensIn: number | null;
+    tokensOut: number | null;
+    ms: number | null;
+}
 export declare function logMessage(row: MsgLogRow): Promise<void>;
+export declare function listRecentMessageMetrics(limit?: number): Promise<MsgLogDiagnosticRow[]>;

package/dist/msg-log.js

@@ -3,3 +3,19 @@ export async function logMessage(row) {
     await getEm().fork().getConnection().execute(`INSERT INTO _orch_msg_log (ts, connector, chat_id, user_id, role, text, tokens_in, tokens_out, ms)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [new Date().toISOString(), row.connector, row.chatId, row.userId, row.role, row.text, row.tokensIn, row.tokensOut, row.ms]);
 }
+export async function listRecentMessageMetrics(limit = 25) {
+    const bounded = Math.max(1, Math.min(100, Math.trunc(limit)));
+    const rows = (await getEm().fork().getConnection().execute(`SELECT id, ts, connector, role, tokens_in, tokens_out, ms
+       FROM _orch_msg_log
+      ORDER BY id DESC
+      LIMIT ?`, [bounded]));
+    return rows.map((r) => ({
+        id: Number(r['id']),
+        ts: String(r['ts']),
+        connector: String(r['connector']),
+        role: r['role'] === 'assistant' ? 'assistant' : 'user',
+        tokensIn: r['tokens_in'] == null ? null : Number(r['tokens_in']),
+        tokensOut: r['tokens_out'] == null ? null : Number(r['tokens_out']),
+        ms: r['ms'] == null ? null : Number(r['ms']),
+    }));
+}

package/dist/mutate.d.ts

@@ -20,8 +20,14 @@ export declare class NotFoundError extends Error {
     constructor();
 }
 export declare function toIssue(i: z.ZodIssue): ValidationIssue;
-export declare function listRecords(entityName: string): Promise<Record<string, unknown>[]>;
-export declare function getRecord(m: ShelfDef, entityName: string, id: number): Promise<Record<string, unknown> | undefined>;
+export declare function listRecords(entityName: string, opts?: {
+    deleted?: 'active' | 'deleted' | 'all';
+}): Promise<Record<string, unknown>[]>;
+export declare function getRecord(m: ShelfDef, entityName: string, id: number, opts?: {
+    includeDeleted?: boolean;
+}): Promise<Record<string, unknown> | undefined>;
 export declare function createRecord(m: ShelfDef, entityName: string, input: unknown, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<Record<string, unknown>>;
 export declare function updateRecord(m: ShelfDef, entityName: string, id: number, input: unknown, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<Record<string, unknown>>;
-export declare function deleteRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<void>;
+export declare function deleteRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx): Promise<void>;
+export declare function restoreRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<Record<string, unknown>>;
+export declare function purgeRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<void>;

package/dist/mutate.js

@@ -50,14 +50,19 @@ function writeEvent(em, actor, op, type, recordId, before, after) {
         after: after == null ? null : JSON.stringify(after),
     });
 }
-export async function listRecords(entityName) {
+export async function listRecords(entityName, opts = {}) {
     const fork = getEm().fork();
-    const rows = await fork.findAll(entityName, { orderBy: { id: 'asc' } });
+    const deleted = opts.deleted ?? 'active';
+    const where = deleted === 'active' ? { deleted_at: null } : deleted === 'deleted' ? { deleted_at: { $ne: null } } : {};
+    const rows = await fork.findAll(entityName, { where, orderBy: { id: 'asc' } });
     return serialize(rows);
 }
-export async function getRecord(m, entityName, id) {
+export async function getRecord(m, entityName, id, opts = {}) {
     const fork = getEm().fork();
-    const row = await fork.findOne(entityName, { id });
+    const row = await fork.findOne(entityName, {
+        id,
+        ...(opts.includeDeleted ? {} : { deleted_at: null }),
+    });
     if (!row)
         return undefined;
     const flat = decodeTemporal(m, serialize(row));
@@ -148,11 +153,45 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
     notifyRecordsChanged();
     return result;
 }
-export async function deleteRecord(m, entityName, id, ctx, afterBase) {
+export async function deleteRecord(m, entityName, id, ctx) {
     await getEm()
         .fork()
         .transactional(async (tx) => {
-        const found = await tx.findOne(entityName, { id });
+        const found = await tx.findOne(entityName, { id, deleted_at: null });
+        if (!found)
+            throw new NotFoundError();
+        const existing = serialize(found);
+        found.deleted_at = nowIso();
+        await tx.flush();
+        writeEvent(tx, ctx.actor, 'delete', `${m.library}/${m.shelf}`, id, existing, null);
+    });
+    notifyRecordsChanged();
+}
+export async function restoreRecord(m, entityName, id, ctx, afterBase) {
+    let result;
+    await getEm()
+        .fork()
+        .transactional(async (tx) => {
+        const found = await tx.findOne(entityName, { id, deleted_at: { $ne: null } });
+        if (!found)
+            throw new NotFoundError();
+        found.deleted_at = null;
+        await tx.flush();
+        const flat = decodeTemporal(m, serialize(found));
+        const nested = nestEmbedded(m, flat);
+        const collections = await readCollections(tx, m, id);
+        const _extends = afterBase ? await afterBase(tx, id) : undefined;
+        result = { ...nested, ...collections, ...(_extends ? { _extends } : {}) };
+        writeEvent(tx, ctx.actor, 'restore', `${m.library}/${m.shelf}`, id, null, result);
+    });
+    notifyRecordsChanged();
+    return result;
+}
+export async function purgeRecord(m, entityName, id, ctx, afterBase) {
+    await getEm()
+        .fork()
+        .transactional(async (tx) => {
+        const found = await tx.findOne(entityName, { id, deleted_at: { $ne: null } });
         if (!found)
             throw new NotFoundError();
         const existing = serialize(found);
@@ -160,7 +199,7 @@ export async function deleteRecord(m, entityName, id, ctx, afterBase) {
         if (afterBase)
             await afterBase(tx, id);
         tx.remove(found);
-        writeEvent(tx, ctx.actor, 'delete', `${m.library}/${m.shelf}`, id, existing, null);
+        writeEvent(tx, ctx.actor, 'purge', `${m.library}/${m.shelf}`, id, existing, null);
     });
     notifyRecordsChanged();
 }

package/dist/record-activity.d.ts

@@ -0,0 +1,11 @@
+export interface RecordActivityClient {
+    favorite: boolean;
+    viewCount: number;
+    lastViewedAt: string | null;
+    score: number;
+}
+export declare function getRecordActivity(userId: number, library: string, shelf: string, recordId: number): Promise<RecordActivityClient>;
+export declare function markRecordViewed(userId: number, library: string, shelf: string, recordId: number, now?: string): Promise<RecordActivityClient>;
+export declare function setRecordFavorite(userId: number, library: string, shelf: string, recordId: number, favorite: boolean): Promise<RecordActivityClient>;
+export declare function deleteRecordActivity(library: string, shelf: string, recordId: number): Promise<void>;
+export declare function applySmartRanking(userId: number, library: string, shelf: string, rows: Record<string, unknown>[], now?: Date): Promise<Record<string, unknown>[]>;

package/dist/record-activity.js

@@ -0,0 +1,118 @@
+import { getEm } from "./db.js";
+import { shelfTableName } from "./entity-schema.js";
+const DAY_MS = 24 * 60 * 60 * 1000;
+const CREATED_HALF_LIFE_DAYS = 30;
+const EDITED_HALF_LIFE_DAYS = 14;
+function activityKey(userId, library, shelf, recordId) {
+    return { user_id: userId, library, shelf, record_id: recordId };
+}
+function toClient(row) {
+    return {
+        favorite: row?.favorite === 1,
+        viewCount: Number(row?.view_count ?? 0),
+        lastViewedAt: row?.last_viewed_at ?? null,
+        score: 0,
+    };
+}
+async function getActivityRow(userId, library, shelf, recordId) {
+    const em = getEm().fork();
+    return (await em.findOne('_RecordActivity', activityKey(userId, library, shelf, recordId)));
+}
+export async function getRecordActivity(userId, library, shelf, recordId) {
+    return toClient((await getActivityRow(userId, library, shelf, recordId)) ?? undefined);
+}
+export async function markRecordViewed(userId, library, shelf, recordId, now = new Date().toISOString()) {
+    const em = getEm().fork();
+    const key = activityKey(userId, library, shelf, recordId);
+    const row = (await em.findOne('_RecordActivity', key));
+    if (row) {
+        row.view_count = Number(row.view_count ?? 0) + 1;
+        row.last_viewed_at = now;
+        await em.flush();
+        return toClient(row);
+    }
+    const created = em.create('_RecordActivity', {
+        ...key,
+        favorite: 0,
+        view_count: 1,
+        last_viewed_at: now,
+    });
+    await em.flush();
+    return toClient(created);
+}
+export async function setRecordFavorite(userId, library, shelf, recordId, favorite) {
+    const em = getEm().fork();
+    const key = activityKey(userId, library, shelf, recordId);
+    const row = (await em.findOne('_RecordActivity', key));
+    if (row) {
+        row.favorite = favorite ? 1 : 0;
+        await em.flush();
+        return toClient(row);
+    }
+    const created = em.create('_RecordActivity', {
+        ...key,
+        favorite: favorite ? 1 : 0,
+        view_count: 0,
+        last_viewed_at: null,
+    });
+    await em.flush();
+    return toClient(created);
+}
+export async function deleteRecordActivity(library, shelf, recordId) {
+    const em = getEm().fork();
+    await em.nativeDelete('_RecordActivity', { library, shelf, record_id: recordId });
+}
+async function listActivityRows(userId, library, shelf, ids) {
+    if (ids.length === 0)
+        return new Map();
+    const em = getEm().fork();
+    const rows = (await em.find('_RecordActivity', { user_id: userId, library, shelf, record_id: { $in: ids } }));
+    return new Map(rows.map((row) => [Number(row.record_id), row]));
+}
+function decayBonus(base, timestamp, halfLifeDays, nowMs) {
+    const then = timestamp ? Date.parse(timestamp) : NaN;
+    if (!Number.isFinite(then))
+        return 0;
+    const ageDays = Math.max(0, nowMs - then) / DAY_MS;
+    return base * 2 ** (-ageDays / halfLifeDays);
+}
+export async function applySmartRanking(userId, library, shelf, rows, now = new Date()) {
+    if (rows.length === 0)
+        return rows;
+    const ids = rows.map((row) => Number(row.id)).filter((id) => Number.isInteger(id));
+    const activities = await listActivityRows(userId, library, shelf, ids);
+    const em = getEm().fork();
+    const timestamps = (await em.find(shelfTableName(library, shelf), { id: { $in: ids }, deleted_at: null }, { fields: ['id', 'created_at', 'updated_at'] }));
+    const dates = new Map(timestamps.map((row) => [Number(row.id), row]));
+    const viewed = rows
+        .map((row) => ({ id: Number(row.id), last: activities.get(Number(row.id))?.last_viewed_at }))
+        .filter((row) => typeof row.last === 'string' && Number.isFinite(Date.parse(row.last)))
+        .sort((a, b) => Date.parse(b.last) - Date.parse(a.last));
+    const recentReadIds = new Set(viewed.slice(0, Math.max(1, Math.ceil(rows.length * 0.1))).map((row) => row.id));
+    const nowMs = now.getTime();
+    const decorated = rows.map((row) => {
+        const id = Number(row.id);
+        const activity = activities.get(id);
+        const date = dates.get(id);
+        const created = date?.created_at;
+        const updated = date?.updated_at;
+        const createdBonus = decayBonus(75, created, CREATED_HALF_LIFE_DAYS, nowMs);
+        const edited = created && updated && Date.parse(updated) > Date.parse(created) ? updated : null;
+        const editedBonus = decayBonus(50, edited, EDITED_HALF_LIFE_DAYS, nowMs);
+        const score = (activity?.favorite === 1 ? 100 : 0) + createdBonus + editedBonus + (recentReadIds.has(id) ? 30 : 0);
+        const client = {
+            favorite: activity?.favorite === 1,
+            viewCount: Number(activity?.view_count ?? 0),
+            lastViewedAt: activity?.last_viewed_at ?? null,
+            score,
+        };
+        return { row: { ...row, _activity: client }, client, updated: updated ?? '' };
+    });
+    return decorated
+        .sort((a, b) => b.client.score - a.client.score ||
+        b.client.viewCount - a.client.viewCount ||
+        String(b.client.lastViewedAt ?? '').localeCompare(String(a.client.lastViewedAt ?? '')) ||
+        b.updated.localeCompare(a.updated) ||
+        Number(b.row.id) - Number(a.row.id))
+        .map((item) => item.row);
+}

package/dist/records-api.d.ts

@@ -12,6 +12,7 @@ export type RecordListOpts = {
     limit?: number;
     offset?: number;
     orderBy?: Record<string, 'ASC' | 'DESC'>;
+    deleted?: 'active' | 'deleted' | 'all';
 };
 export declare const MAX_PAGE = 500;
 export declare function coerceFilter(v: string, column: string): unknown;
@@ -21,14 +22,25 @@ export declare function rowMatch(mdef: ShelfDef, row: Record<string, unknown>, t
     score: number;
     snippet: string;
 } | null;
-export declare function recordCount(library: string, shelf: string, query?: RecordListQuery): Promise<number>;
+export declare function recordCount(library: string, shelf: string, query?: RecordListQuery, opts?: Pick<RecordListOpts, 'deleted'>): 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 recordGet(library: string, shelf: string, id: number, opts?: {
+    includeDeleted?: boolean;
+}): 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>;
+export declare function recordRestore(library: string, shelf: string, id: number, actor?: string): Promise<void>;
+export declare function recordPurge(library: string, shelf: string, id: number, actor?: string): Promise<void>;
+export interface TrashRecord {
+    library: string;
+    shelf: string;
+    label: string;
+    record: Record<string, unknown>;
+}
+export declare function recordTrashList(): Promise<TrashRecord[]>;

package/dist/records-api.js

@@ -1,13 +1,14 @@
 import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor } from '@coffer-org/sdk/shelf';
 import { tokenize, matchScoreFolded, foldText } from '@coffer-org/core/search';
 import { serialize } from '@mikro-orm/core';
-import { getShelf, getExtendsFor } from "./registry-context.js";
+import { getActiveRegistry, getShelf, getExtendsFor } from "./registry-context.js";
 import { shelfTableName } from "./entity-schema.js";
 import { getExtendRecord, getExtendRecords } from "./extend-table.js";
 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";
+import { createRecord, updateRecord, getRecord, deleteRecord, restoreRecord, purgeRecord } from "./mutate.js";
+import { deleteRecordActivity } from "./record-activity.js";
 export class UnknownShelfError extends Error {
 }
 export const MAX_PAGE = 500;
@@ -98,20 +99,29 @@ function buildWhere(m, filterParams) {
     }
     return where;
 }
-export async function recordCount(library, shelf, query = {}) {
+export async function recordCount(library, shelf, query = {}, opts = {}) {
     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)
+    const deleted = opts.deleted ?? 'active';
+    if (deleted === 'active')
+        where.deleted_at = null;
+    else if (deleted === 'deleted')
+        where.deleted_at = { $ne: null };
+    if (m.standalone === false && Object.keys(filterParams).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 { view = 'full', extends: withExt = true, deleted = 'active' } = 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)
+    if (deleted === 'active')
+        where.deleted_at = null;
+    else if (deleted === 'deleted')
+        where.deleted_at = { $ne: null };
+    if (m.standalone === false && Object.keys(filterParams).length === 0)
         return [];
     const fork = getEm().fork();
     const tokens = typeof q === 'string' && q ? tokenize(q) : [];
@@ -157,14 +167,14 @@ export async function recordListPage(library, shelf, query = {}, opts = {}) {
         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);
+    const total = await recordCount(library, shelf, query, opts);
     return { rows, total };
 }
-export async function recordGet(library, shelf, id) {
+export async function recordGet(library, shelf, id, opts = {}) {
     const { m, ename } = resolve(library, shelf);
     if (m.standalone === false)
         return null;
-    const row = await getRecord(m, ename, id);
+    const row = await getRecord(m, ename, id, opts);
     if (!row)
         return null;
     return withExtends(row, library, shelf);
@@ -191,5 +201,24 @@ export async function recordUpdate(library, shelf, id, body, actor = 'gui') {
 }
 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));
+    await deleteRecord(m, ename, id, { actor });
+}
+export async function recordRestore(library, shelf, id, actor = 'gui') {
+    const { m, ename } = resolve(library, shelf);
+    await restoreRecord(m, ename, id, { actor }, (tx, recordId) => readExtends(tx, library, shelf, recordId));
+}
+export async function recordPurge(library, shelf, id, actor = 'gui') {
+    const { m, ename } = resolve(library, shelf);
+    await purgeRecord(m, ename, id, { actor }, (tx, recordId) => deleteExtends(tx, library, shelf, recordId));
+    await deleteRecordActivity(library, shelf, id);
+}
+export async function recordTrashList() {
+    const shelves = getActiveRegistry().shelves.filter((s) => s.standalone !== false);
+    const out = [];
+    for (const m of shelves) {
+        const rows = await recordList(m.library, m.shelf, {}, { view: 'full', extends: true, deleted: 'deleted' });
+        for (const record of rows)
+            out.push({ library: m.library, shelf: m.shelf, label: m.label, record });
+    }
+    return out.sort((a, b) => String(b.record.deleted_at ?? '').localeCompare(String(a.record.deleted_at ?? '')));
 }

package/dist/search-indexer.js

@@ -23,7 +23,7 @@ export async function indexSearchOnce(batch = DEFAULT_BATCH) {
         if (!library || !shelf)
             continue;
         const key = `${r.type}/${r.record_id}`;
-        if (r.op === 'delete') {
+        if (r.op === 'delete' || r.op === 'purge') {
             byRef.set(key, { shelf: r.type, recordId: r.record_id, op: 'delete', folded: '' });
             continue;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "2.3.2",
+  "version": "2.5.0",
   "type": "module",
   "engines": {
     "node": ">=24"