@alizadefaig/pos-server 1.2.26 → 1.2.27

package/app/core/auth/sanctum.js

@@ -0,0 +1,209 @@
+const crypto = require('crypto');
+const zlib = require('zlib');
+
+const {nowSql, parse, now} = require('../support/time');
+
+/**
+ * Проверка токена терминала — порт guard'а Laravel Sanctum (`auth:sanctum` на `/api/{event}`).
+ *
+ * Токен выпускает Laravel (`createToken`): в таблицу ложится sha256 от случайной строки, клиенту
+ * уходит `<id>|<строка>`. Здесь та же проверка по той же таблице, поэтому один и тот же токен
+ * принимают и Laravel, и Node — событие можно возить между ними без перелогина касс.
+ */
+const USER_MODEL = 'App\\Models\\User';
+
+// Sanctum пишет last_used_at на каждый запрос. Касса шлёт десятки запросов в минуту, а это поле
+// читает только выбор свежих токенов для мастера зала (sync.lanDevices) — минуты хватает.
+const TOUCH_EVERY_MS = () => Number(process.env.CORE_TOKEN_TOUCH_MS ?? 60000);
+const TOUCH_LIMIT = 20000;
+const touched = new Map(); // token id → когда писали last_used_at
+
+// bigint Postgres вмещает 19 цифр; длиннее — Laravel упал бы на запросе (500), мы просто
+// не узнаём токен.
+const MAX_ID_DIGITS = 18;
+
+const header = (headers, name) => {
+    if (!headers) {
+        return null;
+    }
+    if (headers[name] !== undefined) {
+        return headers[name];
+    }
+    const found = Object.keys(headers).find((key) => key.toLowerCase() === name);
+    return found ? headers[found] : null;
+};
+
+/** Request::bearerToken(): последнее вхождение «Bearer » без учёта регистра, до первой запятой. */
+const bearerToken = (headers) => {
+    const raw = header(headers, 'authorization');
+    if (typeof raw !== 'string') {
+        return null;
+    }
+    const position = raw.toLowerCase().lastIndexOf('bearer ');
+    if (position === -1) {
+        return null;
+    }
+    const value = raw.slice(position + 7);
+    const comma = value.indexOf(',');
+    return comma === -1 ? value : value.slice(0, comma);
+};
+
+// PHP empty(): '' и '0' — пусто.
+const phpEmpty = (value) => value === '' || value === '0';
+
+/** Guard::isValidBearerToken — у модели целочисленный ключ. */
+const isValidFormat = (token) => {
+    if (token === null || token === undefined) {
+        return false;
+    }
+    const bar = token.indexOf('|');
+    if (bar === -1) {
+        return !phpEmpty(token);
+    }
+    const id = token.slice(0, bar);
+    return /^\d+$/.test(id) && !phpEmpty(token.slice(bar + 1));
+};
+
+const sha256 = (value) => crypto.createHash('sha256').update(value).digest('hex');
+
+const sameHash = (stored, computed) => {
+    if (typeof stored !== 'string' || stored.length !== computed.length) {
+        return false;
+    }
+    return crypto.timingSafeEqual(Buffer.from(stored), Buffer.from(computed));
+};
+
+const TOKEN_SQL = `
+    SELECT t.id, t.token, t.expires_at, t.terminal_id, t.tokenable_type, u.id AS user_id
+      FROM personal_access_tokens t
+      LEFT JOIN users u ON u.id = t.tokenable_id AND t.tokenable_type = ? AND u.deleted_at IS NULL`;
+
+/** PersonalAccessToken::findToken + владелец токена одним запросом. */
+const findToken = async (db, token) => {
+    const bar = token.indexOf('|');
+    if (bar === -1) {
+        return db.get(`${TOKEN_SQL} WHERE t.token = ?`, [USER_MODEL, sha256(token)]);
+    }
+    const id = token.slice(0, bar);
+    if (id.length > MAX_ID_DIGITS) {
+        return null;
+    }
+    const row = await db.get(`${TOKEN_SQL} WHERE t.id = ?`, [USER_MODEL, Number(id)]);
+    return row && sameHash(row.token, sha256(token.slice(bar + 1))) ? row : null;
+};
+
+const expired = (expiresAt) => {
+    if (expiresAt === null || expiresAt === undefined || expiresAt === '') {
+        return false;
+    }
+    const at = parse(expiresAt);
+    return Boolean(at) && at.getTime() < now().getTime();
+};
+
+const touch = (db, id) => {
+    const at = Date.now();
+    const last = touched.get(id);
+    if (last !== undefined && at - last < TOUCH_EVERY_MS()) {
+        return;
+    }
+    if (touched.size >= TOUCH_LIMIT) {
+        touched.clear();
+    }
+    touched.set(id, at);
+    const stamp = nowSql();
+    // Не ждём: запись отметки не должна задерживать сам запрос.
+    db.run('UPDATE personal_access_tokens SET last_used_at = ?, updated_at = ? WHERE id = ?', [stamp, stamp, id])
+        .catch((e) => console.warn('[core-auth] last_used_at:', e.message));
+};
+
+/**
+ * @returns {Promise<null|{userId: string, tokenId: number, tokenTerminalId: string|null, plain: string}>}
+ *          null — Laravel ответил бы 401 {"message":"Unauthenticated."}
+ */
+const authenticate = async (db, headers) => {
+    const token = bearerToken(headers);
+    if (!isValidFormat(token)) {
+        return null;
+    }
+    const row = await findToken(db, token);
+    if (!row || !row.user_id || expired(row.expires_at)) {
+        return null;
+    }
+    const id = Number(row.id);
+    touch(db, id);
+    const terminal = row.terminal_id;
+    return {
+        userId: String(row.user_id),
+        tokenId: id,
+        tokenTerminalId: typeof terminal === 'string' && terminal !== '' ? terminal : null,
+        plain: token,
+    };
+};
+
+// ------------------------------------------------------------ выпуск и отзыв (app.auth, logoutApp)
+
+const ALPHANUMERIC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+/** Str::random(40): буквы и цифры из CSPRNG. */
+const randomString = (length) => {
+    let result = '';
+    for (let i = 0; i < length; i += 1) {
+        result += ALPHANUMERIC[crypto.randomInt(ALPHANUMERIC.length)];
+    }
+    return result;
+};
+
+let crcTable = null;
+const crc32Fallback = (value) => {
+    if (!crcTable) {
+        crcTable = new Int32Array(256);
+        for (let n = 0; n < 256; n += 1) {
+            let c = n;
+            for (let k = 0; k < 8; k += 1) {
+                c = c & 1 ? 0xEDB88320 ^ (c >>> 1) : c >>> 1;
+            }
+            crcTable[n] = c;
+        }
+    }
+    let crc = -1;
+    for (const byte of Buffer.from(value)) {
+        crc = crcTable[(crc ^ byte) & 0xFF] ^ (crc >>> 8);
+    }
+    return (crc ^ -1) >>> 0;
+};
+
+/** hash('crc32b', …) PHP — 8 hex-символов в нижнем регистре. zlib.crc32 есть с Node 20.15/22.2. */
+const crc32b = (value) => {
+    const sum = typeof zlib.crc32 === 'function' ? zlib.crc32(value) : crc32Fallback(value);
+    return sum.toString(16).padStart(8, '0');
+};
+
+/**
+ * HasApiTokens::createToken(name) Sanctum 4: строка `<SANCTUM_TOKEN_PREFIX><40 символов><crc32b>`,
+ * в таблицу — sha256 от неё целиком, abilities `["*"]`, без срока. Такой токен принимает и
+ * guard Laravel, и `authenticate` выше.
+ *
+ * @returns {Promise<{id: number, plainTextToken: string}>}
+ */
+const issue = async (db, userId, name = 'terminal') => {
+    const entropy = randomString(40);
+    const plain = `${process.env.SANCTUM_TOKEN_PREFIX || ''}${entropy}${crc32b(entropy)}`;
+    const stamp = nowSql();
+    const row = await db.get(
+        `INSERT INTO personal_access_tokens
+            (tokenable_type, tokenable_id, name, token, abilities, expires_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         RETURNING id`,
+        [USER_MODEL, userId, name, sha256(plain), '["*"]', null, stamp, stamp]
+    );
+    const id = Number(row.id);
+    return {id, plainTextToken: `${id}|${plain}`};
+};
+
+/** currentAccessToken()->delete(). */
+const revoke = async (db, tokenId) => {
+    touched.delete(Number(tokenId));
+    await db.run('DELETE FROM personal_access_tokens WHERE id = ?', [Number(tokenId)]);
+};
+
+module.exports = {authenticate, bearerToken, isValidFormat, sha256, header, issue, revoke, crc32b, _touched: touched};

