@alizadefaig/pos-server 1.2.25 → 1.2.27

package/app/sync/push.js

@@ -0,0 +1,324 @@
+const {randomUUID} = require('node:crypto');
+const {SyncStore} = require('./store');
+const {limits, timeouts} = require('./config');
+const {BOOLEAN_COLUMNS} = require('../core/support/db');
+
+/**
+ * Push: офлайн-правки кассы → облако.
+ *
+ * Отправляется не журнал операций, а агрегат чека целиком (чек + все позиции, модификаторы,
+ * платежи, события) — облако сливает его по своим правилам (sync.pushOrders) и отвечает по
+ * каждому чеку: applied / skipped / conflict / error. Пометку sync_dirty снимаем только с той версией,
+ * которую отправляли: правка, сделанная кассой во время запроса, поднимет версию, и чек
+ * уйдёт следующим push.
+ */
+
+// Колонки, которые локально лежат JSON-строкой, а облаку нужны объектом (cast array в Laravel).
+const JSON_COLUMNS = {
+    orders: ['data', 'customers', 'extras'],
+    order_events: ['data'],
+    products: ['name', 'full_name', 'data'],
+};
+
+const decodeJson = (value) => {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmed);
+    } catch (e) {
+        return value;
+    }
+};
+
+/** Локальная строка → строка для облака: флаги true/false, JSON — объектом. */
+const toCloudRow = (table, row) => {
+    const result = {...row};
+    for (const column of Object.keys(result)) {
+        if (BOOLEAN_COLUMNS.has(column) && result[column] !== null && result[column] !== undefined) {
+            result[column] = Boolean(Number(result[column]));
+        }
+    }
+    for (const column of JSON_COLUMNS[table] || []) {
+        if (column in result) {
+            result[column] = decodeJson(result[column]);
+        }
+    }
+    return result;
+};
+
+const toCloudRows = (table, rows) => rows.map((row) => toCloudRow(table, row));
+
+/** Агрегат чека для отправки. null — чека локально нет (пометку можно просто снять). */
+const readOrderAggregate = (store, id) => {
+    const order = store.get('SELECT * FROM orders WHERE id = ?', [id]);
+    if (!order) {
+        return null;
+    }
+    const products = store.all('SELECT * FROM order_products WHERE order_id = ? ORDER BY created_at', [id]);
+    const productIds = products.map((row) => row.id);
+    const owners = SyncStore.inList('order_product_id', productIds);
+    const modifiers = productIds.length
+        ? store.all(`SELECT * FROM order_product_modifier_sets WHERE ${owners.sql}`, owners.params)
+        : [];
+    const payments = store.all('SELECT * FROM order_payments WHERE order_id = ?', [id]);
+    const events = store.all('SELECT * FROM order_events WHERE order_id = ? ORDER BY created_at', [id]);
+
+    // Тикеты кухни едут вместе с чеком, включая погашенные (deleted_at): облако держит ту же
+    // историю отправок, иначе номер следующего тикета разошёлся бы с кассой.
+    const tickets = store.all('SELECT * FROM kds_tickets WHERE order_id = ? ORDER BY number, created_at', [id]);
+    const ticketOwners = SyncStore.inList('kds_ticket_id', tickets.map((row) => row.id));
+    const ticketItems = tickets.length
+        ? store.all(`SELECT * FROM kds_ticket_items WHERE ${ticketOwners.sql} ORDER BY created_at`, ticketOwners.params)
+        : [];
+
+    // Товары-экстры, созданные кассой офлайн: облаку они нужны раньше позиций, которые на них
+    // ссылаются. synced_at IS NULL — облако их ещё не подтверждало снапшотом.
+    const catalogIds = [...new Set(products.map((row) => row.product_id).filter(Boolean))];
+    const catalog = SyncStore.inList('id', catalogIds);
+    const extraProducts = catalogIds.length
+        ? store.all(`SELECT * FROM products WHERE synced_at IS NULL AND ${catalog.sql}`, catalog.params)
+        : [];
+
+    return {
+        order: toCloudRow('orders', order),
+        products: toCloudRows('order_products', products),
+        modifier_sets: toCloudRows('order_product_modifier_sets', modifiers),
+        payments: toCloudRows('order_payments', payments),
+        events: toCloudRows('order_events', events),
+        extra_products: toCloudRows('products', extraProducts),
+        kds_tickets: toCloudRows('kds_tickets', tickets),
+        kds_ticket_items: toCloudRows('kds_ticket_items', ticketItems),
+    };
+};
+
+/**
+ * Принтер, настроенный на кассе без облака (printers.update / delete / syncAddress в ядре),
+ * вместе со всеми его цехами: связь без своего id облако заменяет целиком. Удалённый принтер
+ * (deleted_at) тоже едет — облако должно его удалить. null — принтера локально нет.
+ */
+const readPrinterAggregate = (store, id) => {
+    const printer = store.get('SELECT * FROM printers WHERE id = ?', [id]);
+    if (!printer) {
+        return null;
+    }
+    const workshops = store.all('SELECT * FROM printer_workshop WHERE printer_id = ?', [id]);
+    // synced_at — локальная метка снапшота, облаку она ни к чему.
+    const local = ({synced_at, ...row}) => row;
+    return {
+        printer: toCloudRow('printers', local(printer)),
+        workshops: toCloudRows('printer_workshop', workshops.map(local)),
+    };
+};
+
+/**
+ * Пометки с заведением, которому принадлежит запись. Запись другого заведения облако примет
+ * только с его токеном (иначе ответит foreign_company), поэтому push и счётчик очереди берут
+ * лишь заведение сессии, а чужие записи ждут повторного входа в своё заведение.
+ * Запись без заведения, или которой локально уже нет, считается своей: первую облако отвергнет,
+ * и она станет «отравленной» (видна в /local/status), вторую push снимет как отсутствующую.
+ */
+const DIRTY_FROM = `sync_dirty d
+    LEFT JOIN orders o ON d.entity = 'order' AND o.id = d.id
+    LEFT JOIN shifts s ON d.entity = 'shift' AND s.id = d.id
+    LEFT JOIN printers p ON d.entity = 'printer' AND p.id = d.id`;
+const OWNER = 'COALESCE(o.company_id, s.company_id, p.company_id)';
+
+/** companyId пуст (сессии нет) — без фильтра, как раньше. */
+const ownScope = (companyId) => (companyId
+    ? {sql: `WHERE (${OWNER} IS NULL OR ${OWNER} = ?)`, params: [String(companyId)]}
+    : {sql: '', params: []});
+
+/**
+ * Пачка на отправку — читается синхронно, в одном блоке: всё, что уходит в облако, уже
+ * закоммичено локально и согласовано между собой.
+ *
+ * @param {Set<string>} excluded  ключи 'entity:id' отравленных записей (см. index.js)
+ * @param {string|null} companyId заведение сессии: только его записи уходят с её токеном
+ */
+const readBatch = (store, {batchSize, excluded = new Set(), companyId = null}) => {
+    const scope = ownScope(companyId);
+    // Смены — первыми: закрытый офлайн чек ссылается на смену, открытую тоже офлайн.
+    // Принтеры — до чеков: печать чеков в облаке сразу пойдёт на исправленный адрес.
+    const dirty = store.all(
+        `SELECT d.entity, d.id, d.version FROM ${DIRTY_FROM}
+         ${scope.sql}
+         ORDER BY CASE d.entity WHEN 'shift' THEN 0 WHEN 'printer' THEN 1 ELSE 2 END, d.dirty_at, d.id
+         LIMIT ?`,
+        [...scope.params, batchSize + excluded.size]
+    ).filter((row) => !excluded.has(`${row.entity}:${row.id}`)).slice(0, batchSize);
+
+    const orders = [];
+    const shifts = [];
+    const printers = [];
+    const versions = new Map();
+    const missing = [];
+
+    for (const row of dirty) {
+        const key = `${row.entity}:${row.id}`;
+        if (row.entity === 'shift') {
+            const shift = store.get('SELECT * FROM shifts WHERE id = ?', [row.id]);
+            if (!shift) {
+                missing.push(row);
+                continue;
+            }
+            shifts.push(toCloudRow('shifts', shift));
+        } else if (row.entity === 'order') {
+            const aggregate = readOrderAggregate(store, row.id);
+            if (!aggregate) {
+                missing.push(row);
+                continue;
+            }
+            orders.push(aggregate);
+        } else if (row.entity === 'printer') {
+            const aggregate = readPrinterAggregate(store, row.id);
+            if (!aggregate) {
+                missing.push(row);
+                continue;
+            }
+            printers.push(aggregate);
+        } else {
+            missing.push(row);
+            continue;
+        }
+        versions.set(key, row.version);
+    }
+
+    return {orders, shifts, printers, versions, missing};
+};
+
+const clearMark = (store, entity, id, version) => store.run(
+    'DELETE FROM sync_dirty WHERE entity = ? AND id = ? AND version = ?',
+    [entity, id, version]
+);
+
+/**
+ * Ответ облака, после которого пометку можно снять. conflict — облако победило (закрыт или
+ * удалён там), свою версию подтянет pull по ids. Любой skipped (invalid, foreign_company) и
+ * error оставляют пометку и копят попытки — после лимита запись попадает в «отравленные» и видна
+ * в /local/status, а не пропадает молча. foreign_company раньше пометку снимал, и запись другого
+ * заведения, ушедшая с чужим токеном, больше не отправлялась, а через keepClosedDays удалялась.
+ */
+const isDone = (result) => result.status === 'applied' || result.status === 'conflict';
+
+/**
+ * Одна пачка push. Возвращает {sent, conflicts, failed, results, authoritative}.
+ *
+ * @param {{store, cloud, excluded: Set<string>, onFailure: Function, batchSize?: number, epoch?: number,
+ *   companyId?: string}} options
+ *   companyId — заведение сессии, см. readBatch.
+ *   onFailure(key, version, reason) — облако ответило, но запись не приняло (для учёта «отравленных»).
+ *   epoch — мастер-касса (модель M) выгружает авторитетно: облако принимает её версию чека как
+ *   истину. Облако само решает, так ли это, и подтверждает флагом authoritative в ответе.
+ */
+const pushBatch = async ({store, cloud, excluded = new Set(), onFailure = () => {}, batchSize = null, epoch = null,
+    companyId = null}) => {
+    const size = batchSize || limits().pushBatch;
+    const batch = await store.block((s) => {
+        const read = readBatch(s, {batchSize: size, excluded, companyId});
+        // Пометки на то, чего локально уже нет, снимаем сразу — отправлять нечего.
+        for (const row of read.missing) {
+            clearMark(s, row.entity, row.id, row.version);
+        }
+        return read;
+    });
+
+    if (!batch.orders.length && !batch.shifts.length && !batch.printers.length) {
+        return {sent: 0, conflicts: [], failed: [], results: [], authoritative: null};
+    }
+
+    const body = {orders: batch.orders, shifts: batch.shifts};
+    // Ключ только когда есть что слать: облако без приёма принтеров пакет без них примет как раньше.
+    if (batch.printers.length) {
+        body.printers = batch.printers;
+    }
+    if (epoch !== null && epoch !== undefined) {
+        body.epoch = epoch;
+    }
+
+    let response;
+    try {
+        response = await cloud.call(
+            'sync.pushOrders',
+            body,
+            {timeout: timeouts().push, idempotencyKey: randomUUID()}
+        ) || {};
+    } catch (e) {
+        if (e.name === 'CloudRequestError') {
+            // Облако отвергло пачку целиком (валидация) — каждая запись получает попытку,
+            // а index.js переходит на пачки по одной, чтобы найти виновную.
+            for (const [key, version] of batch.versions) {
+                onFailure(key, version, e.message);
+            }
+        }
+        throw e;
+    }
+
+    const conflicts = [];
+    const failed = [];
+    const answered = new Set();
+    const results = [
+        ...(response.results || []).map((result) => ({...result, entity: 'order'})),
+        ...(response.shifts || []).map((result) => ({...result, entity: 'shift'})),
+        ...(response.printers || []).map((result) => ({...result, entity: 'printer'})),
+    ];
+
+    await store.block((s) => {
+        for (const result of results) {
+            const key = `${result.entity}:${result.id}`;
+            if (!batch.versions.has(key)) {
+                continue;
+            }
+            answered.add(key);
+            if (isDone(result)) {
+                clearMark(s, result.entity, result.id, batch.versions.get(key));
+                if (result.status === 'conflict' && result.entity === 'order') {
+                    conflicts.push({id: result.id, reason: result.reason || null});
+                }
+            } else {
+                failed.push({key, reason: [result.status, result.reason, result.message].filter(Boolean).join(': ') || 'error'});
+            }
+        }
+    });
+
+    for (const [key, version] of batch.versions) {
+        if (!answered.has(key)) {
+            failed.push({key, reason: 'no result'});
+        }
+        const failure = failed.find((item) => item.key === key);
+        if (failure) {
+            onFailure(key, version, failure.reason);
+        }
+    }
+
+    return {sent: batch.versions.size, conflicts, failed, results, authoritative: Boolean(response.authoritative)};
+};
+
+/** Сколько записей заведения сессии ждут отправки (без отравленных). */
+const pendingCount = (store, excluded = new Set(), companyId = null) => {
+    const scope = ownScope(companyId);
+    if (!excluded.size) {
+        return Number(store.get(`SELECT COUNT(*) AS count FROM ${DIRTY_FROM} ${scope.sql}`, scope.params).count) || 0;
+    }
+    const rows = store.all(`SELECT d.entity, d.id FROM ${DIRTY_FROM} ${scope.sql}`, scope.params);
+    return rows.filter((row) => !excluded.has(`${row.entity}:${row.id}`)).length;
+};
+
+/** Недосланное других заведений: [{company_id, count}]. Уйдёт при входе в своё заведение. */
+const foreignPending = (store, companyId) => {
+    if (!companyId) {
+        return [];
+    }
+    return store.all(
+        `SELECT ${OWNER} AS company_id, COUNT(*) AS count FROM ${DIRTY_FROM}
+         WHERE ${OWNER} IS NOT NULL AND ${OWNER} <> ?
+         GROUP BY ${OWNER} ORDER BY ${OWNER}`,
+        [String(companyId)]
+    ).map((row) => ({company_id: row.company_id, count: Number(row.count) || 0}));
+};
+
+module.exports = {pushBatch, pendingCount, foreignPending, readBatch, readOrderAggregate, readPrinterAggregate, toCloudRow};

