@coffer-org/server 1.1.0 → 1.2.0

package/dist/entity-schema.js

@@ -1,13 +1,5 @@
-/**
- * MikroORM EntitySchema — похідна від ModuleDef/ExtendDef (джерело істини: f.*).
- * DB-agnostic: імпортує лише @mikro-orm/core + типи ядра.
- * Колонки: text→text, integer→integer, real→float, boolean→boolean.
- *
- * Фізичну схему створює runtime-синк (schema-sync.ts) з цих описів.
- * Тут — лише in-memory опис для типобезпечних запитів.
- */
 import { EntitySchema } from '@mikro-orm/core';
-import { fieldEntries, collectionGroups } from '@coffer-org/sdk/module';
+import { fieldEntries, collectionGroups, storageColumns } from '@coffer-org/sdk/module';
 function mikroType(col) {
     if (col === 'integer')
         return 'integer';
@@ -23,103 +15,91 @@ function mikroType(col) {
         return 'datetime';
     return 'text';
 }
-/** Ім'я сутності (= ім'я таблиці) для модуля: vault__module. */
+function columnProp(field, nullable) {
+    const p = { type: mikroType(field.column), nullable };
+    if (field.default !== undefined)
+        p['default'] = field.default;
+    return p;
+}
+function addFieldProps(properties, fields, plainNullable) {
+    for (const [key, field] of fieldEntries(fields)) {
+        if (field.virtual)
+            continue;
+        if (field.columns) {
+            for (const [col, type] of storageColumns(key, field))
+                properties[col] = { type: mikroType(type), nullable: true };
+        }
+        else {
+            properties[key] = columnProp(field, plainNullable(field));
+        }
+    }
+}
 export function moduleTableName(vault, module) {
     return `${vault}__${module}`;
 }
-/** EntitySchema для одного модуля плагіна. */
 export function buildEntitySchema(m) {
-    // Використовуємо Record<string, any> — EntitySchemaProperty — складний умовний тип,
-    // тому будуємо properties динамічно і передаємо через as any.
     const properties = {
-        id: { type: 'text', primary: true }, // ЄДИНЕ обов'язкове системне поле
-        created_at: { type: 'text' }, // інфраструктура (авто-керована, поза fields)
+        id: { type: 'integer', primary: true, autoincrement: true },
+        created_at: { type: 'text' },
         updated_at: { type: 'text' },
     };
-    for (const [key, field] of fieldEntries(m.fields)) {
-        if (field.virtual)
-            continue;
-        properties[key] = {
-            type: mikroType(field.column),
-            nullable: !field.required,
-        };
-    }
+    addFieldProps(properties, m.fields, (f) => !f.required);
     const name = moduleTableName(m.vault, m.module);
     return new EntitySchema({ name, tableName: name, properties });
 }
-/** EntitySchema для extend-таблиці (PK = base_id). */
 export function buildExtendEntitySchema(e) {
     const properties = {
-        base_id: { type: 'text', primary: true },
+        base_id: { type: 'integer', primary: true },
     };
-    for (const [key, field] of fieldEntries(e.fields)) {
-        if (field.virtual)
-            continue;
-        properties[key] = { type: mikroType(field.column), nullable: true };
-    }
+    addFieldProps(properties, e.fields, () => true);
     const name = `extend__${e.id}`;
     return new EntitySchema({ name, tableName: name, properties });
 }
-/** EntitySchema для singleton-таблиці налаштувань плагіна. PK = plugin_id. */
 export function buildSettingsEntitySchema(pluginId, settings) {
     const properties = {
         plugin_id: { type: 'text', primary: true },
     };
-    for (const [key, field] of fieldEntries(settings.fields)) {
-        if (field.virtual)
-            continue;
-        properties[key] = {
-            type: mikroType(field.column),
-            nullable: !field.required,
-        };
-    }
+    addFieldProps(properties, settings.fields, (f) => !f.required);
     const name = `_settings__${pluginId}`;
     return new EntitySchema({ name, tableName: name, properties });
 }
-// ─── Collection-групи → child-таблиці ──────────────────────────────────────
-/** Ім'я child-таблиці collection-групи. */
 export function childTableName(vault, module, key) {
     return `${vault}__${module}__${key}`;
 }
-/** Child EntitySchema для однієї collection-групи. */
-function buildChildSchema(vault, module, c) {
+function buildChildSchemaAt(prefix, c) {
     const properties = {
-        id: { type: 'text', primary: true },
-        parent_id: { type: 'text', index: true },
+        id: { type: 'integer', primary: true, autoincrement: true },
+        parent_id: { type: 'integer', index: true },
         position: { type: 'integer' },
     };
-    for (const [key, fm] of fieldEntries(c.group.fields)) {
-        if (fm.virtual)
-            continue;
-        properties[key] = { type: mikroType(fm.column), nullable: !fm.required };
-    }
-    const name = childTableName(vault, module, c.key);
+    addFieldProps(properties, c.group.fields, (f) => !f.required);
+    const name = `${prefix}__${c.key}`;
     return new EntitySchema({ name, tableName: name, properties });
 }
-/** Усі child-схеми модуля (рекурсивно: collection усередині collection). */
-export function buildCollectionEntities(m) {
+function buildCollectionEntitiesAt(prefix, fields) {
     const out = [];
-    for (const c of collectionGroups(m.fields)) {
-        out.push(buildChildSchema(m.vault, m.module, c));
-        const nested = collectionGroups(c.group.fields);
-        for (const g of nested) {
-            out.push(buildChildSchema(m.vault, `${m.module}__${c.key}`, g));
-        }
+    for (const c of collectionGroups(fields)) {
+        out.push(buildChildSchemaAt(prefix, c));
+        out.push(...buildCollectionEntitiesAt(`${prefix}__${c.key}`, c.group.fields));
     }
     return out;
 }
-// ─── Системні схеми (плагін core) ──────────────────────────────────────────
-// Авторитетне джерело колонок: ці схеми (фізичну схему створює schema-sync.ts).
+export function buildCollectionEntities(m) {
+    return buildCollectionEntitiesAt(`${m.vault}__${m.module}`, m.fields);
+}
+export function buildExtendCollectionEntities(e) {
+    return buildCollectionEntitiesAt(`extend__${e.id}`, e.fields);
+}
 export const EventSchema = new EntitySchema({
     name: '_Event',
     tableName: '_events',
     properties: {
-        id: { type: 'text', primary: true },
+        id: { type: 'integer', primary: true, autoincrement: true },
         ts: { type: 'text' },
         actor: { type: 'text' },
         op: { type: 'text' },
         type: { type: 'text' },
-        record_id: { type: 'text' },
+        record_id: { type: 'integer', nullable: true },
         before: { type: 'text', nullable: true },
         after: { type: 'text', nullable: true },
     },
@@ -133,15 +113,70 @@ export const PluginRowSchema = new EntitySchema({
         updated_at: { type: 'text' },
     },
 });
-/** Схеми сутностей плагінів (модулі власних vault'ів + vaultModules + extends + settings). */
+export const MigrationRowSchema = new EntitySchema({
+    name: '_Migration',
+    tableName: '_migrations',
+    properties: {
+        plugin_id: { type: 'text', primary: true },
+        version: { type: 'integer', nullable: false },
+    },
+});
+export const SeedRowSchema = new EntitySchema({
+    name: '_Seed',
+    tableName: '_seeds',
+    properties: {
+        plugin_id: { type: 'text', primary: true },
+        name: { type: 'text', primary: true },
+    },
+});
+export const EmbeddingSchema = new EntitySchema({
+    name: '_Embedding',
+    tableName: '_embeddings',
+    properties: {
+        type: { type: 'text', primary: true },
+        record_id: { type: 'integer', primary: true },
+        snippet: { type: 'text' },
+        vector: { type: 'blob' },
+        model: { type: 'text' },
+        dim: { type: 'integer' },
+        updated_at: { type: 'text' },
+    },
+});
+export const PluginStateSchema = new EntitySchema({
+    name: '_PluginState',
+    tableName: '_plugin_state',
+    properties: {
+        plugin: { type: 'text', primary: true },
+        key: { type: 'text', primary: true },
+        value: { type: 'text' },
+    },
+});
 export function buildPluginEntities(plugins) {
     return plugins.flatMap((p) => [
         ...(p.vaults ?? []).flatMap((v) => v.modules.flatMap((m) => [buildEntitySchema(m), ...buildCollectionEntities(m)])),
         ...(p.vaultModules ?? []).flatMap((m) => [buildEntitySchema(m), ...buildCollectionEntities(m)]),
-        ...(p.extends_ ?? []).map(buildExtendEntitySchema),
+        ...(p.extends_ ?? []).flatMap((e) => [buildExtendEntitySchema(e), ...buildExtendCollectionEntities(e)]),
         ...(p.settings && p.settings.fields.length > 0 ? [buildSettingsEntitySchema(p.id, p.settings)] : []),
     ]);
 }
-/** Системні схеми — реєструються в initDb() ДО читання _plugins. */
-export const systemEntities = [EventSchema, PluginRowSchema];
-//# sourceMappingURL=entity-schema.js.map
+export const MsgLogSchema = new EntitySchema({
+    name: '_OrchMsgLog',
+    tableName: '_orch_msg_log',
+    properties: {
+        id: { type: 'integer', primary: true, autoincrement: true },
+        ts: { type: 'text' },
+        connector: { type: 'text' },
+        chat_id: { type: 'text' },
+        user_id: { type: 'text' },
+        role: { type: 'text' },
+        text: { type: 'text' },
+        session_id: { type: 'text', nullable: true },
+        tokens_in: { type: 'integer', nullable: true },
+        tokens_out: { type: 'integer', nullable: true },
+        ms: { type: 'integer', nullable: true },
+    },
+});
+export const systemEntities = [
+    EventSchema, PluginRowSchema, MigrationRowSchema, SeedRowSchema,
+    EmbeddingSchema, PluginStateSchema, MsgLogSchema,
+];

package/dist/extend-io.d.ts

@@ -1,8 +1,7 @@
-/** Розділити тіло запиту: базові поля + extend-дані (_extend_<id>). */
 export declare function splitBody(body: unknown): {
     base: Record<string, unknown>;
     extData: Record<string, Record<string, unknown>>;
 };
-/** Зберегти extend-дані після успішного save базового запису. */
-export declare function saveExtends(vault: string, module: string, baseId: string, extData: Record<string, Record<string, unknown>>): Promise<void>;
-//# sourceMappingURL=extend-io.d.ts.map
+export declare function deleteExtends(vault: string, module: string, id: number): Promise<void>;
+export declare function validateExtends(vault: string, module: string, extData: Record<string, Record<string, unknown>>): void;
+export declare function saveExtends(vault: string, module: string, baseId: number, extData: Record<string, Record<string, unknown>>): Promise<void>;

package/dist/extend-io.js

@@ -1,11 +1,7 @@
-/**
- * Спільна логіка вводу/виводу extend-даних для HTTP-роутів (index.ts) та
- * in-process API (local-api.ts). Уникає дублювання splitBody/saveExtends.
- */
-import { getExtendsFor } from './registry-context.js';
+import { getExtendsFor } from "./registry-context.js";
 import { buildExtendZodPartial } from '@coffer-org/sdk/extend';
-import { extendEntityName, upsertExtendRecord } from './extend-table.js';
-/** Розділити тіло запиту: базові поля + extend-дані (_extend_<id>). */
+import { upsertExtendRecord, deleteExtendRecord } from "./extend-table.js";
+import { toIssue, ValidationError } from "./mutate.js";
 export function splitBody(body) {
     const raw = (body ?? {});
     const base = {};
@@ -18,17 +14,34 @@ export function splitBody(body) {
     }
     return { base, extData };
 }
-/** Зберегти extend-дані після успішного save базового запису. */
+export async function deleteExtends(vault, module, id) {
+    for (const e of getExtendsFor(vault, module)) {
+        await deleteExtendRecord(e, id);
+    }
+}
+export function validateExtends(vault, module, extData) {
+    const issues = [];
+    for (const e of getExtendsFor(vault, module)) {
+        const data = extData[e.id];
+        if (data === undefined)
+            continue;
+        const parsed = buildExtendZodPartial(e).safeParse(data);
+        if (!parsed.success)
+            for (const i of parsed.error.issues)
+                issues.push(toIssue(i));
+    }
+    if (issues.length)
+        throw new ValidationError(issues);
+}
 export async function saveExtends(vault, module, baseId, extData) {
+    validateExtends(vault, module, extData);
     for (const e of getExtendsFor(vault, module)) {
         const data = extData[e.id];
         if (data === undefined)
             continue;
-        // Валідуємо extend-дані
         const parsed = buildExtendZodPartial(e).safeParse(data);
         if (parsed.success && Object.keys(parsed.data).length > 0) {
-            await upsertExtendRecord(extendEntityName(e), baseId, parsed.data);
+            await upsertExtendRecord(e, baseId, parsed.data);
         }
     }
 }
-//# sourceMappingURL=extend-io.js.map

package/dist/extend-table.d.ts

@@ -1,6 +1,7 @@
 import type { ExtendDef } from '@coffer-org/sdk/extend';
+type Row = Record<string, unknown>;
 export declare function extendEntityName(e: ExtendDef): string;
-export declare function getExtendRecord(name: string, baseId: string): Promise<Record<string, unknown> | undefined>;
-export declare function upsertExtendRecord(name: string, baseId: string, data: Record<string, unknown>): Promise<void>;
-export declare function deleteExtendRecord(name: string, baseId: string): Promise<void>;
-//# sourceMappingURL=extend-table.d.ts.map
+export declare function getExtendRecord(e: ExtendDef, baseId: number): Promise<Row | undefined>;
+export declare function upsertExtendRecord(e: ExtendDef, baseId: number, data: Row): Promise<void>;
+export declare function deleteExtendRecord(e: ExtendDef, baseId: number): Promise<void>;
+export {};

package/dist/extend-table.js

@@ -1,28 +1,37 @@
-/**
- * Підтримка extend-таблиць на рівні сервера.
- * Кожен ExtendDef → сутність `extend__<id>` з base_id PK.
- */
 import { serialize } from '@mikro-orm/core';
-import { getEm } from './db.js';
+import { getEm } from "./db.js";
+import { splitAt, writeAt, readAt, deleteAt } from "./collection-io.js";
 export function extendEntityName(e) {
     return `extend__${e.id}`;
 }
-// ─── CRUD ─────────────────────────────────────────────────────────────────────
-export async function getExtendRecord(name, baseId) {
+export async function getExtendRecord(e, baseId) {
     const fork = getEm().fork();
+    const name = extendEntityName(e);
     const row = await fork.findOne(name, { base_id: baseId });
     if (!row)
         return undefined;
-    return serialize(row);
+    const flat = serialize(row);
+    const collections = await readAt(fork, name, e.fields, baseId);
+    return { ...flat, ...collections };
 }
-export async function upsertExtendRecord(name, baseId, data) {
-    const fork = getEm().fork();
-    await fork.upsert(name, { base_id: baseId, ...data });
+export async function upsertExtendRecord(e, baseId, data) {
+    const name = extendEntityName(e);
+    const { base, collections } = splitAt(e.fields, data);
+    await getEm()
+        .fork()
+        .transactional(async (tx) => {
+        await tx.upsert(name, { base_id: baseId, ...base });
+        await writeAt(tx, name, e.fields, baseId, collections);
+    });
 }
-export async function deleteExtendRecord(name, baseId) {
-    const fork = getEm().fork();
-    const ref = fork.getReference(name, baseId);
-    fork.remove(ref);
-    await fork.flush();
+export async function deleteExtendRecord(e, baseId) {
+    const name = extendEntityName(e);
+    await getEm()
+        .fork()
+        .transactional(async (tx) => {
+        await deleteAt(tx, name, e.fields, baseId);
+        const ref = tx.getReference(name, baseId);
+        tx.remove(ref);
+        await tx.flush();
+    });
 }
-//# sourceMappingURL=extend-table.js.map

package/dist/fs-list.d.ts

@@ -0,0 +1,11 @@
+export interface FsEntry {
+    name: string;
+    isDir: boolean;
+}
+export declare function resolveWithinHome(input: string, home: string): {
+    abs: string;
+} | {
+    error: string;
+};
+export declare function filterSort(entries: FsEntry[], exts?: string[]): FsEntry[];
+export declare function listDir(absDir: string): Promise<FsEntry[]>;

package/dist/fs-list.js

@@ -0,0 +1,18 @@
+import { join, resolve, sep } from 'node:path';
+import { readdir } from 'node:fs/promises';
+export function resolveWithinHome(input, home) {
+    const expanded = !input || input === '~' ? home : input.startsWith('~/') ? join(home, input.slice(2)) : input;
+    const abs = resolve(expanded);
+    if (abs !== home && !abs.startsWith(home + sep))
+        return { error: 'outside_home' };
+    return { abs };
+}
+export function filterSort(entries, exts) {
+    const ex = exts?.map((e) => e.toLowerCase().replace(/^\./, '')).filter(Boolean);
+    const out = entries.filter((e) => e.isDir || !ex || ex.length === 0 || ex.includes((e.name.split('.').pop() ?? '').toLowerCase()));
+    return out.sort((a, b) => (a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1));
+}
+export async function listDir(absDir) {
+    const ents = await readdir(absDir, { withFileTypes: true });
+    return ents.map((d) => ({ name: d.name, isDir: d.isDirectory() }));
+}

package/dist/index.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=index.d.ts.map