odant-work 1.0.12 → 1.0.13

package/sources/data/choices.js

@@ -0,0 +1,125 @@
+/**
+ * Выбор значения ссылки (форма, ИИ): кандидаты для поля-ссылки на дату операции.
+ *
+ * Ссылка на виртуальный справочник («Клиенты», «Работающие сотрудники»):
+ *   - без поиска — только состав на дату: коротко и без шума, ведомость зарплаты
+ *     заполняется всеми работающими одним запросом;
+ *   - с поиском — сначала подходящие участники, затем подходящие объекты
+ *     реестра-источника (`member: false`): новый покупатель находится, хотя ещё не клиент;
+ *   - `all` — расширить выбор всем реестром и без поиска;
+ *   - ничего не нашлось — `create`: классы, где создать объект и сразу сослаться на него.
+ * Проведение состав не проверяет: участником объект делает сама операция
+ * (первая продажа делает покупателя клиентом).
+ *
+ * Ссылка на обычный справочник — его объекты (с потомками), с поиском.
+ */
+import { getClass, descendants, isLeaf } from './classes.js';
+import { classSchema } from './schema.js';
+import { queryObjects } from './objects.js';
+import { virtualMembers } from './reports.js';
+import { entryGrants, withoutBranches } from './scope.js';
+import { DataError } from './errors.js';
+
+const POOL = 500;
+const byTitle = (a, b) => a.title.localeCompare(b.title, 'ru');
+
+/** Целевой класс: `target` или поле класса `cid` (`field`, для табличной части — 'таблица.поле'). */
+function resolveTarget(db, q) {
+    if (q.target)
+        return String(q.target);
+    const schema = classSchema(db, q.cid);
+    if (!schema)
+        throw new DataError(`класс ${q.cid ?? ''} не найден`);
+    const parts = String(q.field ?? '').split('.').filter(Boolean);
+    let f = null, list = schema.fields;
+    for (const part of parts) {
+        f = list?.find(x => x.id === part);
+        list = (f?.type === 'table' || f?.type === 'struct') ? f.fields : null;
+    }
+    if (!f || f.type !== 'link')
+        throw new DataError(`${schema.label}: поле «${q.field ?? ''}» — не ссылка`);
+    return f.target;
+}
+
+/** Классы-листы справочника, где можно создать объект. */
+function creatable(db, cid) {
+    return descendants(db, cid)
+        .filter(c => isLeaf(db, c))
+        .map(c => getClass(db, c))
+        .filter(c => c.type === '$catalog' || c.type === '$registry')
+        .map(c => ({ cid: c.cid, path: c.path, label: c.label }));
+}
+
+const plain = o => ({ id: o.id, cid: o.cid, title: o.title });
+
+/**
+ * Кандидаты для поля-ссылки.
+ * @param {object} q
+ * @param {string} [q.target] Класс ссылки (или `cid` + `field`)
+ * @param {string} [q.cid] Класс объекта, где поле
+ * @param {string} [q.field] Поле ('client', 'staff.employee')
+ * @param {*} [q.at] Дата операции: состав виртуального справочника на неё
+ * @param {string} [q.search] Поиск по началам слов
+ * @param {boolean} [q.all] Показать и объекты реестра вне состава (без поиска)
+ * @param {number} [q.limit=200]
+ * @param {Array<object>|null} [q.visible] Права видимости справочника (scope.js); у виртуального — проводок состава
+ * @param {Array<object>|null} [q.registryVisible] Права на объекты реестра виртуального (по умолчанию — `visible` без веток)
+ * @returns {{ target, virtual: boolean, items: Array<{ id, cid, title, member, balance?, ext? }>,
+ *             total: number, others: number, create: Array<{ cid, label }> }}
+ *   total — всего подходящих; others — объектов реестра вне показанного состава (кнопка «показать все»)
+ */
+export function linkChoices(db, q = {}) {
+    const target = resolveTarget(db, q);
+    const schema = classSchema(db, target);
+    if (!schema || schema.family !== 'catalog')
+        throw new DataError(`справочник ${target} не найден`);
+    const limit = Math.max(1, Math.min(1000, Number(q.limit) || 200));
+    const search = String(q.search ?? '').trim() || undefined;
+
+    if (schema.type !== '$virtual') {
+        const r = queryObjects(db, { cid: schema.cid, search, limit: POOL, visible: q.visible });
+        return {
+            target: schema.cid,
+            virtual: false,
+            items: r.items.map(o => ({ ...plain(o), member: true })).sort(byTitle).slice(0, limit),
+            total: r.total,
+            others: 0,
+            create: creatable(db, schema.cid),
+        };
+    }
+
+    const registry = getClass(db, schema.source?.registry);
+    const members = virtualMembers(db, {
+        cid: schema.cid, at: q.at, units: q.units, unit: q.unit, visible: entryGrants(q.visible, 'catalog'),
+    }).items;
+    const member = m => ({ id: m.id, cid: m.cid, title: m.title, member: true, balance: m.balance, ext: m.ext });
+    const create = creatable(db, registry.cid);
+    const regVisible = q.registryVisible !== undefined ? q.registryVisible : withoutBranches(q.visible);
+    const regTotal = queryObjects(db, { cid: registry.cid, limit: 1, visible: regVisible }).total;
+
+    if (!search && !q.all)
+        return {
+            target: schema.cid,
+            virtual: true,
+            items: members.slice(0, limit).map(member),
+            total: members.length,
+            others: Math.max(0, regTotal - members.length),
+            create,
+        };
+
+    const pool = queryObjects(db, { cid: registry.cid, search, limit: POOL, visible: regVisible });
+    const found = new Set(pool.items.map(o => o.id));
+    const ids = new Set(members.map(m => m.id));
+    const items = [
+        ...members.filter(m => !search || found.has(m.id)).map(member),
+        ...pool.items.filter(o => !ids.has(o.id)).map(o => ({ ...plain(o), member: false })).sort(byTitle),
+    ];
+    return {
+        target: schema.cid,
+        virtual: true,
+        items: items.slice(0, limit),
+        total: pool.total,
+        others: 0,
+        create,
+    };
+}

