@alizadefaig/pos-server 1.2.26 → 1.2.28

package/app/core/support/unlock.js

@@ -0,0 +1,113 @@
+const {createHmac, timingSafeEqual} = require('node:crypto');
+const {HttpError} = require('../errors');
+const {toBool} = require('./num');
+
+/**
+ * Проверка PIN сотрудника на кассе без облака: офлайн-`auth.unlock` (routes/desktop/api/offline.js)
+ * и возврат на кассу после выхода терминала (app/sync `resume`). Источник — список `users` из
+ * blob app.init, который привозит снапшот.
+ */
+
+/**
+ * Перебор PIN на кассе (4 цифры — 10 000 вариантов). Считаются только неудачи, ключ —
+ * команда + терминал. OFFLINE_UNLOCK_MAX_ATTEMPTS=0 выключает, как и UNLOCK_MAX_ATTEMPTS в Laravel.
+ * Один счётчик на оба входа: возврат на кассу не даёт обойти лимит блокировки.
+ */
+const unlockThrottle = (() => {
+    const attempts = new Map();
+    const limit = () => {
+        const value = Number(process.env.OFFLINE_UNLOCK_MAX_ATTEMPTS);
+        return Number.isFinite(value) && value >= 0 ? value : 10;
+    };
+    const decayMs = () => (Number(process.env.OFFLINE_UNLOCK_DECAY_SECONDS) || 60) * 1000;
+    const entry = (key) => {
+        const current = attempts.get(key);
+        if (current && current.until > Date.now()) {
+            return current;
+        }
+        attempts.delete(key);
+        return null;
+    };
+    return {
+        assertAllowed(key) {
+            const current = entry(key);
+            if (limit() > 0 && current && current.count >= limit()) {
+                const retryAfter = Math.max(1, Math.ceil((current.until - Date.now()) / 1000));
+                throw new HttpError(429, {
+                    success: false,
+                    error_code: 'too_many_attempts',
+                    message: 'Çox cəhd edildi, bir az gözləyin',
+                    retry_after: retryAfter,
+                });
+            }
+        },
+        fail(key) {
+            if (limit() <= 0) {
+                return;
+            }
+            const current = entry(key) || {count: 0, until: Date.now() + decayMs()};
+            current.count += 1;
+            attempts.set(key, current);
+        },
+        reset(key) {
+            attempts.delete(key);
+        },
+    };
+})();
+
+/**
+ * Роль «владелец» (roles.is_owner) — точное условие TeamUserService::unlock. В blob app.init
+ * её нет (там is_owner = «владелец команды»), поэтому смотрим локальный справочник ролей и
+ * только без него падаем на поле ресурса. `db.get` может быть и синхронным (store синка).
+ */
+const roleIsOwner = async (db, user) => {
+    if (!user.role_id) {
+        return toBool(user.is_owner);
+    }
+    try {
+        const role = await db.get('SELECT is_owner FROM roles WHERE id = ?', [user.role_id]);
+        return role ? toBool(role.is_owner) : toBool(user.is_owner);
+    } catch (e) {
+        return toBool(user.is_owner);
+    }
+};
+
+const filled = (value) => value !== null && value !== undefined && value !== '';
+
+/**
+ * Laravel с USER_PIN_EXPOSURE=hash отдаёт вместо PIN и карты HMAC-SHA256 с солью команды
+ * (pin_salt в корне init-ответа). Сравниваем хеш введённого кода; открытые поля — старый режим.
+ */
+const codeHash = (salt, value) => createHmac('sha256', String(salt)).update(value).digest('hex');
+
+const hashMatches = (expected, actual) => {
+    if (typeof expected !== 'string' || expected.length !== actual.length) {
+        return false;
+    }
+    return timingSafeEqual(Buffer.from(expected), Buffer.from(actual));
+};
+
+const findUnlockUser = async (db, users, code, salt = null) => {
+    const value = String(code);
+    const hashed = filled(salt) ? codeHash(salt, value) : null;
+    for (const user of users) {
+        if (!user) {
+            continue;
+        }
+        const matches = (filled(user.pin) && String(user.pin) === value)
+            || (filled(user.ic_card) && String(user.ic_card) === value)
+            || (hashed !== null && (hashMatches(user.pin_hash, hashed) || hashMatches(user.ic_card_hash, hashed)));
+        if (!matches) {
+            continue;
+        }
+        if (toBool(user.can_work_with_terminal) || await roleIsOwner(db, user)) {
+            return user;
+        }
+    }
+    return null;
+};
+
+/** Ключ счётчика неудач: команда + терминал. */
+const throttleKey = (teamId, terminalId) => `${teamId || ''}|${terminalId || ''}`;
+
+module.exports = {unlockThrottle, findUnlockUser, throttleKey};

