@alizadefaig/pos-server 1.2.26 → 1.2.27

package/app/sync/signal.js

@@ -0,0 +1,202 @@
+const {io} = require('socket.io-client');
+const {normalizeApiUrl} = require('./cloud');
+
+/**
+ * Сигнальный сокет к облаку: «в компании что-то поменялось — сделай pull».
+ *
+ * Подключаемся как прокси-сокет (is_proxy_server): облачный Node кладёт такой сокет в комнату
+ * компании, но обработчиков фронта ему не вешает. terminal_id в query НЕ передаём — иначе облако
+ * считало бы этот сокет терминалом и адресовало бы ему запросы печати (socket/request).
+ *
+ * Данные из патчей не применяем: чек всё равно приходит pull'ом целиком, а сигнал лишь
+ * говорит, когда его делать. Так у зеркала один вход, и порядок событий не важен.
+ *
+ * Модель M (OFFLINE-FIRST-PLAN §12): тот же сокет — канал мастер-кассы. В handshake.auth уходят
+ * токен и заголовки терминала; облачный Node с MASTER_RELAY_ENABLED сверяет их с Laravel и
+ * отвечает `master:ready`. После этого по сокету ходят:
+ *   облако → касса: master:request (событие клиента облака, ответ ack), sync:pull {ids}, pos:mode;
+ *   касса → облако: master:broadcast (бродкаст ядра клиентам облака),
+ *                   master:terminalRequest (печать на терминал, подключённый только к облаку).
+ * Старый облачный Node auth просто игнорирует — сокет работает как раньше.
+ *
+ * sync:snapshot {source_terminal_id} — в облаке поменялся справочник, который касса правит и сама
+ * (принтеры): снапшот нужен сейчас, а не через 10 минут. Своё эхо (source = эта касса) пропускаем.
+ */
+const PULL_EVENTS = new Set(['orders:patch', 'orders:patchBatch', 'orders:update']);
+
+// Служебные и адресные каналы: локальным клиентам их не пересылаем.
+const isServiceEvent = (eventName) => eventName.startsWith('api:')
+    || eventName.startsWith('request:')
+    || eventName.startsWith('response:')
+    || eventName.startsWith('master:')
+    || eventName === 'pos:mode'
+    || eventName === 'sync:pull'
+    || eventName === 'sync:snapshot';
+
+const noop = () => {};
+
+class CloudSignal {
+    /**
+     * @param {object} options
+     * @param {object} options.session      сессия терминала (тот же объект, что у CloudClient)
+     * @param {Function} options.onChange   сигнал «облако что-то поменяло» (pull по курсору)
+     * @param {Function} [options.onSnapshot] сигнал «облако поменяло справочник» (sync:snapshot)
+     * @param {object} [options.master]     обработчики модели M:
+     *   isLocal()            — касса сейчас истина заведения (local/draining);
+     *   onRequest(payload)   — событие клиента облака → Promise<ack>;
+     *   onPull(ids)          — sync:pull;
+     *   onMode(state)        — pos:mode;
+     *   onBroadcast(event, args) — бродкаст облака для локальных клиентов.
+     */
+    constructor({session, onChange, onSnapshot = noop, onConnect = noop, onDisconnect = noop, master = null}) {
+        this.session = session;
+        this.onChange = onChange;
+        this.onSnapshot = onSnapshot;
+        this.onConnectCb = onConnect;
+        this.onDisconnectCb = onDisconnect;
+        this.master = master;
+        this.socket = null;
+        this.connected = false;
+        // облачный Node признал сокет мастер-кассой (master:ready)
+        this.relayReady = false;
+    }
+
+    isLocal() {
+        return Boolean(this.master && this.master.isLocal());
+    }
+
+    start() {
+        if (this.socket || !this.session.api_url || !this.session.company_id) {
+            return this;
+        }
+        const session = this.session;
+        this.socket = io(normalizeApiUrl(session.api_url), {
+            query: {
+                company_id: session.company_id,
+                is_proxy_server: 'true',
+            },
+            // Функция, а не объект: токен/терминал могут смениться на месте (setSession),
+            // и переподключение должно предъявить актуальные.
+            // Токен уходит всегда: облако с SOCKET_AUTH=enforce без него сокет не пустит.
+            auth: (cb) => cb({
+                ...(this.master ? {master: true} : {}),
+                token: session.token,
+                team_id: session.team_id,
+                company_id: session.company_id,
+                terminal_id: session.terminal_id,
+            }),
+            reconnection: true,
+            reconnectionDelay: 2000,
+            reconnectionDelayMax: 15000,
+        });
+        this.socket.on('connect', () => {
+            this.connected = true;
+            // Пока сокета не было, патчи могли пролететь мимо — догоняем pull'ом.
+            this.onConnectCb();
+            this.onChange();
+            if (this.master) {
+                // И режим заведения мог смениться, пока нас не было.
+                this.master.onMode(null);
+            }
+        });
+        this.socket.on('disconnect', () => {
+            this.connected = false;
+            this.relayReady = false;
+            this.onDisconnectCb();
+        });
+
+        if (this.master) {
+            this.socket.on('master:ready', (payload) => {
+                this.relayReady = Boolean(payload && payload.ok);
+                if (!this.relayReady) {
+                    console.warn(`[sync] cloud relay refused this terminal: ${payload && payload.reason}`);
+                }
+            });
+            this.socket.on('master:request', async (payload, ack) => {
+                if (typeof ack !== 'function') {
+                    return;
+                }
+                try {
+                    ack(await this.master.onRequest(payload || {}));
+                } catch (e) {
+                    console.error('[sync] master request failed:', e);
+                    ack({relayed: false, error_code: 'master_error', message: e.message});
+                }
+            });
+        }
+
+        this.socket.onAny((eventName, ...args) => {
+            if (this.master && eventName === 'pos:mode') {
+                this.master.onMode(args[0] || null);
+                return;
+            }
+            if (this.master && eventName === 'sync:pull') {
+                const ids = args[0] && Array.isArray(args[0].ids) ? args[0].ids : [];
+                if (ids.length) {
+                    this.master.onPull(ids);
+                }
+                return;
+            }
+            if (eventName === 'sync:snapshot') {
+                const source = args[0] && args[0].source_terminal_id;
+                if (!source || source !== this.session.terminal_id) {
+                    this.onSnapshot();
+                }
+                return;
+            }
+            if (PULL_EVENTS.has(eventName)) {
+                // Истина у этой кассы: облачные патчи — эхо её же выгрузки, pull по ним не нужен.
+                // Настоящие расхождения облако присылает адресно (sync:pull).
+                if (!this.isLocal()) {
+                    this.onChange();
+                }
+                return;
+            }
+            // KDS, экраны готовности и клиентские бродкасты облака — локальным клиентам.
+            if (this.isLocal() && !isServiceEvent(eventName)) {
+                this.master.onBroadcast(eventName, args);
+            }
+        });
+        return this;
+    }
+
+    /** Бродкаст ядра мастера → клиенты заведения, подключённые к облаку. */
+    broadcast(eventName, args) {
+        if (!this.socket || !this.connected || !this.relayReady) {
+            return false;
+        }
+        this.socket.emit('master:broadcast', {event: eventName, args});
+        return true;
+    }
+
+    /**
+     * Запрос к терминалу, которого нет в локальном сокете (например, печать на PWA облака).
+     * null — канала нет, вызывающий отвечает «No socket» как раньше.
+     */
+    terminalRequest({terminalId, eventName, data, requestId, timeout}) {
+        if (!this.socket || !this.connected || !this.relayReady) {
+            return null;
+        }
+        const waitMs = Number(timeout) > 0 ? Number(timeout) : 10000;
+        return this.socket.timeout(waitMs + 5000).emitWithAck('master:terminalRequest', {
+            terminal_id: terminalId,
+            event: eventName,
+            data,
+            request_id: requestId,
+            timeout: waitMs,
+        }).catch(() => ({success: false, message: 'Timeout error'}));
+    }
+
+    stop() {
+        if (this.socket) {
+            this.socket.offAny();
+            this.socket.removeAllListeners();
+            this.socket.disconnect();
+            this.socket = null;
+        }
+        this.connected = false;
+        this.relayReady = false;
+    }
+}
+
+module.exports = {CloudSignal, PULL_EVENTS, isServiceEvent};

