@coffer-org/server 1.1.0 → 1.2.0

package/dist/plugin-hooks.d.ts

@@ -1,35 +1,45 @@
-/**
- * Серверні хуки життєвого циклу плагінів (server-only).
- *
- * Маніфест плагіна (@coffer-org/sdk/plugin) — ізоморфний і НЕ містить функцій (щоб не тягнути
- * серверні залежності у чисте ядро). Усе, що стосується сервера — міграції/seed/init/teardown —
- * реєструється тут, по id плагіна.
- *
- *   pluginHooks['people'] = {
- *     seed:     async (ctx) => { ... ідемпотентне наповнення ... },
- *     init:     async (ctx) => { ... запуск воркерів/перевірки ... },
- *     teardown: async (ctx) => { ... зняття (м'яке: лише cleanup стану) ... },
- *   };
- *
- * teardown за рішенням — М'ЯКЕ: таблиці/дані лишаються в БД,
- * плагін лише вимикається. ctx.em — fork-нутий EntityManager для seed/init операцій.
- *
- * Реальні хуки оголошуються у самих плагінах (serverHooks) і збираються
- * генерично через loadServerHooks() — тут лише контракт і порожній реєстр.
- */
 import type { EntityManager } from '@mikro-orm/core';
+import type { z } from 'zod';
+import type { ColumnType } from '@coffer-org/sdk/fields';
+export interface TableOps {
+    renameColumn(from: string, to: string): Promise<void>;
+    fill(column: string, value: string | number | boolean | null, opts?: {
+        where?: Record<string, string | number | boolean | null>;
+    }): Promise<void>;
+    changeType(column: string, newType: ColumnType, opts?: {
+        default?: string | number | boolean | null;
+        transform?: (old: unknown) => unknown;
+    }): Promise<void>;
+}
+export interface MigrationCtx {
+    table(name: string): TableOps;
+}
+export interface Migration {
+    version: number;
+    up(ctx: MigrationCtx): Promise<void> | void;
+}
 export interface PluginCtx {
-    /** Fork-нутий EntityManager для seed/init операцій. */
     em: EntityManager;
 }
+export interface Seed {
+    name: string;
+    run(ctx: PluginCtx): Promise<void> | void;
+}
+export interface AgentTool {
+    name: string;
+    description: string;
+    inputSchema: z.ZodRawShape;
+    handler: (args: Record<string, unknown>, ctx: PluginCtx) => Promise<unknown> | unknown;
+}
+export interface AgentContribution {
+    instructions?: string | ((ctx: PluginCtx) => string | Promise<string>);
+    tools?: AgentTool[];
+}
 export interface PluginHooks {
-    /** Ідемпотентне наповнення даними після міграцій. */
-    seed?(ctx: PluginCtx): Promise<void> | void;
-    /** Довільна ініціалізація після seed (воркери, перевірки). */
+    migrations?: Migration[];
+    seed?: Seed[];
     init?(ctx: PluginCtx): Promise<void> | void;
-    /** Зняття плагіна (м'яке): cleanup рантайм-стану. Дані НЕ дропаються. */
     teardown?(ctx: PluginCtx): Promise<void> | void;
+    agent?: AgentContribution;
 }
-/** Реєстр серверних хуків по id плагіна. Порожньо = плагін без серверної логіки. */
 export declare const pluginHooks: Record<string, PluginHooks>;
-//# sourceMappingURL=plugin-hooks.d.ts.map

package/dist/plugin-hooks.js

@@ -1,3 +1 @@
-/** Реєстр серверних хуків по id плагіна. Порожньо = плагін без серверної логіки. */
 export const pluginHooks = {};
-//# sourceMappingURL=plugin-hooks.js.map

package/dist/plugin-runtime.d.ts

@@ -1,36 +1,13 @@
 import { type Registry } from '@coffer-org/core/compose';
 import type { PluginManifest } from '@coffer-org/sdk/plugin';
 export declare function getPlugins(): Promise<PluginManifest[]>;