package/app/sync/reconcile.js

@@ -0,0 +1,161 @@
+const config = require('./config');
+
+/**
+ * Сверка касса ↔ облако (OFFLINE-FIRST-PLAN §12.8, P2).
+ *
+ * push и pull двигают чеки по пометкам sync_dirty и курсору. Если пометка потерялась (крах
+ * посреди блока, ручная правка файла БД, ошибка в правилах слияния), расхождение живёт молча:
+ * ни одна из сторон о нём не знает. Сверка ловит такие случаи по закрытым чекам — именно из
+ * них складывается выручка.
+ *
+ * Раз в OFFLINE_RECONCILE_MS касса шлёт облаку сводку {count, total} закрытых неудалённых
+ * чеков компании за окно [now − windowHours − settle, now − settle]. Совпало — всё. Нет —
+ * облако отдаёт свой список за то же окно, и касса сравнивает построчно.
+ *
+ * Лечение — теми же путями, что и обычный синк, своих записей в облако сверка не делает:
+ *   чек жив у кассы, в облаке его нет          → пометить грязным, уедет обычным push;
+ *   касса — мастер заведения (истина у неё)     → любой расходящийся чек, который есть локально, — push;
+ *   иначе (истина в облаке)                     → pull по ids.
+ *
+ * Сверка запускается только при пустой очереди push: иначе расхождение — это просто
+ * ещё не досланные правки.
+ */
+
+const SQL_TIME = (ms) => new Date(ms).toISOString().slice(0, 19).replace('T', ' ');
+
+const cents = (value) => Math.round((Number(value) || 0) * 100);
+
+const MARK_DIRTY_SQL = `INSERT INTO sync_dirty (entity, id, version, dirty_at) VALUES ('order', ?, 1, datetime('now'))
+    ON CONFLICT (entity, id) DO UPDATE SET version = version + 1, dirty_at = excluded.dirty_at`;
+
+const window = (now = Date.now()) => {
+    const {windowHours, settle} = config.reconcile();
+    const to = now - settle;
+    return {from: SQL_TIME(to - windowHours * 3600 * 1000), to: SQL_TIME(to)};
+};
+
+/** Закрытые чеки компании за окно — и удалённые тоже: «удалён здесь, жив там» тоже расхождение. */
+const localRows = (store, companyId, {from, to}) => store.all(
+    `SELECT id, closed_at, total, deleted_at FROM orders
+     WHERE company_id = ? AND closed_at IS NOT NULL AND closed_at >= ? AND closed_at <= ?`,
+    [companyId, from, to]
+);
+
+const summarize = (rows) => {
+    let count = 0;
+    let total = 0;
+    for (const row of rows) {
+        if (!row.deleted_at) {
+            count += 1;
+            total += cents(row.total);
+        }
+    }
+    return {count, total: total / 100};
+};
+
+/** Построчное сравнение: списки id по видам расхождения. */
+const compare = (local, cloud) => {
+    const localById = new Map(local.map((row) => [String(row.id), row]));
+    const cloudById = new Map(cloud.map((row) => [String(row.id), row]));
+    const diff = {missing_in_cloud: [], missing_locally: [], total_mismatch: [], deleted_mismatch: []};
+
+    for (const [id, row] of localById) {
+        const alive = !row.deleted_at;
+        const remote = cloudById.get(id);
+        if (!remote) {
+            if (alive) {
+                diff.missing_in_cloud.push(id);
+            }
+            continue;
+        }
+        if (alive !== !remote.deleted) {
+            diff.deleted_mismatch.push(id);
+        } else if (alive && cents(row.total) !== cents(remote.total)) {
+            diff.total_mismatch.push(id);
+        }
+    }
+    for (const [id, remote] of cloudById) {
+        if (!remote.deleted && !localById.has(id)) {
+            diff.missing_locally.push(id);
+        }
+    }
+    return diff;
+};
+
+const diffSize = (diff) => (diff
+    ? diff.missing_in_cloud.length + diff.missing_locally.length + diff.total_mismatch.length + diff.deleted_mismatch.length
+    : 0);
+
+/** Что делать с расхождениями: {push: ids, pull: ids}. skip — ключи отравленных записей. */
+const plan = (store, diff, {authoritative = false, skip = new Set(), limit = Infinity} = {}) => {
+    const push = [];
+    const pull = [];
+    const add = (list, id) => {
+        if (push.length + pull.length < limit && !list.includes(id)) {
+            list.push(id);
+        }
+    };
+    const existsLocally = (id) => Boolean(store.get('SELECT 1 AS found FROM orders WHERE id = ?', [id]));
+
+    for (const id of diff.missing_in_cloud) {
+        // Отравленную запись облако и так отвергает — новая версия лишь сбросила бы счётчик попыток.
+        if (!skip.has(`order:${id}`)) {
+            add(push, id);
+        }
+    }
+    for (const id of [...diff.total_mismatch, ...diff.deleted_mismatch, ...diff.missing_locally]) {
+        if (authoritative && existsLocally(id)) {
+            if (!skip.has(`order:${id}`)) {
+                add(push, id);
+            }
+        } else {
+            add(pull, id);
+        }
+    }
+    return {push, pull};
+};
+
+/** Пометить чеки грязными — вне sync_suppress, как если бы их поправила сама касса. */
+const markDirty = (store, ids) => {
+    for (const id of ids) {
+        store.run(MARK_DIRTY_SQL, [id]);
+    }
+    return ids.length;
+};
+
+/**
+ * Одна сверка. Возвращает {ok, window, local, cloud, diff, truncated, push, pull}; ids для
+ * pull вызывающий ставит в свою очередь, пометки для push уже записаны.
+ */
+const run = async ({store, cloud, companyId, authoritative = false, skip = new Set(), now = Date.now()}) => {
+    const range = window(now);
+    const rows = localRows(store, companyId, range);
+    const local = summarize(rows);
+
+    const response = await cloud.call('sync.reconcile', {...range, summary: local});
+    const remote = response && response.cloud ? {
+        count: Number(response.cloud.count) || 0,
+        total: Number(response.cloud.total) || 0,
+    } : null;
+    const result = {ok: Boolean(response && response.ok), window: range, local, cloud: remote,
+        diff: null, truncated: false, push: [], pull: []};
+    if (result.ok) {
+        return result;
+    }
+    if (!Array.isArray(response && response.orders) || response.has_more) {
+        // Список облака неполный — построчно не сравнить, чтобы не «лечить» то, чего не видно.
+        result.truncated = true;
+        return result;
+    }
+
+    result.diff = compare(rows, response.orders);
+    const {push, pull} = plan(store, result.diff, {authoritative, skip, limit: config.reconcile().maxHeal});
+    if (push.length) {
+        await store.block((s) => markDirty(s, push));
+    }
+    result.push = push;
+    result.pull = pull;
+    return result;
+};
+
+module.exports = {run, window, localRows, summarize, compare, plan, markDirty, diffSize};