package/app/sync/snapshot.js

@@ -0,0 +1,189 @@
+const kv = require('./kv');
+const {timeouts} = require('./config');
+const {quote} = require('./store');
+
+/**
+ * Снапшот справочников: облако → локальная БД (товары, залы, столы, сотрудники, настройки…).
+ *
+ * Таблица заменяется целиком: удалённое в бэк-офисе должно пропасть и на кассе. Чеки сюда
+ * не входят — их ведёт зеркало (mirror.js), а служебные таблицы синка не трогаются вовсе.
+ * Весь снапшот применяется одним блоком: касса никогда не видит половину старого каталога
+ * и половину нового.
+ */
+const DENY = new Set([
+    'orders', 'order_products', 'order_product_modifier_sets', 'order_payments', 'order_events',
+    // тикеты кухни едут вместе с чеком (агрегат push/зеркало), а не справочником
+    'kds_tickets', 'kds_ticket_items',
+    'outbox', 'idempotency_keys', 'number_sequences', 'kv', 'sync_dirty', 'sync_suppress',
+    // логотип едет отдельным ключом team_logo (applyTeamLogo)
+    'team_logos',
+    '_migrations',
+]);
+
+/**
+ * Строки, которые нельзя стирать при замене таблицы:
+ *   shifts   — смена, открытая/закрытая офлайн и ещё не отправленная;
+ *   products — «свободный» товар (addExtra), созданный кассой: облако его пока не знает;
+ *   printers, printer_workshop — принтер, настроенный на кассе без облака (printers.update /
+ *              delete / syncAddress в ядре), вместе с его цехами, пока push его не доставил.
+ */
+const DIRTY_PRINTERS = "SELECT id FROM sync_dirty WHERE entity = 'printer'";
+const KEEP_LOCAL = {
+    shifts: "id IN (SELECT id FROM sync_dirty WHERE entity = 'shift')",
+    products: 'synced_at IS NULL',
+    printers: `id IN (${DIRTY_PRINTERS})`,
+    printer_workshop: `printer_id IN (${DIRTY_PRINTERS})`,
+};
+
+/**
+ * Входящие строки, которые не пишутся: локальная версия ещё не отправлена и главнее.
+ * Возвращает функцию «пропустить строку?» или null.
+ */
+const skipDirty = (store, table) => {
+    const dirty = (entity) => new Set(
+        store.all('SELECT id FROM sync_dirty WHERE entity = ?', [entity]).map((row) => row.id)
+    );
+    if (table === 'shifts') {
+        const ids = dirty('shift');
+        return (row) => ids.has(row.id);
+    }
+    if (table === 'printers') {
+        const ids = dirty('printer');
+        return (row) => ids.has(row.id);
+    }
+    if (table === 'printer_workshop') {
+        const ids = dirty('printer');
+        return (row) => ids.has(row.printer_id);
+    }
+    return null;
+};
+
+const applyTables = (store, tables, serverTime) => {
+    const applied = {};
+    const skipped = [];
+    for (const [table, rows] of Object.entries(tables || {})) {
+        if (DENY.has(table) || !Array.isArray(rows) || !store.hasTable(table)) {
+            skipped.push(table);
+            continue;
+        }
+        const columns = store.columns(table);
+        const keep = KEEP_LOCAL[table];
+        store.run(`DELETE FROM ${quote(table)}${keep ? ` WHERE NOT (${keep})` : ''}`);
+
+        const skip = skipDirty(store, table);
+
+        // Связки (printer_workshop, terminal_workshop…) своего id не имеют: таблица только что
+        // очищена целиком, поэтому их строки просто вставляются. Пропускать их нельзя — пустая
+        // printer_workshop оставила бы офлайн-печать цехов без принтеров.
+        const keyed = columns.has('id');
+        let count = 0;
+        for (const row of rows) {
+            if (!row || typeof row !== 'object' || (keyed && !row.id)) {
+                continue;
+            }
+            if (skip && skip(row)) {
+                continue;
+            }
+            const value = columns.has('synced_at') ? {...row, synced_at: serverTime} : row;
+            if (keyed) {
+                store.upsert(table, value);
+            } else {
+                store.insert(table, value);
+            }
+            count += 1;
+        }
+        applied[table] = count;
+    }
+
+    // Язык команды: в облаке это teams.language_id → languages.code, а ядро читает
+    // готовый teams.language_code (см. Context::resolveLocale).
+    if (store.hasTable('languages') && store.columns('teams').has('language_id')) {
+        store.run(
+            `UPDATE teams SET language_code = (SELECT code FROM languages WHERE languages.id = teams.language_id)
+             WHERE language_id IS NOT NULL
+               AND EXISTS (SELECT 1 FROM languages WHERE languages.id = teams.language_id AND code IS NOT NULL)`
+        );
+    }
+    return {applied, skipped};
+};
+
+/**
+ * Картинка, копия которой уже лежит на кассе, — облако её повторно не шлёт. Копия без данных
+ * (облако не смогло прочитать файл) не в счёт: пусть облако попробует снова.
+ */
+const heldLogoId = (store, teamId) => {
+    if (!teamId) {
+        return null;
+    }
+    const row = store.get('SELECT image_id FROM team_logos WHERE team_id = ? AND data IS NOT NULL', [teamId]);
+    return row ? row.image_id : null;
+};
+
+/**
+ * Логотип команды для счёта (ключ team_logo, SyncService::teamLogo):
+ *   {id, data}             — новая картинка; {id: null} — логотипа у команды больше нет;
+ *   {id, unchanged: true}  — у кассы та же картинка.
+ * Ключа нет (старое облако) или null (облако не прочитало файл) — копия кассы не трогается.
+ */
+const applyTeamLogo = (store, teamId, logo) => {
+    if (!teamId || !logo || typeof logo !== 'object' || logo.unchanged) {
+        return;
+    }
+    if (!logo.id) {
+        store.run('DELETE FROM team_logos WHERE team_id = ?', [teamId]);
+        return;
+    }
+    store.run(
+        `INSERT INTO team_logos (team_id, image_id, data, updated_at) VALUES (?, ?, ?, datetime('now'))
+         ON CONFLICT (team_id) DO UPDATE SET image_id = excluded.image_id, data = excluded.data, updated_at = excluded.updated_at`,
+        [teamId, String(logo.id), typeof logo.data === 'string' && logo.data ? logo.data : null]
+    );
+};
+
+/** Снапшот мастера/одиночной кассы: справочники + blob app.init для офлайн-старта терминала. */
+const pullSnapshot = async ({store, cloud}) => {
+    const teamId = (cloud.session && cloud.session.team_id) || null;
+    const logoId = heldLogoId(store, teamId);
+    const response = await cloud.call(
+        'sync.snapshot',
+        logoId ? {team_logo_id: logoId} : {},
+        {timeout: timeouts().snapshot}
+    ) || {};
+    if (!response.tables || typeof response.tables !== 'object') {
+        throw new Error('sync.snapshot: empty response');
+    }
+    const serverTime = response.server_time || new Date().toISOString();
+
+    const result = await store.block((s) => {
+        const tables = applyTables(s, response.tables, serverTime);
+        applyTeamLogo(s, teamId, response.team_logo);
+        if (response.init) {
+            kv.set(s, 'init', response.init);
+        }
+        kv.set(s, 'snapshot_at', new Date().toISOString());
+        return tables;
+    }, {suppress: true});
+
+    if (result.skipped.length) {
+        console.log(`[sync] snapshot: skipped tables ${result.skipped.join(', ')}`);
+    }
+    return result;
+};
+
+/**
+ * Ведомый терминал своей БД не ведёт, но офлайн-старт ему всё равно нужен: хранит свой ответ
+ * app.init (у каждого терминала он свой — цеха, принтеры, настройки терминала).
+ */
+const pullInitOnly = async ({store, cloud}) => {
+    const init = await cloud.call('app.init', {}, {timeout: timeouts().snapshot});
+    if (!init || typeof init !== 'object') {
+        throw new Error('app.init: empty response');
+    }
+    await store.block((s) => {
+        kv.set(s, 'init', init);
+        kv.set(s, 'snapshot_at', new Date().toISOString());
+    });
+    return {applied: {init: 1}, skipped: []};
+};
+
+module.exports = {pullSnapshot, pullInitOnly, applyTables, DENY};