package/app/core/timers.js

@@ -0,0 +1,151 @@
+const {getDatabase} = require('../db/Database');
+const Context = require('./Context');
+const SocketEmitter = require('./emitter');
+const OrderService = require('./services/OrderService');
+const OrderRepository = require('./repositories/OrderRepository');
+const {isEnabled, mode} = require('./index');
+const {Idempotency} = require('./idempotency');
+const syncConfig = require('../sync/config');
+
+/**
+ * Тик повременных позиций — порт цикла `timers:tick` из Laravel.
+ *
+ * Офлайн облако до кассы не достаёт, а цена таймера растёт со временем: без тика терминалы
+ * показывали бы замороженную сумму. Ничего не пишет в БД — только пересчёт в памяти и
+ * батч-патч по компаниям (см. OrderService::tickTimers).
+ *
+ * Облачный контур (CORE_MODE=cloud) тикает только при CORE_TIMERS=true: пока флаг снят, это
+ * делает Laravel `timers:tick`, и два тика дали бы двойные бродкасты. Включать вместе с
+ * остановкой команды Laravel.
+ */
+const TICK_MS = Number(process.env.OFFLINE_TIMER_TICK_MS || 10000);
+
+// Просроченные ключи идемпотентности локальному мастеру убирать некому — чистим редко, чтобы
+// не мешать горячему пути.
+const CLEANUP_EVERY_TICKS = Number(process.env.OFFLINE_IDEMPOTENCY_CLEANUP_TICKS || 100);
+
+// Облако — раз в час и пачками, как cleanupExpiredIdempotencyKeys в Laravel.
+const CLOUD_CLEANUP_EVERY_TICKS = Math.max(1, Math.floor(3600000 / TICK_MS));
+const CLEANUP_CHUNK = 1000;
+
+let handle = null;
+let ticks = 0;
+let running = false;
+
+const cloudTimersEnabled = () => String(process.env.CORE_TIMERS || 'false').toLowerCase() === 'true';
+
+/**
+ * С синком (модель F) тик нужен, только пока фронт работает через локальный Node: в облачном
+ * режиме таймеры тикает облако, а ведомый терминал чеков не держит вовсе — тикает мастер.
+ */
+const tickNeeded = () => {
+    if (mode() === 'cloud') {
+        return cloudTimersEnabled();
+    }
+    if (!syncConfig.isSyncEnabled()) {
+        return true;
+    }
+    if (syncConfig.role() === 'follower') {
+        return false;
+    }
+    return require('../sync').mode() !== 'cloud';
+};
+
+const tickTeam = async (db, teamId, filter) => {
+    const context = new Context({teamId, db});
+    await context.load();
+    const emitter = new SocketEmitter({db, context});
+    return new OrderService({db, context, emitter}).tickTimers(filter);
+};
+
+/**
+ * Облако: у каждой команды свой контекст (сервисный сбор, язык названий в патче). Заведения не в
+ * `online` пропускаются — их чеки тикает мастер-касса (PosModeService::nonOnlineCompanyIds).
+ * Сбой одной команды не останавливает остальные.
+ */
+const tickCloud = async (db) => {
+    const skipCompanyIds = await require('./auth/posMode').nonOnlineCompanyIds(db);
+    const teamIds = await new OrderRepository(db, new Context({db})).teamsWithRunningTimers();
+    for (const teamId of teamIds) {
+        try {
+            await tickTeam(db, teamId, {teamId, skipCompanyIds});
+        } catch (e) {
+            console.error('timers:tick error:', e.message);
+        }
+    }
+    return true;
+};
+
+const tick = async () => {
+    const db = await getDatabase();
+    if (mode() === 'cloud') {
+        return tickCloud(db);
+    }
+    // Локальная установка обслуживает одну команду — её язык нужен только для локализации
+    // названий в патче.
+    const team = await db.get('SELECT id FROM teams LIMIT 1');
+    return tickTeam(db, team ? team.id : null);
+};
+
+const cleanupIdempotency = async () => {
+    const db = await getDatabase();
+    const idempotency = new Idempotency(db);
+    if (mode() !== 'cloud') {
+        return idempotency.cleanup();
+    }
+    let total = 0;
+    let deleted;
+    do {
+        deleted = await idempotency.cleanup(CLEANUP_CHUNK);
+        total += deleted;
+    } while (deleted >= CLEANUP_CHUNK);
+    if (total > 0) {
+        console.info(`idempotency cleanup: deleted ${total} expired keys`);
+    }
+    return total;
+};
+
+const cleanupDue = () => {
+    if (mode() === 'local') {
+        return ticks % CLEANUP_EVERY_TICKS === 0;
+    }
+    return cloudTimersEnabled() && ticks % CLOUD_CLEANUP_EVERY_TICKS === 0;
+};
+
+const startTimerTicker = () => {
+    if (!isEnabled() || handle) {
+        return null;
+    }
+    handle = setInterval(() => {
+        // Тик асинхронный: ошибку ловим через .catch, иначе получим unhandled rejection
+        // и, в свежих Node, падение процесса.
+        // В облаке тик по всем командам может не уложиться в интервал — следующий ждёт.
+        if (tickNeeded() && !running) {
+            running = true;
+            tick()
+                .catch((e) => console.error('[core] timers tick failed:', e.message))
+                .finally(() => {
+                    running = false;
+                });
+        }
+
+        ticks += 1;
+        if (cleanupDue()) {
+            cleanupIdempotency().catch((e) => console.error('[core] idempotency cleanup failed:', e.message));
+        }
+    }, TICK_MS);
+    // Не держим процесс живым ради тика.
+    if (handle.unref) {
+        handle.unref();
+    }
+    return handle;
+};
+
+const stopTimerTicker = () => {
+    if (handle) {
+        clearInterval(handle);
+        handle = null;
+    }
+};
+
+module.exports = {startTimerTicker, stopTimerTicker, tick, cleanupIdempotency};

