@coffer-org/server 3.3.0 → 3.4.0

package/dist/collection-io.js

@@ -151,11 +151,12 @@ export function flattenEmbeddedAt(fields, input) {
         }
     }
     for (const [key, subs] of columnsTargets(fields)) {
+        if (!(key in out))
+            continue;
         const obj = out[key];
         delete out[key];
-        if (obj && typeof obj === 'object')
-            for (const s of subs)
-                out[`${key}__${s}`] = obj[s];
+        for (const s of subs)
+            out[`${key}__${s}`] = obj && typeof obj === 'object' ? obj[s] : null;
     }
     return out;
 }
@@ -163,16 +164,18 @@ export function nestEmbeddedAt(fields, row) {
     const out = { ...row };
     for (const [key, subs] of columnsTargets(fields)) {
         const nested = {};
-        let any = false;
+        let filled = false;
         for (const s of subs) {
             const col = `${key}__${s}`;
-            if (col in out) {
-                nested[s] = out[col];
-                delete out[col];
-                any = true;
-            }
+            if (!(col in out))
+                continue;
+            const v = out[col];
+            nested[s] = v;
+            delete out[col];
+            if (v != null && v !== '')
+                filled = true;
         }
-        if (any)
+        if (filled)
             out[key] = nested;
     }
     for (const [key, g] of embeddedGroups(fields)) {

package/dist/db.js

@@ -2,6 +2,7 @@ import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { MikroORM, EntityCaseNamingStrategy } from '@mikro-orm/core';
 import { SqliteDriver } from '@mikro-orm/sqlite';
+import { disableColumnRenameDetection } from "./rename-guard.js";
 const SKIP_TABLES = [/^_search(_|$)/];
 let _orm;
 export function getOrm() {
@@ -21,6 +22,7 @@ export async function closeDb() {
     _orm = undefined;
 }
 export async function initDb(entities) {
+    disableColumnRenameDetection();
     const driverName = process.env['DB_DRIVER'] ?? 'sqlite';
     const common = {
         entities,

package/dist/entity-schema.d.ts

@@ -13,6 +13,7 @@ export declare function buildExtendCollectionEntities(e: ExtendDef): EntitySchem
 export declare const EventSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const PluginRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const MigrationRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const MigrationOpRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 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>>;

package/dist/entity-schema.js

@@ -122,6 +122,25 @@ export const MigrationRowSchema = new EntitySchema({
         version: { type: 'integer', nullable: false },
     },
 });
+export const MigrationOpRowSchema = new EntitySchema({
+    name: '_MigrationOp',
+    tableName: '_migration_ops',
+    properties: {
+        plugin_id: { type: 'text', primary: true },
+        version: { type: 'integer', primary: true },
+        seq: { type: 'integer', primary: true },
+        op: { type: 'text', nullable: false },
+        table_name: { type: 'text', nullable: false },
+        performed: { type: 'integer', nullable: false },
+        rows: { type: 'integer', nullable: true },
+        scanned: { type: 'integer', nullable: true },
+        code: { type: 'text', nullable: true },
+        reason: { type: 'text', nullable: true },
+        empty_targets: { type: 'text', nullable: true },
+        stranded_sources: { type: 'text', nullable: true },
+        applied_at: { type: 'text', nullable: true },
+    },
+});
 export const SeedRowSchema = new EntitySchema({
     name: '_Seed',
     tableName: '_seeds',
@@ -296,6 +315,7 @@ export const systemEntities = [
     EventSchema,
     PluginRowSchema,
     MigrationRowSchema,
+    MigrationOpRowSchema,
     SeedRowSchema,
     EmbeddingSchema,
     PluginStateSchema,

package/dist/extend-io.d.ts

@@ -1,9 +1,10 @@
 import type { EntityManager } from '@mikro-orm/core';
+import type { PartMemo } from './part-injection.ts';
 export declare function splitBody(body: unknown): {
     base: Record<string, unknown>;
     extData: Record<string, Record<string, unknown>>;
 };
 export declare function deleteExtends(em: EntityManager, library: string, shelf: string, id: number): Promise<void>;
-export declare function readExtends(em: EntityManager, library: string, shelf: string, id: number): Promise<Record<string, unknown>>;
+export declare function readExtends(em: EntityManager, library: string, shelf: string, id: number, memo?: PartMemo): Promise<Record<string, unknown>>;
 export declare function validateExtends(library: string, shelf: string, extData: Record<string, Record<string, unknown>>): void;
-export declare function saveExtends(em: EntityManager, library: string, shelf: string, baseId: number, extData: Record<string, Record<string, unknown>>): Promise<void>;
+export declare function saveExtends(em: EntityManager, library: string, shelf: string, baseId: number, extData: Record<string, Record<string, unknown>>, memo?: PartMemo): Promise<void>;

package/dist/extend-io.js

@@ -20,10 +20,10 @@ export async function deleteExtends(em, library, shelf, id) {
         await deleteExtendRecord(em, e, id);
     }
 }
-export async function readExtends(em, library, shelf, id) {
+export async function readExtends(em, library, shelf, id, memo) {
     const out = {};
     for (const e of getExtendsFor(library, shelf)) {
-        out[e.id] = (await getExtendRecord(e, id, em)) ?? null;
+        out[e.id] = (await getExtendRecord(e, id, em, memo)) ?? null;
     }
     return out;
 }
@@ -41,7 +41,7 @@ export function validateExtends(library, shelf, extData) {
     if (issues.length)
         throw new ValidationError(issues);
 }
-export async function saveExtends(em, library, shelf, baseId, extData) {
+export async function saveExtends(em, library, shelf, baseId, extData, memo) {
     validateExtends(library, shelf, extData);
     for (const e of getExtendsFor(library, shelf)) {
         const data = extData[e.id];
@@ -53,7 +53,7 @@ export async function saveExtends(em, library, shelf, baseId, extData) {
             const fileIssues = normalizeFileFieldsAt(e.fields, row);
             if (fileIssues.length)
                 throw new ValidationError(fileIssues);
-            await upsertExtendRecord(em, e, baseId, row);
+            await upsertExtendRecord(em, e, baseId, row, memo);
         }
     }
 }

package/dist/extend-table.d.ts

@@ -1,9 +1,10 @@
 import type { EntityManager } from '@mikro-orm/core';
 import type { ExtendDef } from '@coffer-org/sdk/extend';
+import { type PartMemo } from './part-injection.ts';
 type Row = Record<string, unknown>;
 export declare function extendEntityName(e: ExtendDef): string;
-export declare function getExtendRecord(e: ExtendDef, baseId: number, em?: EntityManager): Promise<Row | undefined>;
+export declare function getExtendRecord(e: ExtendDef, baseId: number, em?: EntityManager, memo?: PartMemo): Promise<Row | undefined>;
 export declare function getExtendRecords(e: ExtendDef, baseIds: number[], em?: EntityManager): Promise<Map<number, Row>>;
-export declare function upsertExtendRecord(em: EntityManager, e: ExtendDef, baseId: number, data: Row): Promise<void>;
+export declare function upsertExtendRecord(em: EntityManager, e: ExtendDef, baseId: number, data: Row, memo?: PartMemo): Promise<void>;
 export declare function deleteExtendRecord(em: EntityManager, e: ExtendDef, baseId: number): Promise<void>;
 export {};

package/dist/extend-table.js

@@ -4,14 +4,20 @@ import { encodeJsonAt } from "./mutate.js";
 import { encodeTemporalAt, decodeTemporalAt } from "./temporal.js";
 import { chunk } from "./batch.js";
 import { selectRows } from "./read-rows.js";
-import { injectParts, applyStoredParts } from "./part-injection.js";
+import { injectParts, applyStoredParts, hasStoredPartWork, } from "./part-injection.js";
 export function extendEntityName(e) {
     return `extend__${e.id}`;
 }
-function extendPartCtx(e, record) {
-    return { record, settings: {}, global: {}, meta: { library: 'extend', shelf: e.id } };
+function extendPartCtx(e, em, memo) {
+    return {
+        settings: {},
+        global: {},
+        meta: { library: 'extend', shelf: e.id },
+        ...(em ? { em } : {}),
+        ...(memo ? { memo } : {}),
+    };
 }
-export async function getExtendRecord(e, baseId, em) {
+export async function getExtendRecord(e, baseId, em, memo) {
     const fork = em ?? getEm().fork();
     const name = extendEntityName(e);
     const [flat] = (await selectRows(fork, name, { base_id: baseId }, { limit: 1 }));
@@ -20,7 +26,7 @@ export async function getExtendRecord(e, baseId, em) {
     const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
     const collections = await readAt(fork, name, e.fields, baseId);
     const record = { ...decoded, ...collections };
-    return injectParts(e.fields, record, extendPartCtx(e, record));
+    return injectParts(e.fields, record, extendPartCtx(e, em, memo));
 }
 export async function getExtendRecords(e, baseIds, em) {
     const out = new Map();
@@ -40,14 +46,31 @@ export async function getExtendRecords(e, baseIds, em) {
         const id = Number(flat.base_id);
         const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
         const record = { ...decoded, ...(collectionsById.get(id) ?? {}) };
-        out.set(id, await injectParts(e.fields, record, extendPartCtx(e, record)));
+        out.set(id, await injectParts(e.fields, record, extendPartCtx(e, em)));
     }
     return out;
 }
-export async function upsertExtendRecord(em, e, baseId, data) {
+async function storedExtendState(em, e, baseId) {
     const name = extendEntityName(e);
-    const withParts = await applyStoredParts(e.fields, data, extendPartCtx(e, data));
-    const { base, collections } = splitAt(e.fields, withParts);
+    const [flat] = (await selectRows(em, name, { base_id: baseId }, { limit: 1 }));
+    if (!flat)
+        return {};
+    const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
+    return { ...decoded, ...(await readAt(em, name, e.fields, baseId)) };
+}
+export async function upsertExtendRecord(em, e, baseId, data, memo) {
+    const name = extendEntityName(e);
+    const needParts = hasStoredPartWork(e.fields);
+    const target = needParts ? { ...(await storedExtendState(em, e, baseId)), ...data } : data;
+    const withParts = await applyStoredParts(e.fields, target, extendPartCtx(e, em, memo));
+    const write = {};
+    for (const [k, v] of Object.entries(withParts))
+        if (k in data || v !== target[k])
+            write[k] = v;
+    const { base, collections } = splitAt(e.fields, write);
+    for (const k of Object.keys(collections))
+        if (!(k in data))
+            delete collections[k];
     const flat = encodeJsonAt(e.fields, encodeTemporalAt(e.fields, flattenEmbeddedAt(e.fields, base)));
     await em.upsert(name, { base_id: baseId, ...flat });
     await writeAt(em, name, e.fields, baseId, collections);

package/dist/http-errors.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyInstance } from 'fastify';
+export interface HttpError {
+    code: number;
+    body: Record<string, unknown>;
+}
+export declare function httpErrorFor(e: unknown): HttpError | null;
+export declare function registerErrorHandler(app: FastifyInstance): void;

package/dist/http-errors.js

@@ -0,0 +1,24 @@
+import { ValidationError, NotFoundError } from "./mutate.js";
+import { SingleShelfError } from "./records-api.js";
+import { PartContractError } from "./part-errors.js";
+export function httpErrorFor(e) {
+    if (e instanceof ValidationError)
+        return { code: 422, body: { error: 'validation', issues: e.issues } };
+    if (e instanceof SingleShelfError)
+        return { code: 409, body: { error: 'single_shelf', message: e.message } };
+    if (e instanceof NotFoundError)
+        return { code: 404, body: { error: 'not_found' } };
+    if (e instanceof PartContractError)
+        return { code: 500, body: { error: 'part_contract', message: e.message } };
+    return null;
+}
+export function registerErrorHandler(app) {
+    app.setErrorHandler((error, req, reply) => {
+        const mapped = httpErrorFor(error);
+        if (!mapped)
+            return reply.send(error);
+        if (mapped.code >= 500)
+            req.log.error(error);
+        return reply.code(mapped.code).send(mapped.body);
+    });
+}

package/dist/index.js

@@ -11,7 +11,8 @@ import fastifyStatic from '@fastify/static';
 import { shelfTableName } from "./entity-schema.js";
 import { getEm, closeDb } from "./db.js";
 import { recordCounts } from "./counts.js";
-import { ValidationError, NotFoundError } from "./mutate.js";
+import { NotFoundError } from "./mutate.js";
+import { httpErrorFor, registerErrorHandler } from "./http-errors.js";
 import { resolveEmbed } from "./embed.js";
 import { resolveWithinHome, filterSort, listDir } from "./fs-list.js";
 import { initPlugins, teardownPlugins, readDisabled, purgePluginData, getPluginSettings, getPlugins, } from "./plugin-runtime.js";
@@ -24,7 +25,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, recordRestore, recordPurge, recordTrashList, MAX_PAGE, UnknownShelfError, ensureSingle, SingleShelfError, } from "./records-api.js";
+import { recordList, recordListPage, isPagedRequest, recordGet, recordCreate, recordUpdate, recordDelete, recordRestore, recordPurge, recordTrashList, MAX_PAGE, UnknownShelfError, FilterError, ensureSingle, } 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";
@@ -117,6 +118,7 @@ app.post('/api/embed', async (req, reply) => {
         return reply.code(422).send({ error: 'unresolved' });
     return reply.send(rec);
 });
+registerErrorHandler(app);
 function key(library, shelf) {
     return `${library}/${shelf}`;
 }
@@ -125,13 +127,11 @@ async function guard(reply, fn) {
         return await fn();
     }
     catch (e) {
-        if (e instanceof ValidationError)
-            return reply.code(422).send({ error: 'validation', issues: e.issues });
-        if (e instanceof SingleShelfError)
-            return reply.code(409).send({ error: 'single_shelf', message: e.message });
-        if (e instanceof NotFoundError)
-            return reply.code(404).send({ error: 'not_found' });
-        app.log.error(e);
+        const mapped = httpErrorFor(e);
+        if (!mapped || mapped.code >= 500)
+            app.log.error(e);
+        if (mapped)
+            return reply.code(mapped.code).send(mapped.body);
         return reply.code(500).send({ error: 'internal' });
     }
 }
@@ -445,6 +445,8 @@ app.get('/api/:library/:shelf', async (req, reply) => {
     catch (e) {
         if (e instanceof UnknownShelfError)
             return reply.code(404).send({ error: 'unknown_shelf' });
+        if (e instanceof FilterError)
+            return reply.code(400).send({ error: 'bad_filter', message: e.message });
         throw e;
     }
 });

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, recordTrashList, recordRestore, recordPurge, SingleShelfError, } from "./records-api.js";
+import { recordList, recordListPage, recordGet, recordCreate, recordUpdate, recordDelete, UnknownShelfError, recordTrashList, recordRestore, recordPurge, SingleShelfError, FilterError, } from "./records-api.js";
 import { ValidationError as ServerValidationError } from "./mutate.js";
 import { buildClientSchema } from "./schema-api.js";
 export function mapError(e) {
@@ -9,6 +9,8 @@ export function mapError(e) {
         throw new NotFoundError('not_found');
     if (e instanceof SingleShelfError)
         throw new ValidationError([{ field: 'shelf', code: 'single_shelf', message: e.message }]);
+    if (e instanceof FilterError)
+        throw new ValidationError([{ field: 'query', code: 'bad_filter', message: e.message }]);
     throw e;
 }
 export function splitListQuery(raw) {

package/dist/migrations.d.ts

@@ -1,5 +1,7 @@
 import type { EntityManager, EntitySchema } from '@mikro-orm/core';
 import type { Migration, PluginHooks, TableOps } from './plugin-hooks.ts';
+export declare function markColumnHandedOver(table: string, column: string): void;
+export declare function isColumnHandedOver(table: string, column: string): boolean;
 export declare function introspectTable(em: EntityManager, table: string): Promise<{
     exists: boolean;
     columns: Set<string>;
@@ -9,7 +11,23 @@ export declare function introspectTable(em: EntityManager, table: string): Promi
         primary: boolean;
     }[];
 }>;
-export declare function makeTable(em: EntityManager, table: string): TableOps;
+export declare function introspectAllColumns(em: EntityManager, tables: string[]): Promise<Map<string, Set<string>>>;
+export type MigrationOpCode = 'no-table' | 'no-rows' | 'no-change' | 'no-source-column' | 'target-column-exists' | 'converted-nothing';
+export declare const CONCERNING_CODES: ReadonlySet<MigrationOpCode>;
+export interface MigrationOp {
+    op: 'renameColumn' | 'fill' | 'changeType' | 'convert' | 'dropColumn';
+    table: string;
+    performed: boolean;
+    rows?: number;
+    scanned?: number;
+    emptyTargets?: string[];
+    strandedSources?: string[];
+    code?: MigrationOpCode;
+    reason?: string;
+}
+export type OpRecorder = (op: MigrationOp) => void;
+export declare function describeMigrationConcerns(plugin: string, version: number, ops: MigrationOp[]): string | null;
+export declare function makeTable(em: EntityManager, table: string, record?: OpRecorder): TableOps;
 export declare function renameSystemShelfKey(em: EntityManager): Promise<void>;
 export declare function validateMigrations(pluginId: string, list: Migration[]): void;
 interface RunArgs {
@@ -19,7 +37,12 @@ interface RunArgs {
         tables?: string[];
     }[];
     hooks: Record<string, PluginHooks>;
+    onApplied?: (r: {
+        plugin: string;
+        version: number;
+        ops: MigrationOp[];
+    }) => void;
 }
-export declare function runMigrations({ em, plugins, hooks }: RunArgs): Promise<void>;
+export declare function runMigrations({ em, plugins, hooks, onApplied }: RunArgs): Promise<void>;
 export declare function assertSafeRequired(em: EntityManager, entities: EntitySchema[]): Promise<void>;
 export {};