@alizadefaig/pos-server 1.2.26 → 1.2.28

package/app/sync/lanFront.js

@@ -0,0 +1,431 @@
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const {createHash} = require('node:crypto');
+const axios = require('axios');
+const config = require('./config');
+const discovery = require('./discovery');
+
+/**
+ * Копия фронта на мастере для LAN-перехода (config.isLanFrontEnabled). Официант работает на
+ * platform.cafepos.az; пропал интернет — страница уходит на http://<IP мастера>:3005, и мастер
+ * отдаёт ей тот же фронт, скачанный заранее.
+ *
+ * Сборка фронта с VITE_LAN_HANDOFF кладёт рядом с index.html lan-manifest.json:
+ * {version, files: [{path, size, sha256}]}. Мастер раз в LAN_FRONT_SYNC_MS сверяет версию и,
+ * если она новая, скачивает файлы во временный каталог, проверяет размер и sha256 каждого и
+ * только потом переименовывает каталог в <data>/front/<version>. Раздаётся всегда целая
+ * версия: полускачанная никогда не становится текущей. Хранятся текущая и предыдущая.
+ *
+ * Файлы, которые не изменились (хешированные ассеты Vite), берутся из текущей версии без
+ * повторной загрузки.
+ */
+const MANIFEST = 'lan-manifest.json';
+const CURRENT = 'current.json';
+const LOCAL_MANIFEST = '.manifest.json';
+const SAFE_VERSION = /^[A-Za-z0-9._-]{1,64}$/;
+const SAFE_PATH = /^[A-Za-z0-9._\-/@~+]+$/;
+const SHA256 = /^[a-f0-9]{64}$/;
+const PARALLEL = 4;
+const KEEP_VERSIONS = 2;
+
+// Пути, которые Node обслуживает сам: фронт их не перекрывает никогда.
+const RESERVED = /^\/(api|local|socket|socket\.io|master|printers|tax|health|init|up)(\/|$)/i;
+
+const state = {
+    version: null,
+    dir: null,
+    files: null,
+    at: null,
+    error: null,
+    checkedAt: null,
+    lastTry: 0,
+    running: null,
+    indexHtml: null,
+};
+
+const log = (...args) => console.log('[lan-front]', ...args);
+
+const dataDir = () => process.env.CAFEPOS_DATA_DIR || path.join(os.homedir(), '.cafepos');
+const root = () => path.join(dataDir(), 'front');
+
+const nowIso = () => new Date().toISOString();
+
+/** Путь файла из манифеста: только относительный, без `..`, `.` и пустых сегментов. */
+const safePath = (value) => {
+    if (typeof value !== 'string' || !value || value.length > 256 || !SAFE_PATH.test(value)) {
+        return false;
+    }
+    return value.split('/').every((part) => part !== '' && part !== '.' && part !== '..');
+};
+
+const validateManifest = (manifest) => {
+    const limits = config.lanFront();
+    if (!manifest || typeof manifest !== 'object' || !SAFE_VERSION.test(String(manifest.version || ''))) {
+        throw new Error('manifest: bad version');
+    }
+    if (!Array.isArray(manifest.files) || !manifest.files.length) {
+        throw new Error('manifest: no files');
+    }
+    if (manifest.files.length > limits.maxFiles) {
+        throw new Error(`manifest: more than ${limits.maxFiles} files`);
+    }
+    const seen = new Set();
+    let total = 0;
+    for (const file of manifest.files) {
+        if (!file || !safePath(file.path) || seen.has(file.path)) {
+            throw new Error(`manifest: bad path ${file && file.path}`);
+        }
+        if (!Number.isInteger(file.size) || file.size < 0 || !SHA256.test(String(file.sha256 || ''))) {
+            throw new Error(`manifest: bad entry ${file.path}`);
+        }
+        seen.add(file.path);
+        total += file.size;
+    }
+    if (!seen.has('index.html')) {
+        throw new Error('manifest: no index.html');
+    }
+    if (total > limits.maxBytes) {
+        throw new Error(`manifest: ${total} bytes is over the limit`);
+    }
+    return {version: String(manifest.version), files: manifest.files};
+};
+
+const readJson = (file) => {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch (e) {
+        return null;
+    }
+};
+
+const writeJsonAtomic = async (file, value) => {
+    const tmp = `${file}.${process.pid}.tmp`;
+    await fsp.writeFile(tmp, JSON.stringify(value), {mode: 0o600});
+    await fsp.rename(tmp, file);
+};
+
+const activate = (version, dir, files, at) => {
+    state.version = version;
+    state.dir = dir;
+    state.files = new Set(files.map((file) => file.path));
+    state.at = at;
+    state.indexHtml = null;
+};
+
+/** Текущая версия с диска после перезапуска кассы. */
+const load = () => {
+    if (state.version) {
+        return;
+    }
+    const current = readJson(path.join(root(), CURRENT));
+    if (!current || !SAFE_VERSION.test(String(current.version || ''))) {
+        return;
+    }
+    const dir = path.join(root(), current.version);
+    const manifest = readJson(path.join(dir, LOCAL_MANIFEST));
+    if (!manifest || manifest.version !== current.version || !Array.isArray(manifest.files)) {
+        return;
+    }
+    activate(current.version, dir, manifest.files, current.at || null);
+};
+
+const sha256 = (buffer) => createHash('sha256').update(buffer).digest('hex');
+
+const fetchManifest = async () => {
+    const response = await axios.get(`${config.lanFrontUrl()}/${MANIFEST}`, {
+        params: {t: Date.now()},
+        headers: {'Cache-Control': 'no-cache'},
+        timeout: config.lanFront().timeout,
+        maxContentLength: 5 * 1024 * 1024,
+        responseType: 'json',
+        validateStatus: () => true,
+    });
+    if (response.status !== 200) {
+        throw new Error(`manifest: HTTP ${response.status}`);
+    }
+    return validateManifest(response.data);
+};
+
+const fetchFile = async (file) => {
+    const response = await axios.get(`${config.lanFrontUrl()}/${file.path}`, {
+        params: {v: file.sha256.slice(0, 12)},
+        timeout: config.lanFront().timeout,
+        responseType: 'arraybuffer',
+        maxContentLength: Math.max(1, file.size),
+        validateStatus: () => true,
+    });
+    if (response.status !== 200) {
+        throw new Error(`${file.path}: HTTP ${response.status}`);
+    }
+    return Buffer.from(response.data);
+};
+
+/** Файлы текущей версии по sha256 — их не качаем заново. */
+const reusable = () => {
+    const result = new Map();
+    if (!state.dir) {
+        return result;
+    }
+    const manifest = readJson(path.join(state.dir, LOCAL_MANIFEST));
+    for (const file of (manifest && manifest.files) || []) {
+        result.set(`${file.sha256}:${file.size}`, path.join(state.dir, file.path));
+    }
+    return result;
+};
+
+const placeFile = async (tmpDir, file, reuse) => {
+    const target = path.join(tmpDir, file.path);
+    await fsp.mkdir(path.dirname(target), {recursive: true});
+    const existing = reuse.get(`${file.sha256}:${file.size}`);
+    if (existing) {
+        try {
+            const buffer = await fsp.readFile(existing);
+            if (buffer.length === file.size && sha256(buffer) === file.sha256) {
+                await fsp.writeFile(target, buffer);
+                return false;
+            }
+        } catch (e) {
+            // файла прошлой версии нет или он битый — качаем заново
+        }
+    }
+    const buffer = await fetchFile(file);
+    if (buffer.length !== file.size || sha256(buffer) !== file.sha256) {
+        throw new Error(`${file.path}: checksum mismatch`);
+    }
+    await fsp.writeFile(target, buffer);
+    return true;
+};
+
+const cleanup = async () => {
+    let entries;
+    try {
+        entries = await fsp.readdir(root(), {withFileTypes: true});
+    } catch (e) {
+        return;
+    }
+    const versions = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const dir = path.join(root(), entry.name);
+        if (entry.name.startsWith('.tmp-')) {
+            if (!state.running || !dir.endsWith(state.tmpName || '\0')) {
+                await fsp.rm(dir, {recursive: true, force: true});
+            }
+            continue;
+        }
+        if (entry.name === state.version) {
+            continue;
+        }
+        const stat = await fsp.stat(dir).catch(() => null);
+        versions.push({dir, mtime: stat ? stat.mtimeMs : 0});
+    }
+    versions.sort((a, b) => b.mtime - a.mtime);
+    for (const old of versions.slice(KEEP_VERSIONS - 1)) {
+        await fsp.rm(old.dir, {recursive: true, force: true});
+    }
+};
+
+const download = async (manifest) => {
+    await fsp.mkdir(root(), {recursive: true, mode: 0o700});
+    const tmpName = `.tmp-${manifest.version}-${process.pid}-${Date.now()}`;
+    const tmpDir = path.join(root(), tmpName);
+    state.tmpName = tmpName;
+    const reuse = reusable();
+    let fetched = 0;
+    try {
+        await fsp.mkdir(tmpDir, {recursive: true});
+        const queue = [...manifest.files];
+        const worker = async () => {
+            while (queue.length) {
+                if (await placeFile(tmpDir, queue.shift(), reuse)) {
+                    fetched += 1;
+                }
+            }
+        };
+        await Promise.all(Array.from({length: PARALLEL}, worker));
+        await writeJsonAtomic(path.join(tmpDir, LOCAL_MANIFEST), manifest);
+
+        const target = path.join(root(), manifest.version);
+        await fsp.rm(target, {recursive: true, force: true});
+        await fsp.rename(tmpDir, target);
+        const at = nowIso();
+        await writeJsonAtomic(path.join(root(), CURRENT), {version: manifest.version, at});
+        activate(manifest.version, target, manifest.files, at);
+        log(`version ${manifest.version}: ${manifest.files.length} files, ${fetched} downloaded`);
+    } finally {
+        state.tmpName = null;
+        await fsp.rm(tmpDir, {recursive: true, force: true}).catch(() => {});
+    }
+};
+
+const run = async () => {
+    state.lastTry = Date.now();
+    try {
+        const manifest = await fetchManifest();
+        state.checkedAt = nowIso();
+        if (manifest.version !== state.version) {
+            await download(manifest);
+        }
+        state.error = null;
+        await cleanup();
+    } catch (e) {
+        state.error = e.message;
+        console.warn('[lan-front] sync failed:', e.message);
+    }
+};
+
+const due = () => {
+    if (state.running) {
+        return false;
+    }
+    const limits = config.lanFront();
+    const interval = state.version && !state.error ? limits.sync : limits.retry;
+    return Date.now() - state.lastTry >= interval;
+};
+
+/**
+ * Сверить версию с облаком в фоне. Загрузка фронта может длиться минуты — цикл синка её
+ * не ждёт. Повторный вызов во время загрузки возвращает ту же загрузку.
+ */
+const kick = () => {
+    if (!state.running) {
+        state.running = run().finally(() => {
+            state.running = null;
+        });
+    }
+    return state.running;
+};
+
+const status = () => ({
+    version: state.version,
+    at: state.at,
+    checked_at: state.checkedAt,
+    error: state.error,
+    downloading: Boolean(state.running),
+});
+
+// ---------------------------------------------------------------- адреса мастера
+
+const privateRank = (ip) => {
+    const [a, b] = ip.split('.').map(Number);
+    if (a === 192 && b === 168) {
+        return 0;
+    }
+    if (a === 10) {
+        return 1;
+    }
+    if (a === 172 && b >= 16 && b <= 31) {
+        return 2;
+    }
+    return -1;
+};
+
+/**
+ * Куда телефону уходить по LAN: http://<IPv4>:<порт> каждого приватного интерфейса кассы.
+ * Облако пропускает в браузер только такие адреса (LanHandoffService::isPrivateUrl) и не
+ * больше четырёх; 192.168 первым — это почти всегда Wi-Fi зала, а 10/172 — VPN или Docker.
+ */
+const urls = (port) => discovery.interfaces()
+    .map((item) => item.address)
+    .filter((ip) => privateRank(ip) >= 0)
+    .sort((a, b) => privateRank(a) - privateRank(b))
+    .slice(0, 4)
+    .map((ip) => `http://${ip}:${port}`);
+
+/** Блок lan для heartbeat: облако отдаст его телефонам в app.init как lan_master. */
+const heartbeat = (port) => ({
+    urls: state.version ? urls(port) : [],
+    port,
+    front: {version: state.version, at: state.at, error: state.error},
+});
+
+/** Адрес этой кассы (для same-origin страницы, открытой по LAN-адресу). */
+const isOwnAddress = (host) => Boolean(host) && discovery.interfaces().some((item) => item.address === host);
+
+// ---------------------------------------------------------------- раздача
+
+const injected = () => JSON.stringify({v: 1, version: state.version, cloud: config.lanFrontUrl()})
+    .replace(/</g, '\\u003c');
+
+/**
+ * index.html с меткой LAN-страницы: по window.__CAFEPOS_LAN__ фронт понимает, что работает
+ * с мастера (API — на этот же адрес, возврат в облако — на cloud).
+ */
+const indexHtml = () => {
+    if (state.indexHtml && state.indexHtml.version === state.version) {
+        return state.indexHtml.body;
+    }
+    const raw = fs.readFileSync(path.join(state.dir, 'index.html'), 'utf8');
+    const tag = `<script>window.__CAFEPOS_LAN__=${injected()};</script>`;
+    const at = raw.search(/<script\b/i);
+    const body = at >= 0
+        ? `${raw.slice(0, at)}${tag}${raw.slice(at)}`
+        : raw.replace(/<\/head>/i, `${tag}</head>`);
+    state.indexHtml = {version: state.version, body};
+    return body;
+};
+
+const sendIndex = (req, res) => {
+    res.set('Cache-Control', 'no-cache');
+    res.type('html');
+    if (req.method === 'HEAD') {
+        res.end();
+        return;
+    }
+    res.send(indexHtml());
+};
+
+const decode = (value) => {
+    try {
+        return decodeURIComponent(value);
+    } catch (e) {
+        return null;
+    }
+};
+
+/**
+ * Express-middleware раздачи. Стоит до httpGuard: страницу получает любой телефон зала —
+ * фронт и так публичен на platform.cafepos.az, а API за ним пускает только по токену.
+ */
+const middleware = () => (req, res, next) => {
+    if ((req.method !== 'GET' && req.method !== 'HEAD') || !config.isLanFrontEnabled()) {
+        next();
+        return;
+    }
+    load();
+    const requestPath = decode(req.path);
+    if (!state.version || !requestPath || RESERVED.test(requestPath)) {
+        next();
+        return;
+    }
+    const rel = requestPath.replace(/^\/+/, '');
+    if (rel === '' || rel === 'index.html') {
+        sendIndex(req, res);
+        return;
+    }
+    if (state.files.has(rel) && safePath(rel)) {
+        const immutable = rel.startsWith('assets/');
+        res.sendFile(path.join(state.dir, rel), {
+            dotfiles: 'deny',
+            headers: {'Cache-Control': immutable ? 'public, max-age=31536000, immutable' : 'no-cache'},
+        }, (error) => {
+            if (error && !res.headersSent) {
+                next();
+            }
+        });
+        return;
+    }
+    // Маршрут SPA (/order/…): без расширения и из адресной строки — отдаём index.html.
+    const last = rel.split('/').pop();
+    if (!last.includes('.') && req.accepts('html')) {
+        sendIndex(req, res);
+        return;
+    }
+    next();
+};
+
+module.exports = {load, due, kick, status, heartbeat, urls, isOwnAddress, middleware, validateManifest, _state: state, _run: run};

