odant-work 1.0.12 → 1.0.14

package/sources/data/time.js

@@ -0,0 +1,67 @@
+/**
+ * Время в учётном ядре. Моменты хранятся в миллисекундах; день — местный
+ * (сервер стоит в контуре организации), а не UTC: «сегодня» бухгалтера
+ * начинается в 00:00 по его часам.
+ */
+import { DataError } from './errors.js';
+
+const DAY_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+/** Начало местного дня 'YYYY-MM-DD' в мс. */
+export function dayStart(day) {
+    const m = DAY_RE.exec(String(day));
+    if (!m)
+        throw new DataError(`дата «${day}»: ожидается ГГГГ-ММ-ДД`);
+    const t = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3])).getTime();
+    if (localDay(t) !== day)
+        throw new DataError(`дата «${day}» не существует`);
+    return t;
+}
+
+/** Местный день момента: 'YYYY-MM-DD'. */
+export function localDay(ms) {
+    const d = new Date(ms);
+    const p = n => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
+/**
+ * Момент из значения: число (мс), Date, 'YYYY-MM-DD' (начало местного дня), строка ISO.
+ * @returns {number}
+ */
+export function parseTime(v, what = 'время') {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return Math.trunc(v);
+    if (v instanceof Date && Number.isFinite(v.getTime()))
+        return v.getTime();
+    const s = String(v ?? '').trim();
+    if (DAY_RE.test(s))
+        return dayStart(s);
+    if (/^\d+$/.test(s))
+        return Number(s);
+    const t = Date.parse(s);
+    if (!s || !Number.isFinite(t))
+        throw new DataError(`${what}: «${s}» — не дата`);
+    return t;
+}
+
+/**
+ * Полуинтервал [from, to) в мс из границ периода. Граница-день 'YYYY-MM-DD' в `to`
+ * включает весь день. Пустая граница — без ограничения.
+ */
+export function periodRange(from, to) {
+    const a = from === undefined || from === null || from === '' ? -Infinity : parseTime(from, 'начало периода');
+    let b = Infinity;
+    if (!(to === undefined || to === null || to === '')) {
+        b = parseTime(to, 'конец периода');
+        if (DAY_RE.test(String(to).trim()))
+            b = nextDay(b);
+    }
+    return [a, b];
+}
+
+/** Начало следующего местного дня (корректно при переходе на летнее время). */
+export function nextDay(ms) {
+    const d = new Date(ms);
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1).getTime();
+}

package/sources/data/workspace.js

