@coffer-org/server 3.0.0 → 3.2.0

package/dist/condition-where.d.ts

@@ -0,0 +1,6 @@
+import type { Condition } from '@coffer-org/sdk/condition';
+import type { ShelfDef } from '@coffer-org/sdk/shelf';
+export declare class ConditionCompileError extends Error {
+    constructor(message: string);
+}
+export declare function conditionToWhere(m: ShelfDef, cond: Condition): Record<string, unknown>;

package/dist/condition-where.js

@@ -0,0 +1,92 @@
+import { COMPILABLE_SCALAR_OPS as SCALAR_OPS, COMPILABLE_ARRAY_OPS as ARRAY_OPS, COMPILABLE_MEMBER_OPS as MEMBER_OPS, } from '@coffer-org/sdk/condition';
+import { fieldMap } from '@coffer-org/sdk/shelf';
+import { isJsonStored } from '@coffer-org/sdk/fields';
+import { coerceFilter } from "./records-api.js";
+export class ConditionCompileError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConditionCompileError';
+    }
+}
+const coerce = (f, v) => typeof v === 'boolean' ? v : coerceFilter(String(v), f.column);
+function memberOperator(pred, key, where) {
+    if (typeof pred !== 'object' || pred === null)
+        return undefined;
+    const ops = Object.keys(pred);
+    const member = ops.filter((op) => MEMBER_OPS.has(op));
+    if (!member.length)
+        return undefined;
+    if (ops.length > 1) {
+        throw new ConditionCompileError(`${where}: '${key}' mixes '${member[0]}' with other operators`);
+    }
+    return member[0];
+}
+function compileMember(key, operand, where) {
+    if (typeof operand === 'object' && operand !== null) {
+        throw new ConditionCompileError(`${where}: '${key}' $contains expects a single scalar element`);
+    }
+    const token = String(operand);
+    if (/[%_\\]/.test(token)) {
+        throw new ConditionCompileError(`${where}: '${key}' $contains operand '${token}' contains a LIKE metacharacter`);
+    }
+    return { $like: `%${JSON.stringify(token)}%` };
+}
+function compilePredicate(key, f, pred, where) {
+    if (typeof pred !== 'object' || pred === null)
+        return coerce(f, pred);
+    const out = {};
+    for (const [op, operand] of Object.entries(pred)) {
+        if (operand === undefined)
+            continue;
+        if (ARRAY_OPS.has(op)) {
+            if (!Array.isArray(operand))
+                throw new ConditionCompileError(`${where}: '${key}' ${op} expects an array`);
+            out[op] = operand.map((v) => coerce(f, v));
+            continue;
+        }
+        if (!SCALAR_OPS.has(op)) {
+            throw new ConditionCompileError(`${where}: operator '${op}' on '${key}' does not compile to SQL`);
+        }
+        out[op] = coerce(f, operand);
+    }
+    return out;
+}
+export function conditionToWhere(m, cond) {
+    const fm = fieldMap(m.fields);
+    const where = `${m.library}/${m.shelf}`;
+    const walk = (c) => {
+        const out = {};
+        for (const [key, spec] of Object.entries(c)) {
+            if (spec === undefined)
+                continue;
+            if (key === '$and' || key === '$or') {
+                if (!Array.isArray(spec))
+                    throw new ConditionCompileError(`${where}: '${key}' expects an array`);
+                out[key] = spec.map(walk);
+                continue;
+            }
+            const f = fm[key];
+            if (!f)
+                throw new ConditionCompileError(`${where}: unknown field '${key}'`);
+            if (f.virtual)
+                throw new ConditionCompileError(`${where}: '${key}' is virtual and has no column`);
+            const memberOp = memberOperator(spec, key, where);
+            if (memberOp && !f.hints['multiple']) {
+                throw new ConditionCompileError(`${where}: '${key}' is not a multiple field — '${memberOp}' does not apply`);
+            }
+            if (isJsonStored(f)) {
+                if (!memberOp) {
+                    throw new ConditionCompileError(`${where}: '${key}' is stored as JSON — only ${[...MEMBER_OPS].join('/')} applies`);
+                }
+                out[key] = compileMember(key, spec[memberOp], where);
+                continue;
+            }
+            if (f.columns) {
+                throw new ConditionCompileError(`${where}: '${key}' is a composite scalar stored across sub-columns — scalar operators do not apply`);
+            }
+            out[key] = compilePredicate(key, f, spec, where);
+        }
+        return out;
+    };
+    return walk(cond);
+}