package/app/sync/store.js

@@ -0,0 +1,234 @@
+const {getDatabase} = require('../db/Database');
+const {normalizeParam} = require('../db/driver');
+
+/**
+ * Доступ синка к локальной SQLite — синхронными блоками поверх того же соединения, что у ядра.
+ *
+ * Почему не мьютекс. Соединение одно на процесс, и любая запись посреди открытой транзакции
+ * уезжает в её COMMIT/ROLLBACK. Ядро транзакций почти не держит (единственная —
+ * idempotency.reclaimStale), зато между его await'ами может вклиниться что угодно. Поэтому
+ * блок синка ждёт, пока транзакции нет, и дальше исполняется целиком синхронно:
+ * BEGIN → работа → COMMIT без единого await внутри. Никакая запись ядра не попадёт ни внутрь
+ * блока, ни между его чтением и записью.
+ *
+ * Синхронно читается и агрегат для push: иначе строка, прочитанная посреди чужой транзакции,
+ * могла бы уехать в облако, а потом откатиться локально.
+ */
+const IDENT = /^[a-z_][a-z0-9_]*$/i;
+
+const quote = (name) => {
+    if (!IDENT.test(name)) {
+        throw new Error(`sync: bad identifier ${name}`);
+    }
+    return `"${name}"`;
+};
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// 2026-09-24T12:00:00.000000Z · 2026-09-24 12:00:00+00 · 2026-09-24T12:00:00+04:00
+const ZONED_TIMESTAMP = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?)(\.\d+)?(Z|[+-]\d{2}(?::?\d{2})?)?$/;
+
+/**
+ * Время из облака → локальный формат ядра ('YYYY-MM-DD HH:MM:SS', UTC). Laravel сериализует
+ * даты в ISO с зоной, Postgres в текстовом виде — с '+00'. Строки без зоны и без 'T' уже
+ * в нужном формате и не трогаются.
+ */
+const toSqlTimestamp = (value) => {
+    const match = ZONED_TIMESTAMP.exec(value);
+    if (!match || (!match[4] && !value.includes('T'))) {
+        return value;
+    }
+    let zone = match[4] || 'Z';
+    if (/^[+-]\d{2}$/.test(zone)) {
+        zone += ':00';
+    } else if (/^[+-]\d{4}$/.test(zone)) {
+        zone = `${zone.slice(0, 3)}:${zone.slice(3)}`;
+    }
+    const time = match[2].length === 5 ? `${match[2]}:00` : match[2];
+    const fraction = match[3] ? match[3].slice(0, 4) : '';
+    const date = new Date(`${match[1]}T${time}${fraction}${zone}`);
+    if (Number.isNaN(date.getTime())) {
+        return value;
+    }
+    return date.toISOString().slice(0, 19).replace('T', ' ');
+};
+
+/** Значение из облака → значение для SQLite-колонки. */
+const toLocalValue = (value) => {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    if (typeof value === 'string') {
+        return toSqlTimestamp(value);
+    }
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 19).replace('T', ' ');
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return normalizeParam(value);
+};
+
+class SyncStore {
+    constructor(database) {
+        this.database = database;
+        this.driver = database.connection();
+        this.raw = this.driver.raw;
+        this.statements = new Map();
+        this.columnCache = new Map();
+    }
+
+    prepare(sql) {
+        if (!this.statements.has(sql)) {
+            this.statements.set(sql, this.raw.prepare(sql));
+        }
+        return this.statements.get(sql);
+    }
+
+    all(sql, params = []) {
+        return this.prepare(sql).all(...params.map(normalizeParam));
+    }
+
+    get(sql, params = []) {
+        const rows = this.all(sql, params);
+        return rows.length ? rows[0] : null;
+    }
+
+    run(sql, params = []) {
+        const result = this.prepare(sql).run(...params.map(normalizeParam));
+        return result?.changes ?? 0;
+    }
+
+    /** Колонки локальной таблицы: name → {notnull, hasDefault}. Пустая Map — таблицы нет. */
+    columns(table) {
+        if (!this.columnCache.has(table)) {
+            const rows = this.all(`PRAGMA table_info(${quote(table)})`);
+            this.columnCache.set(table, new Map(rows.map((row) => [row.name, {
+                notnull: Boolean(row.notnull),
+                hasDefault: row.dflt_value !== null && row.dflt_value !== undefined,
+            }])));
+        }
+        return this.columnCache.get(table);
+    }
+
+    hasTable(table) {
+        return IDENT.test(table) && this.columns(table).size > 0;
+    }
+
+    /**
+     * Вставка-или-обновление строки облака. Пишутся только колонки, которые есть локально:
+     * облачная схема шире, а лишняя колонка уронила бы весь блок. null в NOT NULL-колонку
+     * не пишем — пусть сработает DEFAULT (Laravel такие поля при вставке не шлёт вовсе).
+     */
+    upsert(table, row) {
+        const {names, values} = this.localRow(table, row);
+        if (!names.includes('id')) {
+            throw new Error(`sync: row of ${table} without id`);
+        }
+        const updates = names.filter((name) => name !== 'id')
+            .map((name) => `${quote(name)} = excluded.${quote(name)}`);
+        const sql = `INSERT INTO ${quote(table)} (${names.map(quote).join(', ')})
+            VALUES (${names.map(() => '?').join(', ')})
+            ON CONFLICT (id) DO ${updates.length ? `UPDATE SET ${updates.join(', ')}` : 'NOTHING'}`;
+        return this.run(sql, values);
+    }
+
+    /**
+     * Строка связки без собственного id (printer_workshop, terminal_workshop…): такие таблицы
+     * снапшот заменяет целиком, поэтому достаточно простой вставки.
+     */
+    insert(table, row) {
+        const {names, values} = this.localRow(table, row);
+        if (!names.length) {
+            return 0;
+        }
+        return this.run(
+            `INSERT INTO ${quote(table)} (${names.map(quote).join(', ')}) VALUES (${names.map(() => '?').join(', ')})`,
+            values
+        );
+    }
+
+    /** Пересечение строки облака с локальными колонками, значения приведены к SQLite. */
+    localRow(table, row) {
+        const columns = this.columns(table);
+        const names = [];
+        const values = [];
+        for (const [name, value] of Object.entries(row)) {
+            const column = columns.get(name);
+            if (!column) {
+                continue;
+            }
+            const local = toLocalValue(value);
+            if (local === null && column.notnull) {
+                continue;
+            }
+            names.push(name);
+            values.push(local);
+        }
+        return {names, values};
+    }
+
+    /** `id IN (?, ?, ...)` для списка; пустой список — условие, которое ничего не выбирает. */
+    static inList(column, ids) {
+        if (!ids.length) {
+            return {sql: '0', params: []};
+        }
+        return {sql: `${column} IN (${ids.map(() => '?').join(', ')})`, params: ids};
+    }
+
+    /**
+     * Синхронный блок. fn обязан быть синхронным: вернул Promise — блок откатывается.
+     * suppress — триггеры sync_dirty молчат (пишем облачные данные, а не правки кассы).
+     */
+    async block(fn, {suppress = false, waitMs = 30000} = {}) {
+        const started = Date.now();
+        while (this.driver.inTransaction) {
+            if (Date.now() - started > waitMs) {
+                throw new Error('sync: core transaction is still open');
+            }
+            await sleep(5);
+        }
+        return this.blockNow(fn, {suppress});
+    }
+
+    blockNow(fn, {suppress = false} = {}) {
+        this.raw.exec('BEGIN');
+        try {
+            if (suppress) {
+                this.run('INSERT OR IGNORE INTO sync_suppress (id) VALUES (1)');
+            }
+            const result = fn(this);
+            if (result && typeof result.then === 'function') {
+                throw new Error('sync: block callback must be synchronous');
+            }
+            if (suppress) {
+                this.run('DELETE FROM sync_suppress');
+            }
+            this.raw.exec('COMMIT');
+            return result;
+        } catch (e) {
+            try {
+                this.raw.exec('ROLLBACK');
+            } catch (rollbackError) {
+                // транзакцию мог уже свернуть сам SQLite — исходная ошибка важнее
+            }
+            throw e;
+        }
+    }
+}
+
+let instance = null;
+
+const getStore = async () => {
+    const database = await getDatabase();
+    if (!instance || instance.database !== database || instance.driver !== database.connection()) {
+        instance = new SyncStore(database);
+    }
+    return instance;
+};
+
+module.exports = {SyncStore, getStore, toLocalValue, toSqlTimestamp, quote};