-/** Прочитати множину вимкнених плагінів із _plugins (core ніколи не вимкнено). */
 export declare function readDisabled(): Promise<Set<string>>;
-/**
- * Прочитати налаштування плагіна (singleton-запис у _settings__<id>).
- * Повертає {} якщо запис ще не збережено.
- */
 export declare function getPluginSettings(pluginId: string): Promise<Record<string, unknown>>;
-/**
- * Двофазний bootstrap БД. Повертає множину вимкнених плагінів.
- * Викликається сервером (через initPlugins) і CLI-скриптами напряму.
- */
 export declare function initStorage(): Promise<Set<string>>;
 export declare function initPlugins(): Promise<Registry>;
-/**
- * Graceful-зупинка воркерів активних плагінів (виклик teardown) на shutdown сервера.
- * Зворотний порядок відносно init. Помилки окремого плагіна не зупиняють решту.
- */
 export declare function teardownPlugins(): Promise<void>;
-/** М'яке зняття плагіна: лише cleanup-хук. Таблиці/дані НЕ дропаються. */
 export declare function teardownPlugin(id: string): Promise<void>;
-/**
- * ЯВНЕ видалення даних плагіна (безповоротне):
- * teardown-хук → DROP TABLE (модулі + extends) → enabled=0 → аудит.
- * Ідемпотентно: повторний виклик безпечний (IF EXISTS, findOne).
- * DDL у SQLite через knex виконується в авто-комміті, тому атомарності
- * між дропами нема — натомість послідовність безпечно перезапускається.
- */
 export declare function purgePluginData(p: PluginManifest, actor: string): Promise<void>;
-/** Pure filter: drop disabled ids, preserve input order. */
 export declare function filterEnabled<T extends {
     id: string;
 }>(all: T[], disabled: Set<string>): T[];
-//# sourceMappingURL=plugin-runtime.d.ts.map

package/dist/plugin-runtime.js

@@ -1,33 +1,18 @@
-/**
- * Оркестрація життєвого циклу плагінів на старті сервера (Рівень 1: набір — з БД).
- *
- *   initStorage() — двофазний bootstrap БД:
- *     1. initDb(системні схеми) → syncSchema() — _events/_folders/_plugins існують;
- *     2. seed рядків _plugins (нові → enabled=1) → читання вимкнених;
- *     3. discoverEntity(схеми АКТИВНИХ плагінів) → syncSchema() — таблиці плагінів.
- *   Entities вимкнених плагінів НЕ реєструються: їхні таблиці невідомі ORM,
- *   тому dropTables:false гарантує збереження даних (м'яке вимкнення).
- *
- *   initPlugins() = initStorage() + composeRegistry + seed/init хуки.
- *   purgePluginData() — ЯВНЕ видалення даних плагіна (DROP TABLE + _folders + enabled=0).
- *
- * core вимкнути не можна.
- */
-import { randomUUID } from 'node:crypto';
 import { serialize } from '@mikro-orm/core';
 import { composeRegistry } from '@coffer-org/core/compose';
-import { initDb, getOrm, getEm } from './db.js';
-import { syncSchema } from './schema-sync.js';
-import { systemEntities, buildPluginEntities, moduleTableName } from './entity-schema.js';
-import { pluginHooks } from './plugin-hooks.js';
-import { discoverPlugins, loadServerHooks } from './plugin-discovery.js';
-import { setActiveRegistry } from './registry-context.js';
-/** Кеш discovered-набору: discovery виконується раз на процес (перший виклик — на bootstrap). */
+import { initDb, getOrm, getEm } from "./db.js";
+import { syncSchema } from "./schema-sync.js";
+import { systemEntities, buildPluginEntities, moduleTableName } from "./entity-schema.js";
+import { pluginHooks } from "./plugin-hooks.js";
+import { discoverPlugins, loadServerHooks } from "./plugin-discovery.js";
+import { runMigrations, assertSafeRequired } from "./migrations.js";
+import { runSeeds } from "./seeds.js";
+import { setActiveRegistry } from "./registry-context.js";
+import { migrateEmbeddingVectorsToBlob } from "./embeddings.js";
 let _plugins = null;
 export async function getPlugins() {
     return (_plugins ??= await discoverPlugins());
 }