package/app/db/Database.js

@@ -1,6 +1,202 @@
+const {join} = require('node:path');
+const {mkdirSync, existsSync, chmodSync} = require('node:fs');
+const os = require('node:os');
+
+const {openDriver, getDriverName} = require('./driver');
+const {migrate} = require('./Migrator');
+
+/**
+ * StorageAdapter ядра — единственная точка доступа к БД.
+ *
+ * Два контура, один слой:
+ *   CORE_DB=pgsql  — облако, общая база с Laravel (схему ведут его миграции);
+ *   CORE_DB=sqlite — локальный мастер, схему ведут локальные миграции из ./migrations.
+ *
+ * Правило из OFFLINE-FIRST-PLAN §5: SQL пишем чистый, без ORM-специфики. Диалектные отличия
+ * (плейсхолдеры, типы) снимает driver.js, здесь — только тонкие хелперы над query/run.
+ */
+/**
+ * Файл базы и его WAL-спутники — только владельцу (0600). На Windows chmod почти ничего не
+ * делает, там каталог и так в профиле пользователя (%APPDATA%). Ошибка прав — не повод не
+ * стартовать кассу.
+ */
+const restrictFile = (file) => {
+    if (!file || file === ':memory:') {
+        return;
+    }
+    for (const path of [file, `${file}-wal`, `${file}-shm`]) {
+        try {
+            if (existsSync(path)) {
+                chmodSync(path, 0o600);
+            }
+        } catch (e) {
+            // права не поменялись — работаем как раньше
+        }
+    }
+};
+
 class Database {
-    constructor() {
+    constructor(options = {}) {
+        const dialect = options.dialect || Database.defaultDialect();
+        this.dialect = dialect === 'postgres' ? 'pgsql' : dialect;
+        this.file = this.dialect === 'sqlite' ? (options.file || Database.defaultFile()) : null;
+        this.driver = null;
+        this.connecting = null;
+    }
+
+    static defaultDialect() {
+        const value = (process.env.CORE_DB || 'sqlite').toLowerCase();
+        return value === 'postgres' ? 'pgsql' : value;
+    }
+
+    static defaultFile() {
+        if (process.env.CAFEPOS_DB_FILE) {
+            return process.env.CAFEPOS_DB_FILE;
+        }
+        const dir = process.env.CAFEPOS_DATA_DIR || join(os.homedir(), '.cafepos');
+        if (!existsSync(dir)) {
+            // В базе PIN сотрудников, чеки и токен синка — только владельцу процесса.
+            mkdirSync(dir, {recursive: true, mode: 0o700});
+        }
+        return join(dir, 'pos.sqlite');
+    }
+
+    /** Идемпотентно и безопасно при параллельных вызовах: соединение поднимается один раз. */
+    async connect() {
+        if (this.driver) {
+            return this;
+        }
+        if (!this.connecting) {
+            this.connecting = this.open();
+        }
+        await this.connecting;
+        return this;
+    }
+
+    async open() {
+        const driver = openDriver({dialect: this.dialect, file: this.file});
+
+        if (this.dialect === 'sqlite') {
+            // WAL — читатели не блокируют писателя: терминалы читают заказы, пока касса пишет.
+            // busy_timeout — вместо мгновенного SQLITE_BUSY ждём до 5с.
+            await driver.exec('PRAGMA journal_mode = WAL;');
+            await driver.exec('PRAGMA foreign_keys = ON;');
+            await driver.exec('PRAGMA busy_timeout = 5000;');
+            restrictFile(this.file);
+        }
+
+        this.driver = driver;
+
+        // В облаке схему ведёт Laravel — свои миграции там не запускаем никогда.
+        if (this.dialect === 'sqlite') {
+            await migrate(this);
+        }
+        return this;
+    }
+
+    driverName() {
+        return getDriverName();
+    }
+
+    /** Подключение обязано быть поднято: connect() зовётся один раз на старте контекста. */
+    connection() {
+        if (!this.driver) {
+            throw new Error('Database is not connected: await db.connect() first');
+        }
+        return this.driver;
+    }
+
+    async exec(sql) {
+        await this.connection().exec(sql);
+        return this;
+    }
+
+    async all(sql, params = []) {
+        return this.connection().query(sql, params);
+    }
+
+    async get(sql, params = []) {
+        const rows = await this.connection().query(sql, params);
+        return rows.length ? rows[0] : null;
+    }
+
+    async run(sql, params = []) {
+        return this.connection().run(sql, params);
+    }
+
+    async value(sql, params = []) {
+        const row = await this.get(sql, params);
+        if (!row) {
+            return null;
+        }
+        const keys = Object.keys(row);
+        return keys.length ? row[keys[0]] : null;
+    }
+
+    async insert(table, data) {
+        const columns = Object.keys(data);
+        const placeholders = columns.map(() => '?').join(', ');
+        await this.run(
+            `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`,
+            columns.map((column) => data[column])
+        );
+        return data.id ?? null;
+    }
+
+    async update(table, id, data) {
+        const columns = Object.keys(data);
+        if (!columns.length) {
+            return 0;
+        }
+        const assignments = columns.map((column) => `${column} = ?`).join(', ');
+        const result = await this.run(
+            `UPDATE ${table} SET ${assignments} WHERE id = ?`,
+            [...columns.map((column) => data[column]), id]
+        );
+        return result?.changes ?? 0;
+    }
+
+    /**
+     * Транзакция. Колбэк получает Database, привязанную к тому же соединению
+     * (в pg это выделенный клиент из пула — иначе BEGIN и запросы уедут в разные соединения).
+     */
+    async transaction(callback) {
+        return this.connection().transaction(async (scopedDriver) => {
+            const scoped = Object.create(Database.prototype);
+            scoped.dialect = this.dialect;
+            scoped.file = this.file;
+            scoped.driver = scopedDriver;
+            scoped.connecting = null;
+            return callback(scoped);
+        });
+    }
+
+    async close() {
+        if (this.driver) {
+            await this.driver.close();
+            this.driver = null;
+            this.connecting = null;
+        }
     }
 }
 
+let instance = null;
+
+/** Один пул/соединение на процесс. Возвращает уже подключённую БД. */
+const getDatabase = async () => {
+    if (!instance) {
+        instance = new Database();
+    }
+    await instance.connect();
+    return instance;
+};
+
+const setDatabase = (database) => {
+    instance = database;
+    return instance;
+};
+
 module.exports = Database;
+module.exports.Database = Database;
+module.exports.getDatabase = getDatabase;
+module.exports.setDatabase = setDatabase;

package/app/db/Migrator.js

@@ -0,0 +1,45 @@
+const {readdirSync, readFileSync} = require('node:fs');
+const {join, extname} = require('node:path');
+
+const MIGRATIONS_DIR = join(__dirname, 'migrations');
+
+/**
+ * Локальные миграции — обычные .sql-файлы, применяются по возрастанию имени ровно один раз.
+ *
+ * Только для локального контура (SQLite). В облаке схему ведёт Laravel: там ядро пишет
+ * в ту же базу, и своя миграция означала бы две системы записи схемы.
+ */
+const migrate = async (database) => {
+    await database.exec(`
+        CREATE TABLE IF NOT EXISTS _migrations (
+            name       TEXT PRIMARY KEY,
+            applied_at TEXT NOT NULL
+        );
+    `);
+
+    const rows = await database.all('SELECT name FROM _migrations');
+    const applied = new Set(rows.map((row) => row.name));
+
+    const files = readdirSync(MIGRATIONS_DIR)
+        .filter((name) => extname(name) === '.sql')
+        .sort();
+
+    for (const file of files) {
+        if (applied.has(file)) {
+            continue;
+        }
+        const sql = readFileSync(join(MIGRATIONS_DIR, file), 'utf8');
+        await database.transaction(async (tx) => {
+            await tx.exec(sql);
+            await tx.run('INSERT INTO _migrations (name, applied_at) VALUES (?, ?)', [
+                file,
+                new Date().toISOString(),
+            ]);
+        });
+        console.log(`[db] migration applied: ${file}`);
+    }
+
+    return files.length;
+};
+
+module.exports = {migrate, MIGRATIONS_DIR};