package/app/tcp.js

@@ -77,7 +77,16 @@ module.exports = function (io = null) {
         socket.on('error', (err) => console.error('TCP Error:', err));
     });
 
-    server.listen(3001, '0.0.0.0', () => {
-        console.log('TCP Server listening on port 3001');
+    // У TCP-канала нет ключа: кто достучался, тот рассылает в любую компанию. В проде Laravel
+    // ходит по HTTP (OVER_TCP=false) — тогда порт лучше не открывать вовсе (TCP_ENABLED=false)
+    // или хотя бы прибить к внутреннему адресу (TCP_HOST). Дефолты — как раньше.
+    if (process.env.TCP_ENABLED === 'false') {
+        console.log('TCP Server disabled (TCP_ENABLED=false)');
+        return;
+    }
+    const tcpHost = process.env.TCP_HOST || '0.0.0.0';
+    const tcpPort = Number(process.env.TCP_PORT) || 3001;
+    server.listen(tcpPort, tcpHost, () => {
+        console.log(`TCP Server listening on ${tcpHost}:${tcpPort}`);
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@alizadefaig/pos-server",
-    "version": "1.2.26",
+    "version": "1.2.27",
     "description": "Server in express js with Proxy to Main server if need and will work with Electron JS",
     "homepage": "https://gitlab.com/faigalizade/pos-server#readme",
     "bugs": {
@@ -13,6 +13,7 @@
     "dependencies": {
         "@alizadefaig/cafetap-escpos-usb": "^1.0.1",
         "axios": "^1.13.2",
+        "bcryptjs": "^3.0.3",
         "cors": "^2.8.5",
         "escpos": "^3.0.0-alpha.6",
         "escpos-network": "^3.0.0-alpha.5",
@@ -21,6 +22,7 @@
         "lodash": "^4.17.21",
         "moment": "^2.30.1",
         "multer": "^2.0.2",
+        "pg": "^8.22.0",
         "redis": "^5.10.0",
         "sequelize": "^6.37.7",
         "sharp": "^0.34.5",
@@ -36,7 +38,8 @@
         "lib": "lib"
     },
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1",
+        "test": "node --test --test-concurrency=1 \"test/**/*.test.js\"",
+        "test:watch": "node --test --watch --test-concurrency=1 \"test/**/*.test.js\"",
         "start": "node server.js"
     }
-}
+}