package/app/sync/mirror.js

@@ -0,0 +1,236 @@
+const kv = require('./kv');
+const {SyncStore} = require('./store');
+const {limits, timeouts} = require('./config');
+
+/**
+ * Зеркало чеков: облако → локальная БД.
+ *
+ * Приходит агрегат целиком (чек + позиции + модификаторы + платежи + тикеты кухни), локально
+ * он заменяет свою копию полностью: чего нет в агрегате — удаляется. Чек, который касса правила сама и
+ * ещё не отправила (есть в sync_dirty), не трогаем — иначе облачный снимок затёр бы
+ * офлайн-правки. Такой чек облако получит через push и вернёт следующим pull.
+ */
+const isDirty = (store, id) => Boolean(store.get(
+    "SELECT 1 AS dirty FROM sync_dirty WHERE entity = 'order' AND id = ?",
+    [id]
+));
+
+const idsOf = (rows) => (rows || []).map((row) => row && row.id).filter(Boolean);
+
+/** Удаляет строки таблицы по условию владельца, кроме перечисленных id. */
+const deleteMissing = (store, table, ownerSql, ownerParams, keepIds) => {
+    const keep = SyncStore.inList('id', keepIds);
+    const notKept = keepIds.length ? ` AND NOT (${keep.sql})` : '';
+    return store.run(`DELETE FROM ${table} WHERE ${ownerSql}${notKept}`, [...ownerParams, ...keep.params]);
+};
+
+/** Применяет один агрегат. Возвращает true, если чек записан. */
+const applyAggregate = (store, aggregate) => {
+    const order = aggregate && aggregate.order;
+    if (!order || !order.id) {
+        return false;
+    }
+    if (isDirty(store, order.id)) {
+        return false;
+    }
+
+    const products = aggregate.products || [];
+    const modifiers = aggregate.modifier_sets || [];
+    const payments = aggregate.payments || [];
+
+    store.upsert('orders', order);
+
+    // Позиции, которые были у чека локально, — чтобы убрать и их модификаторы.
+    const localProductIds = store.all('SELECT id FROM order_products WHERE order_id = ?', [order.id])
+        .map((row) => row.id);
+    const remoteProductIds = idsOf(products);
+
+    for (const product of products) {
+        store.upsert('order_products', product);
+    }
+    deleteMissing(store, 'order_products', 'order_id = ?', [order.id], remoteProductIds);
+
+    const ownerIds = [...new Set([...localProductIds, ...remoteProductIds])];
+    for (const modifier of modifiers) {
+        store.upsert('order_product_modifier_sets', modifier);
+    }
+    if (ownerIds.length) {
+        const owners = SyncStore.inList('order_product_id', ownerIds);
+        deleteMissing(store, 'order_product_modifier_sets', owners.sql, owners.params, idsOf(modifiers));
+    }
+
+    for (const payment of payments) {
+        store.upsert('order_payments', payment);
+    }
+    deleteMissing(store, 'order_payments', 'order_id = ?', [order.id], idsOf(payments));
+
+    applyKdsTickets(store, order.id, aggregate);
+
+    return true;
+};
+
+/**
+ * Тикеты кухни чека. Старое облако ключа kds_tickets не присылает — тогда локальные тикеты
+ * не трогаем: пустой список означал бы «удалить все», а это неправда.
+ */
+const applyKdsTickets = (store, orderId, aggregate) => {
+    if (!Array.isArray(aggregate.kds_tickets)) {
+        return;
+    }
+    const tickets = aggregate.kds_tickets;
+    const items = aggregate.kds_ticket_items || [];
+
+    const localTicketIds = store.all('SELECT id FROM kds_tickets WHERE order_id = ?', [orderId])
+        .map((row) => row.id);
+    const remoteTicketIds = idsOf(tickets);
+
+    for (const ticket of tickets) {
+        store.upsert('kds_tickets', ticket);
+    }
+    for (const item of items) {
+        store.upsert('kds_ticket_items', item);
+    }
+
+    const ticketIds = [...new Set([...localTicketIds, ...remoteTicketIds])];
+    if (ticketIds.length) {
+        const owners = SyncStore.inList('kds_ticket_id', ticketIds);
+        deleteMissing(store, 'kds_ticket_items', owners.sql, owners.params, idsOf(items));
+    }
+    deleteMissing(store, 'kds_tickets', 'order_id = ?', [orderId], remoteTicketIds);
+};
+
+/**
+ * Курсор дельты — свой у каждого заведения. Общий курсор после входа в другое заведение
+ * пропускал бы его чеки, изменённые раньше курсора первого (открытый с утра стол не доехал бы
+ * до кассы), а по возвращении — правки первого, сделанные, пока касса работала на втором.
+ * Старый общий ключ 'orders_cursor' не читается: первый pull заведения идёт без курсора.
+ */
+const cursorKey = (companyId) => (companyId ? `orders_cursor:${companyId}` : 'orders_cursor');
+
+// Первый pull без курсора облако отдаёт открытые чеки и открытые за это окно
+// (SyncService::PULL_INITIAL_WINDOW_HOURS): всё, что старше, до кассы не доезжало.
+const INITIAL_WINDOW_HOURS = 36;
+
+/**
+ * С какого момента у кассы есть ВСЕ чеки заведения (ISO-строка в kv). Нужен отчёту кассы
+ * (reports.getReport в ядре): период раньше этого момента локально неполон. Ставится на
+ * первом pull заведения и на первом входе в него (sync.setSession) и только сдвигается назад.
+ * Уборка (cleanup) режет историю отдельно — её границу отчёт учитывает сам.
+ */
+const historyKey = (companyId) => `orders_from:${companyId}`;
+
+/** Сдвигает начало полной истории заведения назад до `from` (вызывать внутри store.block). */
+const extendHistory = (store, companyId, from) => {
+    if (!companyId || !(from instanceof Date) || Number.isNaN(from.getTime())) {
+        return;
+    }
+    const known = Date.parse(kv.get(store, historyKey(companyId)) || '');
+    if (Number.isNaN(known) || from.getTime() < known) {
+        kv.set(store, historyKey(companyId), from.toISOString());
+    }
+};
+
+/** Начало полной истории заведения или null, если касса о нём ничего не знает. */
+const historyFrom = (store, companyId) => {
+    const value = Date.parse((companyId && kv.get(store, historyKey(companyId))) || '');
+    return Number.isNaN(value) ? null : new Date(value);
+};
+
+/**
+ * Применяет страницу pull одним блоком: либо вся страница и курсор, либо ничего.
+ * initial — страница запрошена без курсора (первый pull заведения или полный pull мастера).
+ */
+const applyPage = (store, orders, {cursor = undefined, companyId = null, initial = false} = {}) => {
+    const applied = [];
+    const skipped = [];
+    for (const aggregate of orders || []) {
+        if (applyAggregate(store, aggregate)) {
+            applied.push(aggregate.order.id);
+        } else if (aggregate && aggregate.order && aggregate.order.id) {
+            skipped.push(aggregate.order.id);
+        }
+    }
+    if (cursor !== undefined && cursor !== null) {
+        kv.set(store, cursorKey(companyId), cursor);
+    }
+    if (initial) {
+        extendHistory(store, companyId, new Date(Date.now() - INITIAL_WINDOW_HOURS * 3600000));
+    }
+    kv.set(store, 'last_pull_at', new Date().toISOString());
+    return {applied, skipped};
+};
+
+/**
+ * Pull с облака. Без ids — дельта от сохранённого курсора (первый раз: открытые чеки плюс
+ * закрытые за последние 36 часов), с ids — ровно эти чеки (после конфликта push).
+ * full — первая страница без курсора, как в первый раз: мастер-касса перед тем, как забрать
+ * заведение (модель M), берёт облачную копию целиком, а не только дельту.
+ */
+const pull = async ({store, cloud, ids = null, full = false, companyId = null}) => {
+    const applied = [];
+    const skipped = [];
+    let pages = 0;
+    let hasMore = true;
+
+    while (hasMore && pages < limits().pullPages) {
+        pages += 1;
+        const cursor = ids || (full && pages === 1) ? null : kv.get(store, cursorKey(companyId));
+        const params = ids ? {ids} : {limit: limits().pullLimit, ...(cursor ? {since: cursor} : {})};
+        const response = await cloud.call('sync.pullOrders', params, {timeout: timeouts().api}) || {};
+
+        const result = await store.block(
+            (s) => applyPage(s, response.orders, {
+                cursor: ids ? undefined : response.cursor,
+                companyId,
+                initial: !ids && !cursor,
+            }),
+            {suppress: true}
+        );
+        applied.push(...result.applied);
+        skipped.push(...result.skipped);
+
+        hasMore = !ids && Boolean(response.has_more) && Boolean(response.cursor) && response.cursor !== cursor;
+    }
+
+    return {applied, skipped, pages, hasMore};
+};
+
+/**
+ * Уборка: закрытые и удалённые чеки старше keepClosedDays дней, если они уже в облаке
+ * (не грязные). Чек с максимальным global_number по компании оставляем — от него считается
+ * номер следующего офлайн-чека (OrderRepository::nextNumbers).
+ */
+const cleanup = (store) => {
+    const days = limits().keepClosedDays;
+    const threshold = new Date(Date.now() - days * 86400000).toISOString().slice(0, 19).replace('T', ' ');
+    const ids = store.all(
+        `SELECT o.id FROM orders o
+         WHERE (o.closed_at IS NOT NULL OR o.deleted_at IS NOT NULL)
+           AND COALESCE(o.closed_at, o.deleted_at) < ?
+           AND NOT EXISTS (SELECT 1 FROM sync_dirty d WHERE d.entity = 'order' AND d.id = o.id)
+           AND o.global_number IS NOT (
+               SELECT MAX(o2.global_number) FROM orders o2 WHERE o2.company_id = o.company_id
+           )`,
+        [threshold]
+    ).map((row) => row.id);
+
+    for (const id of ids) {
+        store.run(
+            'DELETE FROM kds_ticket_items WHERE kds_ticket_id IN (SELECT id FROM kds_tickets WHERE order_id = ?)',
+            [id]
+        );
+        store.run('DELETE FROM kds_tickets WHERE order_id = ?', [id]);
+        store.run(
+            `DELETE FROM order_product_modifier_sets
+             WHERE order_product_id IN (SELECT id FROM order_products WHERE order_id = ?)`,
+            [id]
+        );
+        store.run('DELETE FROM order_products WHERE order_id = ?', [id]);
+        store.run('DELETE FROM order_payments WHERE order_id = ?', [id]);
+        store.run('DELETE FROM order_events WHERE order_id = ?', [id]);
+        store.run('DELETE FROM orders WHERE id = ?', [id]);
+    }
+    return ids.length;
+};
+
+module.exports = {pull, applyAggregate, applyPage, cleanup, cursorKey, historyKey, extendHistory, historyFrom};