package/dist/index.js

@@ -25,6 +25,8 @@ 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, recordRestore, recordPurge, recordTrashList, MAX_PAGE, UnknownShelfError, ensureSingle, SingleShelfError, } from "./records-api.js";
+import { showcaseList, showcaseListAll, showcaseCount, UnknownShowcaseError } from "./showcase-api.js";
+import { getActiveRegistry } from "./registry-context.js";
 import { maskTree, preserveTree } from "./field-masking.js";
 import { writePluginSettings } from "./settings-write.js";
 import { rootLogger, getLogger } from "./log.js";
@@ -446,6 +448,54 @@ app.get('/api/:library/:shelf', async (req, reply) => {
         throw e;
     }
 });
+app.get('/api/showcase/:library/:id', async (req, reply) => {
+    const { library, id } = req.params;
+    const { q, limit, offset } = req.query;
+    const paged = isPagedRequest(limit, offset);
+    try {
+        const s = getActiveRegistry().getShowcase(library, id);
+        if (!s)
+            return reply.code(404).send({ error: 'unknown_showcase' });
+        const { library: srcLibrary, shelf: srcShelf } = s.source;
+        if (!paged) {
+            let rows = await showcaseListAll(library, id, { q });
+            if (req.user && tracksRecordActivity(req.headers)) {
+                rows = await applySmartRanking(req.user.id, srcLibrary, srcShelf, rows);
+            }
+            return { rows: rows.map((r) => listRow(srcLibrary, srcShelf, r)), total: rows.length };
+        }
+        const pageOpts = {
+            limit: limit === undefined ? undefined : Number(limit),
+            offset: offset === undefined ? undefined : Number(offset),
+        };
+        let page = await showcaseList(library, id, { q }, pageOpts);
+        if (req.user && tracksRecordActivity(req.headers)) {
+            const allRows = await showcaseListAll(library, id, { q });
+            const ranked = await applySmartRanking(req.user.id, srcLibrary, srcShelf, allRows);
+            const rawLimit = Number.isFinite(pageOpts.limit) ? Math.trunc(pageOpts.limit) : MAX_PAGE;
+            const pageLimit = Math.min(Math.max(1, rawLimit), MAX_PAGE);
+            const pageOffset = Math.max(0, Number.isFinite(pageOpts.offset) ? Math.trunc(pageOpts.offset) : 0);
+            page = { rows: ranked.slice(pageOffset, pageOffset + pageLimit), total: ranked.length };
+        }
+        return { rows: page.rows.map((r) => listRow(srcLibrary, srcShelf, r)), total: page.total };
+    }
+    catch (e) {
+        if (e instanceof UnknownShowcaseError)
+            return reply.code(404).send({ error: 'unknown_showcase' });
+        throw e;
+    }
+});
+app.get('/api/showcase/:library/:id/count', async (req, reply) => {
+    const { library, id } = req.params;
+    try {
+        return { total: await showcaseCount(library, id) };
+    }
+    catch (e) {
+        if (e instanceof UnknownShowcaseError)
+            return reply.code(404).send({ error: 'unknown_showcase' });
+        throw e;
+    }
+});
 app.get('/api/:library/:shelf/:id/activity', async (req, reply) => {
     const { library, shelf, id } = req.params;
     const rid = Number(id);

package/dist/mcp-http.test-helpers.d.ts

@@ -1,5 +1,6 @@
 import { type FastifyInstance } from 'fastify';
 import { closeDb } from './db.ts';
+export declare function completeInjectedSocket(app: FastifyInstance): void;
 export declare function freshMcpApp(opts?: {
     withAdminTool?: boolean;
     withInstructions?: boolean;

package/dist/mcp-http.test-helpers.js

@@ -7,11 +7,19 @@ import { createUser, createApiToken } from "./auth-store.js";
 import { pluginHooks } from "./plugin-hooks.js";
 let currentAdminToken;
 let currentMemberToken;
+export function completeInjectedSocket(app) {
+    app.addHook('onRequest', async (req) => {
+        const socket = req.raw.socket;
+        if (socket && typeof socket.destroySoon !== 'function')
+            socket.destroySoon = () => { };
+    });
+}
 export async function freshMcpApp(opts = {}) {
     process.env['DB_PATH'] = ':memory:';
     const orm = await initDb(systemEntities);
     await orm.schema.update({ safe: false, dropTables: false });
     const app = Fastify();
+    completeInjectedSocket(app);
     app.addHook('onRequest', async (req, reply) => {
         const gated = req.url.startsWith('/api/') ||
             req.url.startsWith('/uploads/') ||

package/dist/records-api.d.ts

@@ -16,6 +16,7 @@ export type RecordListOpts = {
     offset?: number;
     orderBy?: Record<string, 'ASC' | 'DESC'>;
     deleted?: 'active' | 'deleted' | 'all';
+    where?: Record<string, unknown>;
 };
 export declare const MAX_PAGE = 500;
 export declare function coerceFilter(v: string, column: string): unknown;
@@ -25,7 +26,7 @@ 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, opts?: Pick<RecordListOpts, 'deleted'>): Promise<number>;
+export declare function recordCount(library: string, shelf: string, query?: RecordListQuery, opts?: Pick<RecordListOpts, 'deleted' | 'where'>): 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<{

package/dist/records-api.js

@@ -108,7 +108,7 @@ function buildWhere(m, filterParams) {
 export async function recordCount(library, shelf, query = {}, opts = {}) {
     const { m, ename } = resolve(library, shelf);
     const { q: _q, ...filterParams } = query;
-    const where = buildWhere(m, filterParams);
+    const where = { ...buildWhere(m, filterParams), ...(opts.where ?? {}) };
     const deleted = opts.deleted ?? 'active';
     if (deleted === 'active')
         where.deleted_at = null;
@@ -124,7 +124,7 @@ async function listRecords(library, shelf, query = {}, 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);
+    const where = { ...buildWhere(m, filterParams), ...(opts.where ?? {}) };
     if (deleted === 'active')
         where.deleted_at = null;
     else if (deleted === 'deleted')

package/dist/showcase-api.d.ts

@@ -0,0 +1,21 @@
+export declare class UnknownShowcaseError extends Error {
+    constructor(message: string);
+}
+export declare function resolveShowcase(library: string, id: string): {
+    s: import("@coffer-org/sdk/showcase").ShowcaseDef;
+    m: import("@coffer-org/sdk/shelf").ShelfDef;
+    where: Record<string, unknown>;
+};
+export declare function showcaseList(library: string, id: string, query?: {
+    q?: string;
+}, opts?: {
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    rows: Record<string, unknown>[];
+    total: number;
+}>;
+export declare function showcaseListAll(library: string, id: string, query?: {
+    q?: string;
+}): Promise<Record<string, unknown>[]>;
+export declare function showcaseCount(library: string, id: string): Promise<number>;

package/dist/showcase-api.js

@@ -0,0 +1,30 @@
+import { getActiveRegistry, getShelf } from "./registry-context.js";
+import { conditionToWhere } from "./condition-where.js";
+import { recordList, recordListPage, recordCount, UnknownShelfError } from "./records-api.js";
+export class UnknownShowcaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnknownShowcaseError';
+    }
+}
+export function resolveShowcase(library, id) {
+    const s = getActiveRegistry().getShowcase(library, id);
+    if (!s)
+        throw new UnknownShowcaseError(`unknown_showcase ${library}/${id}`);
+    const m = getShelf(s.source.library, s.source.shelf);
+    if (!m)
+        throw new UnknownShelfError(`unknown_shelf ${s.source.library}/${s.source.shelf}`);
+    return { s, m, where: conditionToWhere(m, s.filter) };
+}
+export async function showcaseList(library, id, query = {}, opts = {}) {
+    const { s, where } = resolveShowcase(library, id);
+    return recordListPage(s.source.library, s.source.shelf, { q: query.q }, { ...opts, view: 'list', extends: false, where });
+}
+export async function showcaseListAll(library, id, query = {}) {
+    const { s, where } = resolveShowcase(library, id);
+    return recordList(s.source.library, s.source.shelf, { q: query.q }, { view: 'list', extends: false, where });
+}
+export async function showcaseCount(library, id) {
+    const { s, where } = resolveShowcase(library, id);
+    return recordCount(s.source.library, s.source.shelf, {}, { where });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -24,8 +24,8 @@
     "postpack": "node ../../scripts/swap-exports.mjs src"
   },
   "dependencies": {
-    "@coffer-org/core": "^3.0.0",
-    "@coffer-org/sdk": "^3.0.0",
+    "@coffer-org/core": "^3.2.0",
+    "@coffer-org/sdk": "^3.2.0",
     "@extractus/oembed-extractor": "^4.1.0",
     "@fastify/cors": "^11.2.0",
     "@fastify/multipart": "^10.0.0",