package/app/core/auth/scope.js

@@ -0,0 +1,231 @@
+const crypto = require('crypto');
+
+/**
+ * Принадлежность заголовков токену — порт App\Services\Platform\PlatformScope.
+ *
+ * Токен говорит, КТО пришёл; заголовки team-id/company-id/terminal-id/employee-id — ОТ ЧЬЕГО
+ * имени он действует. Без сверки любой живой токен работал бы с чужой командой.
+ *
+ * PLATFORM_SCOPE_CHECK: off (по умолчанию, как сегодня) → log (только предупреждение) → enforce (403).
+ * Причины, тексты и форма ответов — как у Laravel.
+ */
+const MODE_OFF = 'off';
+const MODE_LOG = 'log';
+const MODE_ENFORCE = 'enforce';
+
+const REASON_TEAM = 'team';
+const REASON_COMPANY = 'company';
+const REASON_TERMINAL = 'terminal';
+const REASON_EMPLOYEE = 'employee';
+const REASON_TOKEN_TERMINAL = 'token_terminal';
+
+const ERROR_CODE = 'scope_mismatch';
+const DENY_MESSAGE = 'Giriş icazəsi yoxdur';
+
+// Эти события и переключают терминал токена: сверять старую привязку с новым терминалом нельзя.
+const TERMINAL_SWITCH_EVENTS = new Set(['auth.loginTerminal', 'app.loginTerminal']);
+const CHECK_EVENT = 'auth.check';
+
+const CACHE_LIMIT = 20000;
+const okCache = new Map(); // ключ → истекает (мс)
+const logged = new Map();
+
+const mode = () => {
+    const value = String(process.env.PLATFORM_SCOPE_CHECK ?? MODE_OFF).trim().toLowerCase();
+    return value === MODE_LOG || value === MODE_ENFORCE ? value : MODE_OFF;
+};
+
+const ttlMs = () => {
+    const seconds = parseInt(process.env.PLATFORM_SCOPE_CACHE_TTL ?? '60', 10);
+    return Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : 0;
+};
+
+/** '', 'null', 'undefined' и не-строки — «заголовка нет». */
+const value = (raw) => {
+    if (typeof raw !== 'string') {
+        return null;
+    }
+    const trimmed = raw.trim();
+    return trimmed === '' || trimmed === 'null' || trimmed === 'undefined' ? null : trimmed;
+};
+
+// Str::isUuid: любой uuid без проверки версии. Невалидный uuid в where по uuid-колонке
+// Postgres роняет запрос — отсекаем до БД.
+const UUID = /^[\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}$/;
+const isUuid = (raw) => typeof raw === 'string' && UUID.test(raw);
+
+const cacheHas = (map, key) => {
+    const expires = map.get(key);
+    if (expires === undefined) {
+        return false;
+    }
+    if (expires <= Date.now()) {
+        map.delete(key);
+        return false;
+    }
+    return true;
+};
+
+const cachePut = (map, key, ttl) => {
+    if (map.size >= CACHE_LIMIT) {
+        map.clear();
+    }
+    map.set(key, Date.now() + ttl);
+};
+
+const sha1 = (text) => crypto.createHash('sha1').update(text).digest('hex');
+
+const exists = async (db, sql, params) => Boolean(await db.get(`SELECT 1 AS ok FROM ${sql} LIMIT 1`, params));
+
+const terminalBelongs = async (db, terminalId, teamId, companyId = null, aliveOnly = false) => {
+    terminalId = value(terminalId);
+    teamId = value(teamId);
+    companyId = value(companyId);
+    if (!isUuid(terminalId) || !isUuid(teamId)) {
+        return false;
+    }
+    if (companyId !== null && !isUuid(companyId)) {
+        return false;
+    }
+    let sql = 'terminals WHERE id = ? AND team_id = ?';
+    const params = [terminalId, teamId];
+    if (companyId !== null) {
+        sql += ' AND company_id = ?';
+        params.push(companyId);
+    }
+    if (aliveOnly) {
+        sql += ' AND deleted_at IS NULL';
+    }
+    return exists(db, sql, params);
+};
+
+const resolve = async (db, {userId, teamId, companyId, terminalId, employeeId, tokenTerminalId, withTokenTerminal}) => {
+    // Член команды — живая строка team_users или владелец команды.
+    const isMember = await exists(db, 'team_users WHERE team_id = ? AND user_id = ? AND deleted_at IS NULL', [teamId, userId])
+        || await exists(db, 'teams WHERE id = ? AND user_id = ? AND deleted_at IS NULL', [teamId, userId]);
+    if (!isMember) {
+        return REASON_TEAM;
+    }
+
+    // Компания, терминал и сотрудник сверяются вместе с удалёнными строками своей команды:
+    // касса с устаревшим заголовком должна хотя бы разблокироваться и получить свежий init.
+    if (companyId !== null) {
+        const belongs = isUuid(companyId) && await exists(db, 'companies WHERE id = ? AND team_id = ?', [companyId, teamId]);
+        if (!belongs) {
+            return REASON_COMPANY;
+        }
+    }
+
+    if (terminalId !== null && !await terminalBelongs(db, terminalId, teamId, companyId)) {
+        return REASON_TERMINAL;
+    }
+
+    if (employeeId !== null) {
+        const belongs = isUuid(employeeId) && await exists(db, 'team_users WHERE id = ? AND team_id = ?', [employeeId, teamId]);
+        if (!belongs) {
+            return REASON_EMPLOYEE;
+        }
+    }
+
+    if (withTokenTerminal && tokenTerminalId !== null && terminalId !== null
+        && tokenTerminalId.toLowerCase() !== terminalId.toLowerCase()) {
+        return REASON_TOKEN_TERMINAL;
+    }
+
+    return null;
+};
+
+/**
+ * PlatformScope::check. null — всё сходится, иначе причина.
+ *
+ * @param auth     результат sanctum.authenticate (null — пользователя нет)
+ * @param platform сырые заголовки {teamId, companyId, terminalId, employeeId}
+ */
+const check = async (db, auth, platform, withTokenTerminal = true) => {
+    const teamId = value(platform.teamId);
+    if (!auth || !isUuid(teamId)) {
+        return REASON_TEAM;
+    }
+
+    const companyId = value(platform.companyId);
+    const terminalId = value(platform.terminalId);
+    const employeeId = value(platform.employeeId);
+    const tokenTerminalId = auth.tokenTerminalId;
+
+    const key = sha1([
+        auth.userId,
+        String(auth.tokenId ?? ''),
+        tokenTerminalId ?? '',
+        withTokenTerminal ? '1' : '0',
+        teamId,
+        companyId ?? '',
+        terminalId ?? '',
+        employeeId ?? '',
+    ].join('|'));
+    const ttl = ttlMs();
+    if (ttl > 0 && cacheHas(okCache, key)) {
+        return null;
+    }
+
+    const reason = await resolve(db, {
+        userId: auth.userId, teamId, companyId, terminalId, employeeId, tokenTerminalId, withTokenTerminal,
+    });
+
+    // Кэшируем только «ок»: отказ должен сняться сразу, как только данные поправили.
+    if (reason === null && ttl > 0) {
+        cachePut(okCache, key, ttl);
+    }
+    return reason;
+};
+
+/** PlatformScope::report — одна строка на одинаковое расхождение за TTL. */
+const report = (reason, {event, auth, platform, ip}, reportMode, extra = {}) => {
+    const context = {
+        reason,
+        mode: reportMode,
+        event,
+        user_id: auth ? auth.userId : null,
+        token_id: auth ? auth.tokenId : null,
+        token_terminal_id: auth ? auth.tokenTerminalId : null,
+        team_id: platform.teamId ?? null,
+        company_id: platform.companyId ?? null,
+        terminal_id: platform.terminalId ?? null,
+        employee_id: platform.employeeId ?? null,
+        ip: ip ?? null,
+        ...extra,
+    };
+    const ttl = ttlMs();
+    const json = JSON.stringify(context);
+    if (ttl > 0) {
+        const key = sha1(json);
+        if (cacheHas(logged, key)) {
+            return;
+        }
+        cachePut(logged, key, ttl);
+    }
+    console.warn('[platform-scope] mismatch', json);
+};
+
+const deny = (reason) => ({status: 403, body: {message: DENY_MESSAGE, error_code: ERROR_CODE, reason}});
+
+const checkFailed = (reason) => ({status: 403, body: {ok: false, error_code: ERROR_CODE, reason}});
+
+module.exports = {
+    MODE_OFF,
+    MODE_LOG,
+    MODE_ENFORCE,
+    REASON_TEAM,
+    REASON_TERMINAL,
+    CHECK_EVENT,
+    TERMINAL_SWITCH_EVENTS,
+    mode,
+    value,
+    isUuid,
+    check,
+    report,
+    deny,
+    checkFailed,
+    terminalBelongs,
+    _okCache: okCache,
+    _logged: logged,
+};

