@alizadefaig/pos-server 1.2.26 → 1.2.28

package/app/socket/server.js

@@ -5,6 +5,40 @@ const https = require("https");
 const {getConfig} = require("../config");
 const {getLogger} = require("../logger/Log");
 const {socketSendByFilter} = require("../../utils");
+const {canHandle: coreCanHandle, dispatch: coreDispatch} = require("../core");
+const {socketGuard} = require("../sync/lan");
+const {socketAllowRequest} = require("../security");
+const {socketAuth} = require("./auth");
+const syncConfig = require("../sync/config");
+
+// Офлайн-контур (модель F): клиентские бродкасты фронта, которые надо разнести по залу.
+// Служебные каналы (api:*, ответы на request:*) адресные — их не ретранслируем.
+const isRelayable = (eventName) => !eventName.startsWith('api:') && !eventName.startsWith('response:');
+
+// Контекст запроса телефона по LAN совпадает с тем, по которому его пустили. Пустой заголовок
+// подменой не считается: lanDeviceHeaders заполнит его значением устройства. Сверяются все
+// варианты имени (`company-id` и `Company-Id` в одном запросе), а не только первый найденный.
+const LAN_HEADERS = [['terminal-id', 'terminal_id'], ['company-id', 'company_id'], ['team-id', 'team_id']];
+const lanHeadersMatch = (device, headers) => {
+    const fields = new Map(LAN_HEADERS);
+    return Object.entries(headers && typeof headers === 'object' ? headers : {}).every(([key, raw]) => {
+        const field = fields.get(key.toLowerCase());
+        const value = Array.isArray(raw) ? raw[0] : raw;
+        return !field || value === undefined || value === null || value === ''
+            || String(value) === String(device[field]);
+    });
+};
+const lanDeviceHeaders = (device, headers) => {
+    const names = new Set(LAN_HEADERS.map(([header]) => header));
+    const result = {};
+    for (const [key, value] of Object.entries(headers && typeof headers === 'object' ? headers : {})) {
+        if (!names.has(key.toLowerCase())) result[key] = value;
+    }
+    for (const [header, field] of LAN_HEADERS) {
+        if (device[field]) result[header] = device[field];
+    }
+    return result;
+};
 
 // Keep-alive agent — переиспользуем TCP-соединения к Laravel вместо новых на каждый запрос.
 // БАГ C: maxSockets 64→128 (запас; после async-печати длинных холдов почти нет). env-настраиваемо.