package/sources/data/classes.js

@@ -0,0 +1,412 @@
+/**
+ * Кэш дерева классов в БД данных: таблицы `classes` и `class_tree`.
+ *
+ * Источник истины — файлы дерева: класс = папка с метапапкой `$тип`, собственный
+ * слой — `<класс>/$тип/class.js`. Здесь дерево сканируется и складывается в БД,
+ * чтобы иерархию (итоги по счёту со всеми субсчетами, объекты промежуточного
+ * класса операций, подразделение со всеми вложенными) отвечал один SQL-запрос
+ * по замыканию `class_tree`.
+ *
+ * Идентификатор класса `cid` всегда равен его пути в дереве WORK (`path`).
+ */
+import crypto from 'node:crypto';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { tx } from './db.js';
+
+/** Типы прикладных классов данных. */
+export const DATA_TYPES = Object.freeze(['$catalog', '$virtual', '$struct', '$operation', '$account', '$register']);
+
+/** Типы классов орг-структуры (подразделения), доменов и модулей. */
+export const STRUCTURE_TYPES = Object.freeze(['$structure', '$base']);
+export const MODULE_TYPES = Object.freeze(['$module']);
+export const DOMAIN_TYPES = Object.freeze(['$domain']);
+
+/** Корни дерева, которые сканируются по умолчанию. */
+export const DEFAULT_ROOTS = Object.freeze(['MODULES', 'ORGANIZATIONS', 'DATA', 'BASE']);
+
+/** Папки, которые не бывают классами. */
+const SKIP = new Set(['node_modules', 'history', 'logs']);
+
+/** Приоритет при нескольких метапапках в одной папке: известные типы раньше прочих. */
+const KNOWN = [...DATA_TYPES, '$registry', ...STRUCTURE_TYPES, ...MODULE_TYPES, ...DOMAIN_TYPES];
+
+/**
+ * Копия значения без функций, геттеров и символов (только данные class.js).
+ * Геттеры не вызываются: в class.js они могут обращаться к ядру.
+ */
+export function plainData(value, depth = 0) {
+    if (depth > 32 || typeof value === 'function' || typeof value === 'symbol')
+        return undefined;
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(v => plainData(v, depth + 1) ?? null);
+    const out = {};
+    for (const [key, d] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        if (!('value' in d))
+            continue;
+        const v = plainData(d.value, depth + 1);
+        if (v !== undefined)
+            out[key] = v;
+    }
+    return out;
+}
+
+const ownFileCache = new Map();
+const rootScanCache = new Map();
+
+export function clearScanCache() {
+    rootScanCache.clear();
+}
+
+/** Собственный слой class.js как данные (быстрый разбор литерала с фолбэком на ESM-импорт). */
+async function readOwn(file) {
+    let stat;
+    try {
+        stat = await fsp.stat(file);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return {};
+        throw e;
+    }
+    const mtime = Math.trunc(stat.mtimeMs);
+    const cached = ownFileCache.get(file);
+    if (cached && cached.mtime === mtime)
+        return cached.data;
+    let rawMod;
+    try {
+        const src = await fsp.readFile(file, 'utf-8');
+        const trimmed = src.replace(/^\uFEFF/, '').trim();
+        if (trimmed.startsWith('export default') && !/\bimport\b/.test(trimmed)) {
+            const expr = trimmed.replace(/^export\s+default\s+/, '').replace(/;\s*$/, '');
+            rawMod = new Function(`"use strict"; return (${expr});`)();
+        }
+    }
+    catch {
+        rawMod = undefined;
+    }
+    if (rawMod === undefined) {
+        const mod = await import(pathToFileURL(file).href + '?mtime=' + mtime);
+        rawMod = mod.default ?? {};
+    }
+    const data = plainData(rawMod ?? {}) || {};
+    ownFileCache.set(file, { mtime, data });
+    return data;
+}
+
+/**
+ * Найти классы в дереве.
+ * Идентификатор класса `cid` равен его пути `path`.
+ * @param {string} rootDir Корень WORK на диске
+ * @param {readonly string[]} [roots] Корневые папки сканирования (отсутствующие пропускаются)
+ * @returns {Promise<{ classes: Array<{cid, path, type, label, own}>, problems: string[] }>}
+ */
+export async function scanClasses(rootDir, roots = DEFAULT_ROOTS) {
+    const classes = [];
+    const problems = [];
+
+    async function visit(rel, probList = problems) {
+        let entries;
+        try {
+            entries = await fsp.readdir(path.join(rootDir, rel), { withFileTypes: true });
+        }
+        catch (e) {
+            if (e.code === 'ENOENT' || e.code === 'ENOTDIR')
+                return;
+            throw e;
+        }
+        const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).sort();
+        const metas = dirs.filter(n => n.startsWith('$'));
+        let selfItem = null;
+        if (metas.length) {
+            const ranked = [...metas].sort((a, b) => rank(a) - rank(b) || a.localeCompare(b));
+            const type = ranked[0];
+            const clsPath = '/' + rel.split(path.sep).join('/');
+            if (metas.length > 1)
+                probList.push(`${clsPath}: несколько метапапок (${metas.join(', ')}), выбран ${type}`);
+            let own = {};
+            try {
+                own = await readOwn(path.join(rootDir, rel, type, 'class.js'));
+            }
+            catch (e) {
+                probList.push(`${clsPath}: class.js не загружен — ${e.message}`);
+            }
+            const label = typeof own.label === 'string' && own.label ? own.label : path.basename(rel);
+            selfItem = { cid: clsPath, path: clsPath, type, label, own };
+        }
+        const childDirs = dirs.filter(name => !name.startsWith('$') && !name.startsWith('.') && !name.startsWith('#') && !SKIP.has(name));
+        const subLists = await Promise.all(childDirs.map(name => visit(path.join(rel, name), probList)));
+        const out = selfItem ? [selfItem] : [];
+        for (const sub of subLists) {
+            if (sub?.length)
+                out.push(...sub);
+        }
+        return out;
+    }
+
+    const now = Date.now();
+    const absRoot = path.resolve(rootDir);
+    const isMainRepo = absRoot === path.resolve(process.cwd());
+    const rootLists = await Promise.all(roots.map(async root => {
+        const cacheKey = `${absRoot}::${root}`;
+        if (isMainRepo && root === 'MODULES') {
+            const hit = rootScanCache.get(cacheKey);
+            if (hit && now - hit.ts < 5000) {
+                const res = await hit.promise;
+                if (res.problems.length)
+                    problems.push(...res.problems);
+                return res.items;
+            }
+            const promise = (async () => {
+                const localProblems = [];
+                const items = await visit(root, localProblems);
+                return { items: items || [], problems: localProblems };
+            })();
+            rootScanCache.set(cacheKey, { ts: now, promise });
+            const res = await promise;
+            if (res.problems.length)
+                problems.push(...res.problems);
+            return res.items;
+        }
+        return visit(root, problems);
+    }));
+    for (const list of rootLists) {
+        if (list?.length)
+            classes.push(...list);
+    }
+
+    return { classes, problems };
+}
+
+function rank(meta) {
+    const i = KNOWN.indexOf(meta);
+    return i < 0 ? KNOWN.length : i;
+}
+
+const generations = new WeakMap();
+
+/** Поколение кэша классов БД: растёт при каждом изменении (сброс производных кэшей — схем). */
+export function classesGeneration(db) {
+    return generations.get(db) || 0;
+}
+
+function hashOf(own) {
+    return crypto.createHash('sha1').update(JSON.stringify(own)).digest('hex');
+}
+
+/**
+ * Записать найденные классы в БД: upsert, удаление исчезнувших, пересборка замыкания.
+ * Родитель класса — ближайший найденный класс-предок по пути.
+ * @returns {{ total: number, changed: number, removed: number }}
+ */
+export function syncClasses(db, classes) {
+    const byPath = new Map(classes.map(c => [c.path, c]));
+    const parentOf = c => {
+        for (let p = path.posix.dirname(c.path); p !== '/' && p !== '.'; p = path.posix.dirname(p)) {
+            const hit = byPath.get(p);
+            if (hit)
+                return hit.cid;
+        }
+        return null;
+    };
+    return tx(db, () => {
+        const old = new Map(db.prepare('SELECT cid, path, parent, type, label, hash FROM classes').all().map(r => [r.cid, r]));
+        const upsert = db.prepare(`
+            INSERT INTO classes (cid, path, parent, type, label, own, hash) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(cid) DO UPDATE SET path = excluded.path, parent = excluded.parent, type = excluded.type,
+                label = excluded.label, own = excluded.own, hash = excluded.hash`);
+        let changed = 0;
+        const del = db.prepare('DELETE FROM classes WHERE cid = ?');
+        const keep = new Set(classes.map(c => c.cid));
+        let removed = 0;
+        for (const cid of old.keys()) {
+            if (!keep.has(cid)) {
+                del.run(cid);
+                removed++;
+            }
+        }
+        for (const c of classes) {
+            const parent = parentOf(c);
+            const hash = hashOf(c.own);
+            const prev = old.get(c.cid);
+            if (prev && prev.path === c.path && prev.parent === parent && prev.type === c.type && prev.label === c.label && prev.hash === hash)
+                continue;
+            if (prev?.path !== c.path)
+                db.prepare('DELETE FROM classes WHERE path = ? AND cid <> ?').run(c.path, c.cid);
+            upsert.run(c.cid, c.path, parent, c.type, c.label, JSON.stringify(c.own), hash);
+            changed++;
+        }
+        if (changed || removed) {
+            rebuildTree(db);
+            generations.set(db, classesGeneration(db) + 1);
+        }
+        return { total: classes.length, changed, removed };
+    });
+}
+
+/** Пересобрать замыкание иерархии из `classes.parent`. */
+export function rebuildTree(db) {
+    tx(db, () => {
+        db.exec('DELETE FROM class_tree');
+        const parent = new Map(db.prepare('SELECT cid, parent FROM classes').all().map(r => [r.cid, r.parent]));
+        const ins = db.prepare('INSERT INTO class_tree (ancestor, descendant, depth) VALUES (?, ?, ?)');
+        for (const cid of parent.keys()) {
+            const seen = new Set();
+            for (let a = cid, d = 0; a && parent.has(a) && !seen.has(a); a = parent.get(a), d++) {
+                seen.add(a);
+                ins.run(a, cid, d);
+            }
+        }
+        generations.set(db, classesGeneration(db) + 1);
+    });
+}
+
+/**
+ * Просканировать дерево и обновить кэш классов.
+ * @returns {Promise<{ total: number, changed: number, removed: number, problems: string[] }>}
+ */
+export async function refreshClasses(db, rootDir, roots = DEFAULT_ROOTS) {
+    const { classes, problems } = await scanClasses(rootDir, roots);
+    return { ...syncClasses(db, classes), problems };
+}
+
+const classIndexCache = new WeakMap();
+
+/**
+ * Построить или вернуть из памяти индекс всех классов и замыкания иерархии БД.
+ * Сбрасывается автоматически при изменении `classesGeneration(db)`.
+ */
+function getClassIndex(db) {
+    const gen = classesGeneration(db);
+    let idx = classIndexCache.get(db);
+    if (idx && idx.gen === gen)
+        return idx;
+
+    const byCid = new Map();
+    const byPath = new Map();
+    const childrenByParent = new Map();
+    const nonVirtualChildParents = new Set();
+    const allSortedByPath = [];
+
+    const rows = db.prepare('SELECT cid, path, parent, type, label, own FROM classes ORDER BY path').all();
+    for (const r of rows) {
+        const item = {
+            cid: r.cid,
+            path: r.path,
+            parent: r.parent,
+            type: r.type,
+            label: r.label,
+            own: r.own ? JSON.parse(r.own) : {},
+        };
+        byCid.set(item.cid, item);
+        byPath.set(item.path, item);
+        allSortedByPath.push(item);
+        if (item.parent) {
+            let list = childrenByParent.get(item.parent);
+            if (!list)
+                childrenByParent.set(item.parent, list = []);
+            list.push(item);
+            if (item.type !== '$virtual')
+                nonVirtualChildParents.add(item.parent);
+        }
+    }
+    for (const list of childrenByParent.values())
+        list.sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0));
+
+    const descByAncestor = new Map();
+    const treeRows = db.prepare('SELECT ancestor, descendant, depth FROM class_tree ORDER BY ancestor, depth, descendant').all();
+    for (const tr of treeRows) {
+        let dList = descByAncestor.get(tr.ancestor);
+        if (!dList)
+            descByAncestor.set(tr.ancestor, dList = []);
+        dList.push(tr.descendant);
+    }
+
+    const ancByDescendant = new Map();
+    for (const item of allSortedByPath) {
+        const chain = [];
+        const seen = new Set();
+        for (let cur = item; cur && !seen.has(cur.cid); cur = cur.parent ? byCid.get(cur.parent) : null) {
+            seen.add(cur.cid);
+            chain.unshift(cur);
+        }
+        ancByDescendant.set(item.cid, chain);
+    }
+
+    idx = {
+        gen,
+        byCid,
+        byPath,
+        childrenByParent,
+        nonVirtualChildParents,
+        descByAncestor,
+        ancByDescendant,
+        allSortedByPath,
+    };
+    classIndexCache.set(db, idx);
+    return idx;
+}
+
+function cloneClassRow(r) {
+    return r ? { ...r } : null;
+}
+
+/** Класс по пути (null — нет). */
+export function getClass(db, ref) {
+    const key = String(ref ?? '');
+    if (!key)
+        return null;
+    const idx = getClassIndex(db);
+    return cloneClassRow(idx.byCid.get(key) || idx.byPath.get(key));
+}
+
+/**
+ * Пути потомков класса.
+ * @param {object} [opts] { self = true — включая сам класс }
+ * @returns {string[]}
+ */
+export function descendants(db, cid, { self = true } = {}) {
+    const list = getClassIndex(db).descByAncestor.get(String(cid ?? ''));
+    if (!list?.length)
+        return [];
+    return self ? list.slice() : list.slice(1);
+}
+
+/**
+ * Цепочка предков от корня к классу.
+ * @param {object} [opts] { self = true — включая сам класс }
+ * @returns {Array<{cid, path, parent, type, label, own}>}
+ */
+export function ancestors(db, cid, { self = true } = {}) {
+    const chain = getClassIndex(db).ancByDescendant.get(String(cid ?? ''));
+    if (!chain?.length)
+        return [];
+    const slice = self ? chain : chain.slice(0, -1);
+    return slice.map(cloneClassRow);
+}
+
+/** Прямые дочерние классы. */
+export function children(db, cid) {
+    const list = getClassIndex(db).childrenByParent.get(String(cid ?? ''));
+    return list ? list.map(cloneClassRow) : [];
+}
+
+/** Лист — класс без дочерних классов своего реального типа (виртуальные справочники $virtual всегда листья для своих расширений и не превращают родительский $catalog в не-лист). */
+export function isLeaf(db, cid) {
+    const key = String(cid ?? '');
+    const idx = getClassIndex(db);
+    const cls = idx.byCid.get(key) || idx.byPath.get(key);
+    if (cls?.type === '$virtual')
+        return true;
+    const targetCid = cls?.cid || key;
+    return !idx.nonVirtualChildParents.has(targetCid);
+}
+
+/** Все классы типа (или типов). */
+export function classesOfType(db, types) {
+    const set = new Set([].concat(types).map(String));
+    return getClassIndex(db).allSortedByPath.filter(c => set.has(c.type)).map(cloneClassRow);
+}