@@ -0,0 +1,152 @@
+/**
+ * Рабочее пространство пользователя: подразделения и места, где он работает, и меню каждого места.
+ *
+ * Меню места — ссылки места на классы (справочники, операции, счета), то есть ровно то, что места
+ * дают в правах: свои ссылки места — со своим `access`, ссылки вложенных мест — на чтение,
+ * общие ссылки подразделения — всем. BOSS видит места подразделения на чтение, ADMIN — со своими
+ * правами. Реальные права проверяет сервер при каждом вызове; здесь только описание для интерфейса.
+ *
+ * Чистая часть (`buildWorkspace`) не знает про сервер: подразделения приходят готовыми
+ * (класс, роли пользователя, `#security`), поэтому проверяется без дерева файлов.
+ */
+import { getClass, children } from './classes.js';
+import { FAMILY } from './schema.js';
+import { normalizeSecurity, walkPlaces, trailKey, memberTrailKeys } from '../server/access/workplaces.js';
+
+const RANK = { read: 1, write: 2 };
+const SCOPE_RANK = { null: 0, own: 1, place: 2, unit: 3, all: 4 };
+const LIMIT_CLASSES = 5000;
+
+/** Права на ссылку: у BOSS и вышестоящего места — только чтение. */
+const readOnly = links => links.map(l => ({ ...l, access: 'read' }));
+
+/** Слияние ссылок по id: выше доступ, при равном — шире видимость. */
+function mergeLinks(...lists) {
+    const out = new Map();
+    for (const l of lists.flat()) {
+        const cur = out.get(l.id);
+        const better = !cur
+            || (RANK[l.access] ?? 0) > (RANK[cur.access] ?? 0)
+            || ((RANK[l.access] ?? 0) === (RANK[cur.access] ?? 0) && (SCOPE_RANK[l.scope ?? null] ?? 0) > (SCOPE_RANK[cur.scope ?? null] ?? 0));
+        if (better)
+            out.set(l.id, { id: l.id, access: l.access, scope: l.scope ?? null });
+    }
+    return [...out.values()];
+}
+
+const ownLinks = node => node.LINKS.map(l => ({ id: l.id, access: l.access, scope: l.scope ?? null }));
+
+/**
+ * Подразделения и места пользователя с меню.
+ * @param {object} db БД данных (кэш классов)
+ * @param {object} input
+ * @param {Array<{ cid, path, label, type, parent, own, roles: string[], admin: boolean, security: object }>} input.units
+ *   подразделения корня и всех вложенных: класс, роли пользователя в нём, секция `#security`
+ * @param {string|null} input.uid пользователь
+ * @returns {{ uid, units: Array, contexts: Array, classes: object }}
+ *   units — плоский список от корня (`parent` — cid вложенного в состав), у видимого: `rights`
+ *   (`admin`|`boss`|`member`), `links` — меню подразделения без места (общие ссылки и места
+ *   на чтение для BOSS/ADMIN), `places` — места (`key`, `parent`, `view`: `mine`|`below`|`boss`|`admin`, `links`);
+ *   contexts — где пользователь работает; classes — путь класса → описание с `children` (пути)
+ */
+export function buildWorkspace(db, { units, uid = null }) {
+    const byCid = new Map(units.map(u => [u.cid, u]));
+    const rel = u => (u.admin ? 'admin' : u.roles.includes('BOSS') ? 'boss' : u.roles.length ? 'member' : null);
+    const visible = new Set(units.filter(u => rel(u)).map(u => u.cid));
+    const shown = new Set(visible);
+    for (const cid of visible)
+        for (let p = byCid.get(cid)?.parent; p && byCid.has(p) && !shown.has(p); p = byCid.get(p).parent)
+            shown.add(p);
+
+    const wanted = new Set();
+    const out = [];
+    const contexts = [];
+
+    for (const u of units) {
+        if (!shown.has(u.cid))
+            continue;
+        const entry = {
+            cid: u.cid,
+            path: u.path,
+            label: u.label,
+            icon: u.own?.icon ?? '',
+            parent: byCid.has(u.parent) && shown.has(u.parent) ? u.parent : null,
+            rights: rel(u),
+            places: [],
+            links: [],
+        };
+        out.push(entry);
+        if (!entry.rights)
+            continue;
+
+        const { common, places } = normalizeSecurity(u.security);
+        const nodes = walkPlaces(places).map(({ node, trail }) => ({
+            key: trailKey(trail), parent: trail.length > 1 ? trailKey(trail.slice(0, -1)) : null, node,
+        }));
+        const mine = new Set(memberTrailKeys(u.security, uid));
+        const underMine = key => [...mine].some(m => key === m || key.startsWith(m + '/'));
+        const commonLinks = common.map(l => ({ id: l.id, access: l.access, scope: l.scope ?? null }));
+        const placeMenu = (n, view) => {
+            const nested = nodes.filter(x => x.key.startsWith(n.key + '/')).flatMap(x => ownLinks(x.node));
+            const own = ownLinks(n.node);
+            return mergeLinks(commonLinks, view === 'mine' || view === 'admin' ? own : readOnly(own), readOnly(nested));
+        };
+
+        for (const n of nodes) {
+            const view = entry.rights === 'admin' ? 'admin'
+                : mine.has(n.key) ? 'mine'
+                    : underMine(n.key) ? 'below'
+                        : entry.rights === 'boss' ? 'boss' : null;
+            if (!view)
+                continue;
+            entry.places.push({
+                key: n.key, parent: n.parent, label: n.node.label, icon: n.node.icon, view, mine: mine.has(n.key),
+                links: placeMenu(n, view),
+            });
+        }
+
+        const wide = entry.rights === 'admin' || entry.rights === 'boss';
+        const all = nodes.flatMap(n => ownLinks(n.node));
+        entry.links = mergeLinks(commonLinks, entry.rights === 'admin' ? all : wide ? readOnly(all) : []);
+
+        for (const p of entry.places)
+            if (p.mine)
+                contexts.push({ unit: u.cid, place: p.key, kind: 'place', label: `${u.label} / ${p.label}` });
+        if (wide || !entry.places.some(p => p.mine))
+            contexts.push({ unit: u.cid, place: null, kind: 'unit', label: u.label });
+
+        for (const l of [...entry.links, ...entry.places.flatMap(p => p.links)])
+            wanted.add(l.id);
+    }
+
+    return { uid, units: out, contexts, classes: describeClasses(db, wanted) };
+}
+
+/** Класс для меню: название, значок, тип, семейство и вложенные классы (пути). */
+function describe(c, kids) {
+    return {
+        cid: c.cid, path: c.path, label: c.label, icon: c.own?.icon ?? '', type: c.type,
+        family: FAMILY[c.type] ?? 'other', leaf: kids.length === 0, children: kids.map(k => k.path),
+    };
+}
+
+/** Описание классов-ссылок и всего их поддерева (меню разворачивает ветки без новых запросов). */
+function describeClasses(db, paths) {
+    const out = {};
+    const stack = [...paths];
+    let count = 0;
+    while (stack.length && count < LIMIT_CLASSES) {
+        const path = stack.pop();
+        if (out[path])
+            continue;
+        const c = getClass(db, path);
+        if (!c)
+            continue;
+        const kids = children(db, c.cid);
+        out[c.path] = describe(c, kids);
+        count++;
+        for (const k of kids)
+            stack.push(k.path);
+    }
+    return out;
+}