-/** Прочитати множину вимкнених плагінів із _plugins (core ніколи не вимкнено). */
 export async function readDisabled() {
     const fork = getEm().fork();
     const rows = await fork.find('_Plugin', { enabled: 0 });
@@ -35,10 +20,6 @@ export async function readDisabled() {
     disabled.delete('core');
     return disabled;
 }
-/**
- * Прочитати налаштування плагіна (singleton-запис у _settings__<id>).
- * Повертає {} якщо запис ще не збережено.
- */
 export async function getPluginSettings(pluginId) {
     try {
         const fork = getEm().fork();
@@ -53,7 +34,6 @@ export async function getPluginSettings(pluginId) {
         return {};
     }
 }
-/** Зареєструвати рядки _plugins для всіх відомих плагінів (нові → enabled=1). */
 async function seedPluginRows() {
     const fork = getEm().fork();
     const existing = new Set((await fork.find('_Plugin', {})).map((r) => r.id));
@@ -65,24 +45,25 @@ async function seedPluginRows() {
     }
     await fork.flush();
 }
-/**
- * Двофазний bootstrap БД. Повертає множину вимкнених плагінів.
- * Викликається сервером (через initPlugins) і CLI-скриптами напряму.
- */
 export async function initStorage() {
     await initDb(systemEntities);
-    await syncSchema(); // системні таблиці
-    // Legacy-зачистка: folder-інфраструктура прибрана. Колонку folder_id у таблицях
-    // модулів дропає syncSchema (safe:false); таблицю _folders — лише явний DROP
-    // (dropTables:false таблиці не чіпає). Ідемпотентно (IF EXISTS).
+    await syncSchema();
+    await migrateEmbeddingVectorsToBlob();
     await getEm().fork().getConnection().execute('DROP TABLE IF EXISTS "_folders"');
     await seedPluginRows();
     const disabled = await readDisabled();
     const active = (await getPlugins()).filter((p) => !disabled.has(p.id));
+    const hooks = await loadServerHooks();
+    await runMigrations({
+        em: getEm().fork(),
+        plugins: active.map((p) => ({ id: p.id, tables: pluginTables(p) })),
+        hooks,
+    });
     const pluginEntities = buildPluginEntities(active);
+    await assertSafeRequired(getEm().fork(), pluginEntities);
     if (pluginEntities.length)
         getOrm().discoverEntity(pluginEntities);
-    await syncSchema(); // таблиці/колонки активних плагінів
+    await syncSchema();
     return disabled;
 }
 export async function initPlugins() {
@@ -90,31 +71,24 @@ export async function initPlugins() {
     const reg = composeRegistry(await getPlugins(), { disabled });
     setActiveRegistry(reg);
     Object.assign(pluginHooks, await loadServerHooks());
+    await runSeeds({ em: getEm().fork(), plugins: reg.order, hooks: pluginHooks });
     for (const p of reg.order) {
         const h = pluginHooks[p.id];
         try {
-            if (h?.seed) {
-                await h.seed({ em: getEm().fork() });
-                console.log(`[plugin] ${p.id}: seed ✓`);
-            }
             if (h?.init) {
                 await h.init({ em: getEm().fork() });
                 console.log(`[plugin] ${p.id}: init ✓`);
             }
         }
         catch (err) {
-            console.error(`[plugin] ${p.id}: збій при ініціалізації`, err);
+            console.error(`[plugin] ${p.id}: initialization failure`, err);
             throw err;
         }
     }
-    console.log(`[plugin] активні: ${reg.order.map((p) => p.id).join(' ')}` +
-        (disabled.size ? ` | вимкнені: ${[...disabled].join(' ')}` : ''));
+    console.log(`[plugin] active: ${reg.order.map((p) => p.id).join(' ')}` +
+        (disabled.size ? ` | disabled: ${[...disabled].join(' ')}` : ''));
     return reg;
 }
-/**
- * Graceful-зупинка воркерів активних плагінів (виклик teardown) на shutdown сервера.
- * Зворотний порядок відносно init. Помилки окремого плагіна не зупиняють решту.
- */
 export async function teardownPlugins() {
     Object.assign(pluginHooks, await loadServerHooks());
     const disabled = await readDisabled();
@@ -132,7 +106,6 @@ export async function teardownPlugins() {
         }
     }
 }
-/** М'яке зняття плагіна: лише cleanup-хук. Таблиці/дані НЕ дропаються. */
 export async function teardownPlugin(id) {
     const h = pluginHooks[id];
     if (h?.teardown) {
@@ -140,56 +113,49 @@ export async function teardownPlugin(id) {
         console.log(`[plugin] ${id}: teardown ✓`);
     }
 }
-/** Пари (vault, module) усіх модулів плагіна — власні vault'и + vaultModules. */
 function pluginModules(p) {
     return [
         ...(p.vaults ?? []).flatMap((v) => v.modules.map((m) => ({ vault: m.vault, module: m.module }))),
         ...(p.vaultModules ?? []).map((m) => ({ vault: m.vault, module: m.module })),
     ];
 }
-/**
- * ЯВНЕ видалення даних плагіна (безповоротне):
- * teardown-хук → DROP TABLE (модулі + extends) → enabled=0 → аудит.
- * Ідемпотентно: повторний виклик безпечний (IF EXISTS, findOne).
- * DDL у SQLite через knex виконується в авто-комміті, тому атомарності
- * між дропами нема — натомість послідовність безпечно перезапускається.
- */
-export async function purgePluginData(p, actor) {
-    await teardownPlugin(p.id);
-    const tables = [
+function pluginTables(p) {
+    return [
         ...pluginModules(p).map(({ vault, module }) => moduleTableName(vault, module)),
         ...(p.extends_ ?? []).map((e) => `extend__${e.id}`),
         ...(p.settings && p.settings.fields.length > 0 ? [`_settings__${p.id}`] : []),
     ];
+}
+export async function purgePluginData(p, actor) {
+    await teardownPlugin(p.id);
+    const tables = pluginTables(p);
     const conn = getEm().fork().getConnection();
     for (const t of tables) {
         await conn.execute(`DROP TABLE IF EXISTS "${t}"`);
     }
-    // enabled=0 + аудит — однією транзакцією.
     await getEm()
         .fork()
         .transactional(async (tx) => {
         const now = new Date().toISOString();
+        await tx.nativeDelete('_Migration', { plugin_id: p.id });
+        await tx.nativeDelete('_Seed', { plugin_id: p.id });
         const row = await tx.findOne('_Plugin', { id: p.id });
         if (row)
             tx.assign(row, { enabled: 0, updated_at: now });
         else
             tx.create('_Plugin', { id: p.id, enabled: 0, updated_at: now });
         tx.create('_Event', {
-            id: randomUUID(),
             ts: now,
             actor,
             op: 'purge',
             type: p.id,
-            record_id: p.id,
+            record_id: null,
             before: null,
             after: null,
         });
     });
-    console.log(`[plugin] ${p.id}: purge ✓ (${tables.length} табл.)`);
+    console.log(`[plugin] ${p.id}: purge ✓ (${tables.length} tables)`);
 }
-/** Pure filter: drop disabled ids, preserve input order. */
 export function filterEnabled(all, disabled) {
     return all.filter((p) => !disabled.has(p.id));
 }
-//# sourceMappingURL=plugin-runtime.js.map

package/dist/plugin-state.d.ts

@@ -0,0 +1,2 @@
+export declare function getPluginState(plugin: string, key: string): Promise<string | null>;
+export declare function setPluginState(plugin: string, key: string, value: string): Promise<void>;

package/dist/plugin-state.js

@@ -0,0 +1,11 @@
+import { getEm } from "./db.js";
+export async function getPluginState(plugin, key) {
+    const em = getEm().fork();
+    const row = (await em.findOne('_PluginState', { plugin, key }));
+    return row?.value ?? null;
+}
+export async function setPluginState(plugin, key, value) {
+    const em = getEm().fork();
+    await em.upsert('_PluginState', { plugin, key, value });
+    await em.flush();
+}

package/dist/plugins-api.d.ts

@@ -1,3 +1,2 @@
 import type { FastifyInstance } from 'fastify';
 export declare function registerPluginsApi(app: FastifyInstance): Promise<void>;
-//# sourceMappingURL=plugins-api.d.ts.map

package/dist/plugins-api.js

@@ -1,16 +1,10 @@
 import { join } from 'node:path';
 import { createReadStream, existsSync, readFileSync } from 'node:fs';
-import { discoverPluginAssets } from './plugin-discovery.js';
-import { getPlugins, readDisabled } from './plugin-runtime.js';
+import { discoverPluginAssets } from "./plugin-discovery.js";
+import { getPlugins, readDisabled } from "./plugin-runtime.js";
 const nmRoot = () => join(process.cwd(), 'node_modules');
-// requested filename → key in package.json#coffer
 const ASSET_KEY = { 'schema.js': 'schema', 'web.js': 'web', 'web.css': 'css' };
 export async function registerPluginsApi(app) {
-    // Single /api/plugins manifest serving TWO consumers:
-    //   • the web federation loader — reads `enabled` + `schema`/`web`/`css` URLs;
-    //   • the admin SettingsPage — reads `enabled`/`vaults`/`extends`/`hasSettings`.
-    // Returns ALL discovered plugins (loader filters by `enabled` itself). Toggling
-    // is the canonical PATCH /api/plugins/:id (dependency-validated, in index.ts).
     app.get('/api/plugins', async () => {
         const [plugins, assets, disabled] = await Promise.all([getPlugins(), discoverPluginAssets(), readDisabled()]);
         const assetById = new Map(assets.map((a) => [a.id, a]));
@@ -30,7 +24,6 @@ export async function registerPluginsApi(app) {
             };
         });
     });
-    // Serve a plugin's built asset from node_modules: /plugins/<id>/<file>
     app.get('/plugins/:id/:file', async (req, reply) => {
         const { id, file } = req.params;
         const key = ASSET_KEY[file];
@@ -50,4 +43,3 @@ export async function registerPluginsApi(app) {
         return reply.send(createReadStream(abs));
     });
 }
-//# sourceMappingURL=plugins-api.js.map

package/dist/records-api.d.ts

@@ -0,0 +1,19 @@
+import type { ModuleDef } from '@coffer-org/sdk/module';
+export declare class UnknownTypeError extends Error {
+}
+export type RecordListQuery = {
+    q?: string;
+    id?: string;
+    [field: string]: string | number | undefined;
+};
+export declare function coerceFilter(v: string, column: string): unknown;
+export declare function withExtends(record: Record<string, unknown>, vault: string, module: string): Promise<Record<string, unknown>>;
+export declare function rowMatch(mdef: ModuleDef, row: Record<string, unknown>, tokens: string[]): {
+    score: number;
+    snippet: string;
+} | null;
+export declare function recordList(vault: string, type: string, query?: RecordListQuery): Promise<Record<string, unknown>[]>;
+export declare function recordGet(vault: string, type: string, id: number): Promise<Record<string, unknown> | null>;
+export declare function recordCreate(vault: string, type: string, body: unknown, actor?: string): Promise<Record<string, unknown>>;
+export declare function recordUpdate(vault: string, type: string, id: number, body: unknown, actor?: string): Promise<Record<string, unknown>>;
+export declare function recordDelete(vault: string, type: string, id: number, actor?: string): Promise<void>;

package/dist/records-api.js

@@ -0,0 +1,116 @@
+import { fieldMap, textSearchKeys, titleKey, recordTitle } from '@coffer-org/sdk/module';
+import { tokenize, matchScoreFolded, foldText } from '@coffer-org/core/search';
+import { serialize } from '@mikro-orm/core';
+import { getModule, getExtendsFor } from "./registry-context.js";
+import { moduleTableName } from "./entity-schema.js";
+import { getExtendRecord } from "./extend-table.js";
+import { getEm } from "./db.js";
+import { decodeTemporal, dtStringToDate } from "./temporal.js";
+import { splitBody, saveExtends, deleteExtends, validateExtends } from "./extend-io.js";
+import { createRecord, updateRecord, getRecord, deleteRecord } from "./mutate.js";
+export class UnknownTypeError extends Error {
+}
+function resolve(vault, type) {
+    const m = getModule(vault, type);
+    if (!m)
+        throw new UnknownTypeError(`unknown_type ${vault}/${type}`);
+    return { m, ename: moduleTableName(m.vault, m.module) };
+}
+export function coerceFilter(v, column) {
+    if (column === 'integer' || column === 'real') {
+        const n = Number(v);
+        return Number.isNaN(n) ? v : n;
+    }
+    if (column === 'boolean')
+        return v === 'true' || v === '1';
+    if (column === 'datetime')
+        return dtStringToDate(v);
+    return v;
+}
+export async function withExtends(record, vault, module) {
+    const matchedExtends = getExtendsFor(vault, module);
+    if (!matchedExtends.length)
+        return record;
+    const _extends = {};
+    await Promise.all(matchedExtends.map(async (e) => {
+        _extends[e.id] = (await getExtendRecord(e, record.id)) ?? null;
+    }));
+    return { ...record, _extends };
+}
+export function rowMatch(mdef, row, tokens) {
+    const textKeys = textSearchKeys(mdef);
+    if (!textKeys.length)
+        return null;
+    const tk = titleKey(mdef);
+    const otherKeys = textKeys.filter((key) => key !== tk);
+    const label = recordTitle(mdef, row);
+    const otherRaw = otherKeys.map((key) => String(row[key] ?? ''));
+    const foldedOthers = otherRaw.map(foldText);
+    const score = matchScoreFolded(foldText(label), foldedOthers, tokens);
+    if (score === null)
+        return null;
+    const hitIdx = foldedOthers.findIndex((f) => tokens.some((t) => f.includes(t)));
+    const raw = (hitIdx >= 0 ? otherRaw[hitIdx] : label) ?? label;
+    const snippet = raw.length > 120 ? raw.slice(0, 120) + '…' : raw;
+    return { score, snippet };
+}
+export async function recordList(vault, type, query = {}) {
+    const { m, ename } = resolve(vault, type);
+    const { q, ...filterParams } = query;
+    const where = {};
+    const fm = fieldMap(m.fields);
+    for (const [k, v] of Object.entries(filterParams)) {
+        if (k === 'id' || v === undefined)
+            continue;
+        const fieldDef = fm[k];
+        if (fieldDef && !fieldDef.virtual)
+            where[k] = coerceFilter(String(v), fieldDef.column);
+    }
+    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 };
+    }
+    if (m.standalone === false && Object.keys(where).length === 0)
+        return [];
+    const fork = getEm().fork();
+    let rows = (await fork.find(ename, where)).map((r) => serialize(r));
+    const tokens = typeof q === 'string' && q ? tokenize(q) : [];
+    if (tokens.length > 0)
+        rows = rows.filter((row) => rowMatch(m, row, tokens) !== null);
+    const decoded = rows.map((r) => decodeTemporal(m, r));
+    return Promise.all(decoded.map((row) => withExtends(row, vault, type)));
+}
+export async function recordGet(vault, type, id) {
+    const { m, ename } = resolve(vault, type);
+    if (m.standalone === false)
+        return null;
+    const row = await getRecord(m, ename, id);
+    if (!row)
+        return null;
+    return withExtends(row, vault, type);
+}
+export async function recordCreate(vault, type, body, actor = 'gui') {
+    const { m, ename } = resolve(vault, type);
+    const { base, extData } = splitBody(body);
+    validateExtends(vault, type, extData);
+    const row = await createRecord(m, ename, base, { actor });
+    await saveExtends(vault, type, row.id, extData);
+    return withExtends(row, vault, type);
+}
+export async function recordUpdate(vault, type, id, body, actor = 'gui') {
+    const { m, ename } = resolve(vault, type);
+    const { base, extData } = splitBody(body);
+    validateExtends(vault, type, extData);
+    const row = await updateRecord(m, ename, id, base, { actor });
+    await saveExtends(vault, type, id, extData);
+    return withExtends(row, vault, type);
+}
+export async function recordDelete(vault, type, id, actor = 'gui') {
+    const { m, ename } = resolve(vault, type);
+    await deleteRecord(m, ename, id, { actor });
+    await deleteExtends(vault, type, id);
+}

package/dist/registry-context.d.ts

@@ -1,11 +1,5 @@
-/**
- * Серверний реєстр-контекст: активний composeRegistry, заданий на boot (initPlugins).
- * Розриває цикл server→@registry(app root)→plugins→server. getModule/getExtendsFor
- * беруться звідси (делегують у рантайм-реєстр), а не зі статичного src/registry.ts.
- */
 import type { Registry } from '@coffer-org/core/compose';
-/** Встановлюється раз на boot із initPlugins(). */
 export declare function setActiveRegistry(reg: Registry): void;
+export declare function getActiveRegistry(): Registry;
 export declare const getModule: Registry['getModule'];
 export declare const getExtendsFor: Registry['getExtendsFor'];
-//# sourceMappingURL=registry-context.d.ts.map

package/dist/registry-context.js

@@ -1,13 +1,14 @@
 let active = null;
-/** Встановлюється раз на boot із initPlugins(). */
 export function setActiveRegistry(reg) {
     active = reg;
 }
 function current() {
     if (!active)
-        throw new Error('[registry-context] реєстр ще не ініціалізовано (виклич setActiveRegistry)');
+        throw new Error('[registry-context] registry not initialized yet (call setActiveRegistry)');
     return active;
 }
+export function getActiveRegistry() {
+    return current();
+}
 export const getModule = (vault, module) => current().getModule(vault, module);
 export const getExtendsFor = (vault, module) => current().getExtendsFor(vault, module);
-//# sourceMappingURL=registry-context.js.map

package/dist/schema-api.d.ts

@@ -0,0 +1 @@
+export declare function buildClientSchema(): unknown[];

package/dist/schema-api.js

@@ -0,0 +1,11 @@
+import { moduleToClient } from '@coffer-org/sdk/module';
+import { extendToClient } from '@coffer-org/sdk/extend';
+import { getActiveRegistry } from "./registry-context.js";
+export function buildClientSchema() {
+    const { vaults, extends_ } = getActiveRegistry();
+    return vaults.map((v) => ({
+        ...v.meta,
+        modules: v.modules.map(moduleToClient),
+        extends: extends_.filter((e) => e.attachTo.some((r) => r.vault === v.meta.id)).map(extendToClient),
+    }));
+}

package/dist/schema-sync.d.ts

@@ -1,2 +1 @@
 export declare function syncSchema(): Promise<void>;
-//# sourceMappingURL=schema-sync.d.ts.map

package/dist/schema-sync.js

@@ -1,13 +1,4 @@
-/**
- * Синхронізація схеми БД зі схемами сутностей у рантаймі (без міграцій).
- *
- * safe:false       — повний синк колонок ВІДОМИХ таблиць (додавання + видалення);
- *                    видалене з f.* поле → колонка дропається при наступному старті.
- * dropTables:false — таблиці, невідомі ORM (purge-нуті/вимкнені плагіни, legacy),
- *                    не чіпаються ніколи. Дроп таблиць — лише явний purge.
- */
-import { getOrm } from './db.js';
+import { getOrm } from "./db.js";
 export async function syncSchema() {
     await getOrm().schema.update({ safe: false, dropTables: false });
 }
-//# sourceMappingURL=schema-sync.js.map

package/dist/secrets.d.ts

@@ -0,0 +1,7 @@
+import type { LayoutEl } from '@coffer-org/sdk/fields';
+export declare const MASK = "********";
+export declare function passwordKeys(fields: LayoutEl[]): string[];
+export declare function maskSecrets(fields: LayoutEl[], row: Record<string, unknown>): Record<string, unknown>;
+export declare function preserveSecrets(fields: LayoutEl[], incoming: Record<string, unknown>, existing: Record<string, unknown>): Record<string, unknown>;
+export declare function maskTree(fields: LayoutEl[], obj: Record<string, unknown>): Record<string, unknown>;
+export declare function preserveTree(fields: LayoutEl[], incoming: Record<string, unknown>, existing: Record<string, unknown>): Record<string, unknown>;

package/dist/secrets.js

@@ -0,0 +1,60 @@
+import { fieldEntries, collectionGroups } from '@coffer-org/sdk/module';
+export const MASK = '********';
+export function passwordKeys(fields) {
+    return fieldEntries(fields)
+        .filter(([, f]) => f.kind === 'password')
+        .map(([k]) => k);
+}
+export function maskSecrets(fields, row) {
+    const out = { ...row };
+    for (const k of passwordKeys(fields))
+        if (out[k])
+            out[k] = MASK;
+    return out;
+}
+export function preserveSecrets(fields, incoming, existing) {
+    const out = { ...incoming };
+    for (const k of passwordKeys(fields)) {
+        if (out[k] !== MASK)
+            continue;
+        if (existing[k] !== undefined && existing[k] !== null)
+            out[k] = existing[k];
+        else
+            delete out[k];
+    }
+    return out;
+}
+export function maskTree(fields, obj) {
+    const out = maskSecrets(fields, obj);
+    for (const c of collectionGroups(fields)) {
+        const key = c.key;
+        const sub = c.group.fields;
+        const arr = out[key];
+        if (Array.isArray(arr)) {
+            out[key] = arr.map((item) => item && typeof item === 'object' ? maskTree(sub, item) : item);
+        }
+    }
+    return out;
+}
+export function preserveTree(fields, incoming, existing) {
+    const out = preserveSecrets(fields, incoming, existing);
+    for (const c of collectionGroups(fields)) {
+        const key = c.key;
+        const sub = c.group.fields;
+        const uniq = c.group.unique ?? [];
+        const inArr = out[key];
+        if (!Array.isArray(inArr))
+            continue;
+        const exArr = Array.isArray(existing[key]) ? existing[key] : [];
+        out[key] = inArr.map((item) => {
+            if (!item || typeof item !== 'object')
+                return item;
+            const rec = item;
+            const match = uniq.length > 0
+                ? exArr.find((e) => e && uniq.every((u) => e[u] === rec[u]))
+                : undefined;
+            return preserveTree(sub, rec, (match ?? {}));
+        });
+    }
+    return out;
+}