@@ -48,7 +82,8 @@ module.exports = (server = null) => {
     if (server && !serverSocket) {
         // Дефолт = поведение как сейчас (нативные heartbeat/адаптер). Опции добавляются
         // только при явном включении флагов — это и есть «правка под флагом с откатом».
-        const serverOptions = { cors: { origin: '*' } };
+        // allowRequest: WebSocket не подчиняется CORS — Origin проверяем сами (no-op без офлайна).
+        const serverOptions = { cors: { origin: '*' }, allowRequest: socketAllowRequest };
         if (WS_HEARTBEAT_ENABLED) {
             serverOptions.pingInterval = WS_PING_INTERVAL; // быстрый детект мёртвого сокета (~15с)
             serverOptions.pingTimeout = WS_PING_TIMEOUT;
@@ -61,6 +96,10 @@ module.exports = (server = null) => {
             };
         }
         serverSocket = new Server(server, serverOptions);
+        // Мастер зала слушает 0.0.0.0 — сокет без ключа зала не пускаем (no-op без синка/ключа).
+        serverSocket.use(socketGuard);
+        // Облачный Node: токен сокета проверяет Laravel (SOCKET_AUTH, по умолчанию off).
+        serverSocket.use(socketAuth);
 
         const logger = getLogger();
 
@@ -90,7 +129,10 @@ module.exports = (server = null) => {
             const companyId = socket.handshake.query.company_id;
             const terminalId = socket.handshake.query.terminal_id;
             let userId = socket.handshake.query.user_id;
-            const isProxy = socket.handshake.query.is_proxy_server ?? false;
+            // Телефон, пришедший по LAN со своим токеном (socketGuard), — обычный клиент,
+            // прокси-сокетом он себя не объявит.
+            const lanDevice = socket.data.lanDevice || null;
+            const isProxy = lanDevice ? false : (socket.handshake.query.is_proxy_server ?? false);
             const PROXY_TARGET = getConfig().apiUrl;
 
             socket.join(companyId);
@@ -100,12 +142,16 @@ module.exports = (server = null) => {
             socket.userId = userId;
             socket.isProxy = isProxy;
 
+            // С синком фронт подключается к локальному Node только офлайн: облаку о его
+            // присутствии и событиях сообщить нечем (запросы висели бы до таймаута TCP).
+            const reportToCloud = !syncConfig.isSyncEnabled();
+
             if (!isProxy) {
                 // При connectionStateRecovery 'connection' ре-фаерится на восстановленном
                 // сокете (socket.recovered=true) — повторный presence-POST не нужен (терминал
                 // уже зарегистрирован, комнаты восстановлены). Обработчики ниже регистрируем
                 // всегда (объект сокета новый).
-                if (!socket.recovered) {
+                if (!socket.recovered && reportToCloud) {
                     axios.post(`${PROXY_TARGET}/api/socket/connection`, {
                         companyId,
                         terminalId,
@@ -126,6 +172,35 @@ module.exports = (server = null) => {
                     // Немедленно подтверждаем получение — фронт знает что запрос дошёл
                     socket.emit(ackEvent);
 
+                    // Телефон по LAN проверен при подключении по своему терминалу и заведению.
+                    // Заголовки запроса обязаны говорить о том же: иначе по токену одного
+                    // терминала можно было бы действовать от имени другого.
+                    if (lanDevice) {
+                        if (!lanHeadersMatch(lanDevice, headers)) {
+                            socket.emit(responseEvent, {
+                                success: false,
+                                error: { success: false, message: 'Forbidden', error_code: 'lan_device_mismatch' },
+                            });
+                            return;
+                        }
+                        headers = lanDeviceHeaders(lanDevice, headers);
+                    }
+
+                    // Офлайн-ядро: событие обрабатывается локальной БД, в Laravel не идёт.
+                    // canHandle учитывает флаг OFFLINE_CORE — при выключенном флаге (по умолчанию)
+                    // всегда false, и запрос уходит наверх ровно как раньше.
+                    if (coreCanHandle(event)) {
+                        try {
+                            const result = await coreDispatch(event, { headers: headers ?? {}, params: data ?? {} });
+                            if (HOT_LOGS) console.log(`[api:res] ${event} ✓ local ${Date.now() - t0}ms id=${request_id.slice(0, 8)}`);
+                            socket.emit(responseEvent, { success: true, data: result });
+                        } catch (err) {
+                            if (HOT_LOGS) console.log(`[api:res] ${event} ✗ local status=${err?.status} id=${request_id.slice(0, 8)}`);
+                            socket.emit(responseEvent, { success: false, error: err?.body ?? { message: err.message } });
+                        }
+                        return;
+                    }
+
                     // Прокидываем Idempotency-Key если прислан
                     const idempotencyKey = headers?.['Idempotency-Key'] ?? headers?.['idempotency-key'];
                     const upstreamHeaders = {
@@ -158,13 +233,15 @@ module.exports = (server = null) => {
                 socket.on('setUserId', (id) => {
                     userId = id;
 
-                    axios.post(`${PROXY_TARGET}/api/socket/setUserId`, {
-                        companyId,
-                        terminalId,
-                        userId,
-                    }).catch((err) => {
-                        logger.error(err);
-                    });
+                    if (reportToCloud) {
+                        axios.post(`${PROXY_TARGET}/api/socket/setUserId`, {
+                            companyId,
+                            terminalId,
+                            userId,
+                        }).catch((err) => {
+                            logger.error(err);
+                        });
+                    }
 
 
                     if (id) {
@@ -174,6 +251,7 @@ module.exports = (server = null) => {
 
 
                 socket.on('disconnect', () => {
+                    if (!reportToCloud) return;
                     axios.post(`${PROXY_TARGET}/api/socket/disconnect`, {
                         companyId,
                         terminalId,
@@ -185,17 +263,41 @@ module.exports = (server = null) => {
 
                 socket.onAny((eventName, ...data) => {
                     if (eventName.startsWith('api:')) return; // handled by api:request handler
-                    axios.post(`${PROXY_TARGET}/api/socket/${eventName}`, {
-                        companyId,
-                        terminalId,
-                        userId,
-                        data
-                    }).catch((err) => {
-                        logger.error(err);
-                    });
+                    if (reportToCloud) {
+                        axios.post(`${PROXY_TARGET}/api/socket/${eventName}`, {
+                            companyId,
+                            terminalId,
+                            userId,
+                            data
+                        }).catch((err) => {
+                            logger.error(err);
+                        });
+                    }
+                    socket.to(companyId).emit(eventName, ...data);
+
+                    // Ведомый терминал: остальной зал сидит на мастере — отдаём бродкаст туда.
+                    if (!reportToCloud && syncConfig.role() === 'follower' && isRelayable(eventName)) {
+                        const bridge = require('../sync').bridge();
+                        if (bridge) bridge.forward(eventName, ...data);
+                    }
+                    // Мастер заведения (модель M): терминалы, работающие через облако, тоже
+                    // должны увидеть бродкаст. Вне режима local — no-op.
+                    if (!reportToCloud && syncConfig.role() !== 'follower' && isRelayable(eventName)) {
+                        require('../sync').relayBroadcast(eventName, data);
+                    }
+                });
+            } else if (socket.handshake.auth?.master && syncConfig.isMasterRelayEnabled()) {
+                // Облачный Node: сигнальный сокет мастер-кассы. Личность проверяется через
+                // Laravel, до ответа master:ready канал ретрансляции закрыт.
+                require('../relay/masters').register(socket);
+            } else if (syncConfig.isSyncEnabled() && syncConfig.role() !== 'follower') {
+                // Мастер зала: прокси-сокет — это мост ведомого терминала. Его клиентские
+                // бродкасты (orders:closing…) раздаём остальным терминалам компании.
+                socket.onAny((eventName, ...data) => {
+                    if (!isRelayable(eventName)) return;
                     socket.to(companyId).emit(eventName, ...data);
+                    require('../sync').relayBroadcast(eventName, data);
                 });
-            } else {
             }
         });
     }

package/app/sync/bridge.js

@@ -0,0 +1,162 @@
+const {io} = require('socket.io-client');
+const {lanKey} = require('./config');
+
+/**
+ * Мост ведомого терминала к мастеру зала (socket.io).
+ *
+ * Офлайн фронт ведомого подключён к СВОЕМУ Node, а чеки живут у мастера. Мост:
+ *   мастер → фронт:  бродкасты мастера (orders:patch и т.п.) пересылаются в комнату компании
+ *                    своего сокет-сервера — фронт видит их так же, как видел бы из облака;
+ *   мастер → фронт:  request:<event>:<id> (печать через терминал) — адресный запрос к своему
+ *                    фронту, ответ уходит мастеру как response:<event>:<id>;
+ *   фронт → мастер:  клиентские бродкасты фронта (orders:closing…) уходят мастеру, а он
+ *                    раздаёт их остальным терминалам зала.
+ *
+ * Мост подключается с terminal_id этого терминала: так мастер находит его по terminalId,
+ * когда нужно напечатать на принтере, подключённом к этой кассе.
+ */
+const REQUEST_TIMEOUT_MS = Number(process.env.OFFLINE_BRIDGE_REQUEST_TIMEOUT_MS || 120000);
+
+const findSocket = (server, terminalId) => {
+    if (!server) {
+        return null;
+    }
+    for (const socket of server.sockets.sockets.values()) {
+        if (socket.terminalId === terminalId && !socket.isProxy) {
+            return socket;
+        }
+    }
+    return null;
+};
+
+/** Запасной вариант адресного запроса, если app/socket/request.js ещё нет. */
+const fallbackRequest = ({terminalId, eventName, data, requestId, timeout}) => new Promise((resolve) => {
+    const server = require('../socket/server')();
+    const socket = findSocket(server, terminalId);
+    if (!socket) {
+        resolve({success: false, message: 'No socket'});
+        return;
+    }
+    const responseEvent = `response:${eventName}:${requestId}`;
+    let done = false;
+    const timer = setTimeout(() => {
+        if (!done) {
+            done = true;
+            socket.off(responseEvent, onResponse);
+            resolve({success: false, message: 'Timeout error'});
+        }
+    }, timeout);
+    const onResponse = (payload) => {
+        if (!done) {
+            done = true;
+            clearTimeout(timer);
+            resolve(payload);
+        }
+    };
+    socket.once(responseEvent, onResponse);
+    socket.emit(`request:${eventName}:${requestId}`, data);
+});
+
+const localRequest = (options) => {
+    try {
+        const module_ = require('../socket/request');
+        if (module_ && typeof module_.socketRequest === 'function') {
+            return module_.socketRequest(options);
+        }
+    } catch (e) {
+        if (e.code !== 'MODULE_NOT_FOUND') {
+            throw e;
+        }
+    }
+    return fallbackRequest(options);
+};
+
+class MasterBridge {
+    /**
+     * @param {{masterUrl: string, session: object, isRelaying: () => boolean}} options
+     *   isRelaying — пересылать ли бродкасты: только пока фронт работает через локальный Node,
+     *   в облачном режиме он получает их из облака, и копия от мастера была бы дублем.
+     */
+    constructor({masterUrl, session, isRelaying}) {
+        this.masterUrl = masterUrl;
+        this.session = session;
+        this.isRelaying = isRelaying;
+        this.socket = null;
+    }
+
+    get connected() {
+        return Boolean(this.socket && this.socket.connected);
+    }
+
+    start() {
+        if (this.socket || !this.session.company_id) {
+            return this;
+        }
+        this.socket = io(this.masterUrl, {
+            query: {
+                company_id: this.session.company_id,
+                terminal_id: this.session.terminal_id || '',
+                is_proxy_server: 'true',
+            },
+            auth: lanKey() ? {lan_key: lanKey()} : {},
+            reconnection: true,
+            reconnectionDelay: 1000,
+            reconnectionDelayMax: 5000,
+        });
+
+        this.socket.onAny((eventName, ...args) => {
+            if (eventName.startsWith('request:')) {
+                this.handleRequest(eventName, args[0]).catch((e) => {
+                    console.error('[sync] bridge request failed:', e.message);
+                });
+                return;
+            }
+            if (eventName.startsWith('response:') || !this.isRelaying()) {
+                return;
+            }
+            const server = require('../socket/server')();
+            if (server) {
+                server.to(this.session.company_id).emit(eventName, ...args);
+            }
+        });
+        return this;
+    }
+
+    async handleRequest(eventName, data) {
+        const rest = eventName.slice('request:'.length);
+        const separator = rest.lastIndexOf(':');
+        if (separator <= 0) {
+            return;
+        }
+        const name = rest.slice(0, separator);
+        const requestId = rest.slice(separator + 1);
+        const result = await localRequest({
+            terminalId: this.session.terminal_id,
+            eventName: name,
+            data,
+            requestId,
+            timeout: REQUEST_TIMEOUT_MS,
+        });
+        if (this.socket) {
+            this.socket.emit(`response:${name}:${requestId}`, result);
+        }
+    }
+
+    /** Клиентский бродкаст фронта → мастеру (он раздаст его остальным терминалам). */
+    forward(eventName, ...args) {
+        if (this.connected && this.isRelaying()) {
+            this.socket.emit(eventName, ...args);
+        }
+    }
+
+    stop() {
+        if (this.socket) {
+            this.socket.offAny();
+            this.socket.removeAllListeners();
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+}
+
+module.exports = {MasterBridge, localRequest};

package/app/sync/cloud.js

@@ -0,0 +1,120 @@
+const axios = require('axios');
+const http = require('node:http');
+const https = require('node:https');
+const {healthPath, timeouts, stripSlash} = require('./config');
+
+/**
+ * HTTP-клиент синка к облаку. Ходит от имени терминала (сессия из POST /local/session) —
+ * те же заголовки, что шлёт фронт, поэтому Laravel видит обычный запрос кассы.
+ *
+ * Каждый ответ — сигнал о связи для монитора: нет ответа или 5xx — провал, любой другой
+ * ответ — связь есть (даже 4xx: облако живо, просто запрос ему не понравился).
+ */
+const httpAgent = new http.Agent({keepAlive: true, maxSockets: 8});
+const httpsAgent = new https.Agent({keepAlive: true, maxSockets: 8});
+
+/** Сеть/таймаут/5xx: облако недоступно, операцию надо повторить позже. */
+class CloudUnavailable extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CloudUnavailable';
+    }
+}
+
+/** Облако ответило 4xx: связь есть, но запрос отвергнут. */
+class CloudRequestError extends Error {
+    constructor(event, status, body) {
+        super(`${event}: HTTP ${status}${body && body.message ? ` ${body.message}` : ''}`);
+        this.name = 'CloudRequestError';
+        this.status = status;
+        this.body = body;
+    }
+}
+
+// Старый облачный Node при упавшем Laravel отвечает 200 с таким телом (см. app/proxy.js).
+const isBadGateway = (data) => Boolean(data && typeof data === 'object' && data.error === 'Bad Gateway');
+
+/** api_url фронта бывает и с хвостом /api — приводим к адресу хоста. */
+const normalizeApiUrl = (url) => stripSlash(url).replace(/\/api$/, '');
+
+class CloudClient {
+    constructor(session, {onLink = null} = {}) {
+        this.session = session;
+        this.onLink = onLink || (() => {});
+    }
+
+    get baseUrl() {
+        return normalizeApiUrl(this.session.api_url);
+    }
+
+    headers(extra = {}) {
+        const session = this.session;
+        const headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            timestamp: String(Math.floor(Date.now() / 1000)),
+        };
+        if (session.token) {
+            headers.Authorization = `Bearer ${session.token}`;
+        }
+        if (session.team_id) {
+            headers['team-id'] = session.team_id;
+        }
+        if (session.company_id) {
+            headers['company-id'] = session.company_id;
+        }
+        if (session.terminal_id) {
+            headers['terminal-id'] = session.terminal_id;
+        }
+        if (session.employee_id) {
+            headers['employee-id'] = session.employee_id;
+        }
+        return {...headers, ...extra};
+    }
+
+    async call(event, data = {}, {timeout = timeouts().api, idempotencyKey = null} = {}) {
+        let response;
+        try {
+            response = await axios.post(`${this.baseUrl}/api/${event}`, data, {
+                headers: this.headers(idempotencyKey ? {'Idempotency-Key': idempotencyKey} : {}),
+                timeout,
+                validateStatus: () => true,
+                httpAgent,
+                httpsAgent,
+            });
+        } catch (e) {
+            this.onLink(false, `${event}: ${e.code || e.message}`);
+            throw new CloudUnavailable(`${event}: ${e.code || e.message}`);
+        }
+
+        if (response.status >= 500 || isBadGateway(response.data)) {
+            this.onLink(false, `${event}: HTTP ${response.status}`);
+            throw new CloudUnavailable(`${event}: HTTP ${response.status}`);
+        }
+        this.onLink(true);
+        if (response.status >= 400) {
+            throw new CloudRequestError(event, response.status, response.data);
+        }
+        return response.data;
+    }
+
+    /** Проверка связи. Через облачный Node /up доходит до Laravel — проверяется весь путь. */
+    async health() {
+        try {
+            const response = await axios.get(`${this.baseUrl}${healthPath()}`, {
+                timeout: timeouts().health,
+                validateStatus: () => true,
+                httpAgent,
+                httpsAgent,
+            });
+            const ok = response.status < 500 && !isBadGateway(response.data);
+            this.onLink(ok, ok ? null : `health: HTTP ${response.status}`);
+            return ok;
+        } catch (e) {
+            this.onLink(false, `health: ${e.code || e.message}`);
+            return false;
+        }
+    }
+}
+
+module.exports = {CloudClient, CloudUnavailable, CloudRequestError, normalizeApiUrl, isBadGateway};