package/sources/host/auto-updater.js

@@ -192,17 +192,38 @@ export function scanTrackedFiles(rootDir = '.') {
 }
 
 /**
- * Прочитать текущую версию из package.json.
+ * Прочитать текущую версию из package.json (или #system/package-manifest.json, если в корне лежит package.json хост-проекта).
  */
 export function readLocalPackageVersion(rootDir = '.') {
+    const absRoot = path.resolve(rootDir);
+    try {
+        const pkgPath = path.join(absRoot, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.version)
+                return String(pkg.version);
+        }
+    }
+    catch { /* ignore */ }
     try {
-        const pkgPath = path.join(path.resolve(rootDir), 'package.json');
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        return String(pkg.version || '1.0.0');
+        const manifestPath = path.join(absRoot, MANIFEST_REL_PATH);
+        if (fs.existsSync(manifestPath)) {
+            const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            if (raw?.version)
+                return String(raw.version);
+        }
     }
-    catch {
-        return '1.0.0';
+    catch { /* ignore */ }
+    try {
+        const nmPkgPath = path.join(absRoot, 'node_modules', PACKAGE_NAME, 'package.json');
+        if (fs.existsSync(nmPkgPath)) {
+            const nmPkg = JSON.parse(fs.readFileSync(nmPkgPath, 'utf8'));
+            if (nmPkg?.version)
+                return String(nmPkg.version);
+        }
     }
+    catch { /* ignore */ }
+    return '1.0.0';
 }
 
 /**
@@ -428,14 +449,24 @@ export function applyUpdateFromDirectory({
     const upstreamBackupRoot = path.join(absRoot, '#system', 'updates', `upstream-${targetVersion}`);
 
     // Проверим, изменились ли dependencies в package.json
+    let oldPkg = null;
+    let newPkg = null;
     try {
-        const oldPkg = JSON.parse(fs.readFileSync(path.join(absRoot, 'package.json'), 'utf8'));
-        const newPkg = JSON.parse(fs.readFileSync(path.join(absSource, 'package.json'), 'utf8'));
-        if (JSON.stringify(oldPkg.dependencies || {}) !== JSON.stringify(newPkg.dependencies || {})) {
+        if (fs.existsSync(path.join(absRoot, 'package.json')))
+            oldPkg = JSON.parse(fs.readFileSync(path.join(absRoot, 'package.json'), 'utf8'));
+        if (fs.existsSync(path.join(absSource, 'package.json')))
+            newPkg = JSON.parse(fs.readFileSync(path.join(absSource, 'package.json'), 'utf8'));
+        if (oldPkg && newPkg && JSON.stringify(oldPkg.dependencies || {}) !== JSON.stringify(newPkg.dependencies || {})) {
             report.dependenciesChanged = true;
         }
     }
     catch { /* ignore */ }