package/app/core/emitter.js

@@ -0,0 +1,67 @@
+const {socketSendByFilter} = require('../../utils');
+const syncConfig = require('../sync/config');
+
+/**
+ * Порт SocketService в части бродкаста заказов.
+ *
+ * В Laravel эмит идёт по TCP в Node, который уже раздаёт его в комнату компании. Здесь мы
+ * УЖЕ внутри Node — поэтому зовём socketSendByFilter напрямую, без TCP-петли.
+ *
+ * updateOrders требует список открытых чеков, и строит его сам: OrderService передаёт
+ * эмиттеру только companyId (как и SocketService::updateOrders в Laravel).
+ */
+class SocketEmitter {
+    constructor({db, context, buildOpenOrders = null}) {
+        this.db = db;
+        this.context = context;
+        this.buildOpenOrders = buildOpenOrders;
+    }
+
+    emit(eventName, companyId, data) {
+        if (!companyId) {
+            return;
+        }
+        // Модель M: касса — мастер заведения, часть терминалов работает через облако.
+        // Вне этого режима relayBroadcast ничего не делает.
+        if (syncConfig.isSyncEnabled()) {
+            try {
+                require('../sync').relayBroadcast(eventName, [data]);
+            } catch (e) {
+                console.error('[core] relay broadcast failed:', e.message);
+            }
+        }
+        // Сокет-сервер поднимается вместе с express; если его нет (тесты, ранний старт) —
+        // молча пропускаем бродкаст, мутация уже записана в локальную БД.
+        if (!require('../socket/server')()) {
+            return;
+        }
+        try {
+            socketSendByFilter({companyId: String(companyId), eventName, data});
+        } catch (e) {
+            // Бродкаст не должен ронять мутацию: чек уже записан в локальную БД,
+            // терминал догонит состояние следующим ответом или переподключением.
+            console.error('[core] socket emit failed:', e.message);
+        }
+    }
+
+    orderPatch(companyId, payload) {
+        this.emit('orders:patch', companyId, payload);
+    }
+
+    orderPatchBatch(companyId, patches) {
+        if (!patches || !patches.length) {
+            return;
+        }
+        this.emit('orders:patchBatch', companyId, patches);
+    }
+
+    async updateOrders(companyId) {
+        const target = companyId || this.context.companyId;
+        if (!target || !this.buildOpenOrders) {
+            return;
+        }
+        this.emit('orders:update', target, await this.buildOpenOrders(target));
+    }
+}
+
+module.exports = SocketEmitter;

