@coffer-org/server 2.5.2 → 2.6.0

package/dist/collection-io.js

@@ -2,6 +2,7 @@ import { serialize } from '@mikro-orm/core';
 import { collectionGroups, fieldEntries, storageColumns } from '@coffer-org/sdk/shelf';
 import { isGroup, isEmbeddedGroup, isJsonStored } from '@coffer-org/sdk/fields';
 import { chunk } from "./batch.js";
+import { selectRows } from "./read-rows.js";
 function flattenLayout(fields) {
     const out = [];
     for (const f of fields) {
@@ -68,7 +69,7 @@ export async function readAt(em, prefix, fields, parentId) {
     for (const c of collectionGroups(fields)) {
         const table = `${prefix}__${c.key}`;
         const childFields = c.group.fields;
-        const rows = serialize(await em.find(table, { parent_id: parentId }, { orderBy: { position: 'asc' } }));
+        const rows = (await selectRows(em, table, { parent_id: parentId }, { orderBy: { position: 'asc' } }));
         const acc = [];
         for (const row of rows) {
             const { id, parent_id: _pid, position: _pos, ...rest } = row;
@@ -90,9 +91,7 @@ export async function readAtMany(em, prefix, fields, parentIds) {
         const childFields = c.group.fields;
         const rows = [];
         for (const ids of chunk(parentIds)) {
-            rows.push(...serialize(await em.find(table, { parent_id: { $in: ids } }, {
-                orderBy: { position: 'asc' },
-            })));
+            rows.push(...(await selectRows(em, table, { parent_id: { $in: ids } }, { orderBy: { position: 'asc' } })));
         }
         const nestedByChild = await readAtMany(em, table, childFields, rows.map((r) => r.id));
         for (const id of parentIds)

package/dist/extend-table.js

@@ -1,17 +1,16 @@
-import { serialize } from '@mikro-orm/core';
 import { getEm } from "./db.js";
 import { splitAt, writeAt, readAt, readAtMany, deleteAt } from "./collection-io.js";
 import { chunk } from "./batch.js";
+import { selectRows } from "./read-rows.js";
 export function extendEntityName(e) {
     return `extend__${e.id}`;
 }
 export async function getExtendRecord(e, baseId, em) {
     const fork = em ?? getEm().fork();
     const name = extendEntityName(e);
-    const row = await fork.findOne(name, { base_id: baseId });
-    if (!row)
+    const [flat] = (await selectRows(fork, name, { base_id: baseId }, { limit: 1 }));
+    if (!flat)
         return undefined;
-    const flat = serialize(row);
     const collections = await readAt(fork, name, e.fields, baseId);
     return { ...flat, ...collections };
 }
@@ -23,7 +22,7 @@ export async function getExtendRecords(e, baseIds, em) {
     const name = extendEntityName(e);
     const flats = [];
     for (const ids of chunk(baseIds)) {
-        flats.push(...serialize(await fork.find(name, { base_id: { $in: ids } })));
+        flats.push(...(await selectRows(fork, name, { base_id: { $in: ids } })));
     }
     if (flats.length === 0)
         return out;

package/dist/global-search.js

@@ -1,10 +1,10 @@
 import { textSearchKeys, titleKey, recordTitle, storageColumnsFor } from '@coffer-org/sdk/shelf';
-import { serialize } from '@mikro-orm/core';
 import { tokenize } from '@coffer-org/core/search';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { getEm } from "./db.js";
 import { rowMatch } from "./records-api.js";
 import { ftsAvailable, ftsCandidates, MIN_FTS_QUERY_LENGTH } from "./search-index.js";
+import { selectRows } from "./read-rows.js";
 const log = getLogger('search');
 export const SEARCH_SCAN_LIMIT = 1000;
 function matchCols(m) {
@@ -44,10 +44,7 @@ export async function globalSearchByScan(shelves, q, limit) {
             continue;
         if (!textSearchKeys(shelf.def).length)
             continue;
-        const rows = (await fork.find(shelf.table, {}, {
-            limit: SEARCH_SCAN_LIMIT,
-            fields: matchCols(shelf.def),
-        })).map((r) => serialize(r));
+        const rows = await selectRows(fork, shelf.table, {}, { limit: SEARCH_SCAN_LIMIT, fields: matchCols(shelf.def) });
         if (rows.length === SEARCH_SCAN_LIMIT) {
             log.warn('scan cap reached', { shelf: shelf.key, limit: SEARCH_SCAN_LIMIT });
         }
@@ -77,9 +74,7 @@ export async function globalSearch(shelves, q, limit) {
             continue;
         if (!textSearchKeys(shelf.def).length)
             continue;
-        const rows = (await fork.find(shelf.table, { id: { $in: ids } }, {
-            fields: matchCols(shelf.def),
-        })).map((r) => serialize(r));
+        const rows = await selectRows(fork, shelf.table, { id: { $in: ids } }, { fields: matchCols(shelf.def) });
         scored.push(...scoreRows(shelf, rows, tokens));
     }
     scored.sort((a, b) => b.score - a.score || tieKey(a.result).localeCompare(tieKey(b.result)));

package/dist/index.js

@@ -365,6 +365,11 @@ function maskRecordRow(library, shelf, row) {
     }
     return out;
 }
+function listRow(library, shelf, row) {
+    const out = maskRecordRow(library, shelf, row);
+    const activity = out._activity;
+    return activity ? { ...out, _activity: { favorite: activity.favorite === true } } : out;
+}
 app.get('/api/trash', async (_req, reply) => {
     const rows = await recordTrashList();
     return rows.map((entry) => ({ ...entry, record: maskRecordRow(entry.library, entry.shelf, entry.record) }));
@@ -415,7 +420,7 @@ app.get('/api/:library/:shelf', async (req, reply) => {
             let rows = await recordList(library, shelf, query, opts);
             if (req.user && tracksRecordActivity(req.headers))
                 rows = await applySmartRanking(req.user.id, library, shelf, rows);
-            return rows.map((r) => maskRecordRow(library, shelf, r));
+            return rows.map((r) => listRow(library, shelf, r));
         }
         const pageOpts = {
             ...opts,
@@ -431,7 +436,7 @@ app.get('/api/:library/:shelf', async (req, reply) => {
             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) => maskRecordRow(library, shelf, r)), total: page.total };
+        return { rows: page.rows.map((r) => listRow(library, shelf, r)), total: page.total };
     }
     catch (e) {
         if (e instanceof UnknownShelfError)

package/dist/mutate.js

@@ -3,6 +3,7 @@ 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 { selectRows } from "./read-rows.js";
 import { normalizeFileFields, dropUnchangedFileFields, touchesFileFields } from "./file-fields.js";
 import { notifyRecordsChanged } from "./index-signal.js";
 import { encodeTemporal, decodeTemporal } from "./temporal.js";
@@ -54,18 +55,14 @@ export async function listRecords(entityName, opts = {}) {
     const fork = getEm().fork();
     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);
+    return selectRows(fork, entityName, where, { orderBy: { id: 'asc' } });
 }
 export async function getRecord(m, entityName, id, opts = {}) {
     const fork = getEm().fork();
-    const row = await fork.findOne(entityName, {
-        id,
-        ...(opts.includeDeleted ? {} : { deleted_at: null }),
-    });
+    const [row] = await selectRows(fork, entityName, { id, ...(opts.includeDeleted ? {} : { deleted_at: null }) }, { limit: 1 });
     if (!row)
         return undefined;
-    const flat = decodeTemporal(m, serialize(row));
+    const flat = decodeTemporal(m, row);
     const nested = nestEmbedded(m, flat);
     const collections = await readCollections(fork, m, id);
     return { ...nested, ...collections };

package/dist/plugin-runtime.js

@@ -1,4 +1,3 @@
-import { serialize } from '@mikro-orm/core';
 import { composeRegistry } from '@coffer-org/core/compose';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { initDb, getOrm, getEm } from "./db.js";
@@ -6,6 +5,7 @@ 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 { selectRows } from "./read-rows.js";
 import { runMigrations, assertSafeRequired, renameSystemShelfKey } from "./migrations.js";
 import { runSeeds } from "./seeds.js";
 import { setActiveRegistry } from "./registry-context.js";
@@ -36,12 +36,10 @@ export function getDisabled() {
 export async function getPluginSettings(pluginId) {
     try {
         const fork = getEm().fork();
-        const row = await fork.findOne(`_settings__${pluginId}`, {
-            plugin_id: pluginId,
-        });
+        const [row] = await selectRows(fork, `_settings__${pluginId}`, { plugin_id: pluginId }, { limit: 1 });
         if (!row)
             return {};
-        return serialize(row);
+        return row;
     }
     catch {
         return {};

package/dist/read-rows.d.ts

@@ -0,0 +1,8 @@
+import type { EntityManager } from '@mikro-orm/core';
+export type SelectOpts = {
+    fields?: string[];
+    orderBy?: Record<string, 'ASC' | 'DESC' | 'asc' | 'desc'>;
+    limit?: number;
+    offset?: number;
+};
+export declare function selectRows(em: EntityManager, entityName: string, where?: Record<string, unknown>, opts?: SelectOpts): Promise<Record<string, unknown>[]>;

package/dist/read-rows.js

@@ -0,0 +1,11 @@
+export async function selectRows(em, entityName, where = {}, opts = {}) {
+    const qb = em.createQueryBuilder(entityName);
+    qb.select(opts.fields ?? '*').where(where);
+    if (opts.orderBy)
+        qb.orderBy(opts.orderBy);
+    if (opts.limit !== undefined)
+        qb.limit(opts.limit, opts.offset);
+    else if (opts.offset !== undefined)
+        qb.offset(opts.offset);
+    return (await qb.execute('all', true));
+}

package/dist/records-api.js

@@ -1,7 +1,7 @@
 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 { getActiveRegistry, getShelf, getExtendsFor } from "./registry-context.js";
+import { selectRows } from "./read-rows.js";
 import { shelfTableName } from "./entity-schema.js";
 import { getExtendRecord, getExtendRecords } from "./extend-table.js";
 import { getEm } from "./db.js";
@@ -15,7 +15,7 @@ export const MAX_PAGE = 500;
 function pickCols(row, cols) {
     const out = {};
     for (const c of cols)
-        if (c in row)
+        if (c in row && row[c] !== null)
             out[c] = row[c];
     return out;
 }
@@ -137,7 +137,7 @@ export async function recordList(library, shelf, query = {}, opts = {}) {
         ...(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));
+    let rows = await selectRows(fork, ename, where, findOpts);
     if (tokens.length > 0)
         rows = rows.filter((row) => rowMatch(m, row, tokens) !== null);
     if (projected)

package/package.json

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