+    const isHostWrapperPkg = Boolean(
+        oldPkg && (
+            (oldPkg.name && oldPkg.name !== PACKAGE_NAME)
+            || (!oldPkg.name && oldPkg.dependencies?.[PACKAGE_NAME])
+        )
+    );
 
     const walkSource = (currSourceDir) => {
         for (const entry of fs.readdirSync(currSourceDir)) {
@@ -453,7 +484,18 @@ export function applyUpdateFromDirectory({
                 continue;
 
             const dstFile = path.join(absRoot, rel);
-            const newBuf = fs.readFileSync(srcFile);
+            let newBuf = fs.readFileSync(srcFile);
+            if (rel === 'package.json' && isHostWrapperPkg && newPkg) {
+                const mergedPkg = {
+                    ...newPkg,
+                    name: oldPkg.name || 'odant-work-workspace',
+                    dependencies: {
+                        ...(newPkg.dependencies || {}),
+                        ...(oldPkg.dependencies?.[PACKAGE_NAME] ? { [PACKAGE_NAME]: `^${targetVersion}` } : {}),
+                    },
+                };
+                newBuf = Buffer.from(JSON.stringify(mergedPkg, null, 2) + '\n', 'utf8');
+            }
             const newHash = sha256Buffer(newBuf);
 
             // 1. Защищённые пользовательские данные никогда не перезаписываются, если уже существуют
@@ -496,7 +538,10 @@ export function applyUpdateFromDirectory({
             const isModifiedByUser = !baselineHash || (diskHash !== baselineHash);
 
             if (isModifiedByUser) {
-                // Пользователь менял этот класс/файл — НЕ затираем его работу!
+                // Пользователь менял этот класс/файл — НЕ затираем его работу и сохраняем прежний baselineHash,
+                // чтобы и при последующих обновлениях этот файл оставался защищённым!
+                if (baselineHash)
+                    newManifestFiles[rel] = baselineHash;
                 report.preservedUserModified.push(rel);
                 if (diskHash !== newHash) {
                     const upstreamCopy = path.join(upstreamBackupRoot, rel);
@@ -617,6 +662,7 @@ let updateTimer = null;
 export function startAutoUpdateDaemon({
     rootDir = '.',
     intervalMs,
+    runOnStart = true,
     fetchImpl = globalThis.fetch,
 } = {}) {
     ensurePackageManifest(rootDir);
@@ -625,8 +671,7 @@ export function startAutoUpdateDaemon({
         clearInterval(updateTimer);
         updateTimer = null;
     }
-    const period = Number(intervalMs || (state.checkIntervalHours || 6) * 3600_000 || DEFAULT_CHECK_INTERVAL_MS);
-    updateTimer = setInterval(async () => {
+    const runCheck = async () => {
         try {
             const cur = loadAutoUpdateState(rootDir);
             if (!cur.enabled) return;
@@ -635,7 +680,13 @@ export function startAutoUpdateDaemon({
         catch (err) {
             console.warn('[auto-updater]', err?.message || err);
         }
-    }, period);
+    };
+    if (runOnStart) {
+        const bootTimer = setTimeout(runCheck, 5_000);
+        bootTimer.unref?.();
+    }
+    const period = Number(intervalMs || (state.checkIntervalHours || 6) * 3600_000 || DEFAULT_CHECK_INTERVAL_MS);
+    updateTimer = setInterval(runCheck, period);
     updateTimer.unref?.();
     return updateTimer;
 }