package/app/core/errors.js

@@ -0,0 +1,18 @@
+/**
+ * Ошибка с готовым HTTP-ответом. Laravel возвращает из сервисов response()->json(...)
+ * с кодом — здесь то же самое, но через исключение, чтобы роут не разбирал тип результата.
+ * `headers` — заголовки ответа (Retry-After у 429), их ставит только HTTP-транспорт.
+ */
+class HttpError extends Error {
+    constructor(status, body, headers = null) {
+        super(typeof body === 'string' ? body : (body && body.message) || `HTTP ${status}`);
+        this.name = 'HttpError';
+        this.status = status;
+        this.body = typeof body === 'string' ? {message: body} : body;
+        this.headers = headers;
+    }
+}
+
+const notFound = (message = 'Not found') => new HttpError(404, {success: false, message});
+
+module.exports = {HttpError, notFound};

package/app/core/guard.js

@@ -0,0 +1,54 @@
+const {HttpError} = require('./errors');
+
+/**
+ * Порт guard закрытого чека (`OrderService::isOrderClosed` / `assertOrderMutable` в Laravel).
+ *
+ * `closing` и `closed` оба значат «деньги уже приняты». closed_at проверяется отдельно: он
+ * ставится раньше финального статуса, и по нему закрытый чек отличим от открытого, даже если
+ * статус застрял промежуточным.
+ *
+ * Формат ответа — байт в байт как у `OrderClosedException::render`: терминал опознаёт его по
+ * `error_code` в теле (Node статус наверх не прокидывает) и убирает чек у себя.
+ */
+const CLOSED_STATUSES = ['closing', 'closed'];
+const ERROR_CODE = 'order_closed';
+const DEFAULT_MESSAGE = 'Bağlanmış çekdə dəyişiklik etmək olmaz. Əvvəlcə çeki geri açın.';
+
+const isOrderClosed = (order) => {
+    if (!order) {
+        return false;
+    }
+    const closedAt = order.closed_at;
+    return (closedAt !== null && closedAt !== undefined && closedAt !== '')
+        || CLOSED_STATUSES.includes(order.status);
+};
+
+const assertOrderMutable = (order, action, message = null, context = null) => {
+    if (!isOrderClosed(order)) {
+        return;
+    }
+
+    // Отклонённую попытку нужно уметь найти постфактум, а не только заблокировать.
+    console.warn('[order-guard] попытка изменить закрытый чек отклонена', JSON.stringify({
+        action,
+        order_id: order.id,
+        order_number: order.number,
+        order_status: order.status,
+        closed_at: order.closed_at,
+        company_id: order.company_id,
+        employee_id: context ? context.employeeId : null,
+        terminal_id: context ? context.terminalId : null,
+    }));
+
+    throw new HttpError(422, {
+        success: false,
+        error_code: ERROR_CODE,
+        message: message || DEFAULT_MESSAGE,
+        action,
+        order_id: order.id,
+        order_status: order.status,
+        closed_at: order.closed_at,
+    });
+};
+
+module.exports = {CLOSED_STATUSES, ERROR_CODE, isOrderClosed, assertOrderMutable};