@onyx-p/imlib-web 3.0.1 → 3.0.2

package/database/worker.cjs

@@ -0,0 +1,592 @@
+'use strict';
+
+var node_worker_threads = require('node:worker_threads');
+var SQL = require('@signalapp/sqlcipher');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var SQL__default = /*#__PURE__*/_interopDefault(SQL);
+
+const READ_METHOD_NAMES = [
+    'getMessages',
+    'getLatestMessage',
+    'getLatestMessages',
+    'getDialogLoadedState',
+    'getMessageById',
+    'getMessageByUId',
+    'getMessageIdRange',
+    'searchMessages',
+    'searchTextMessages',
+    'getLegacyMigrationState'
+];
+const WRITE_METHOD_NAMES = [
+    'addMessages',
+    'clearConversationCache',
+    'clearAllCache',
+    'removeMessagesByUId',
+    'updateMessageReceiptStatus',
+    'clearBurnAfterReadingExpiredMessages',
+    'upsertMessage',
+    'convertToRecallMessages',
+    'importLegacyBatch',
+    'completeLegacyMigration'
+];
+const READ_METHODS = new Set(READ_METHOD_NAMES);
+const WRITE_METHODS = new Set(WRITE_METHOD_NAMES);
+function serializeDatabaseError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+        };
+    }
+    return {
+        name: 'Error',
+        message: String(error),
+        stack: undefined
+    };
+}
+
+const SCHEMA_MIGRATIONS = [
+    {
+        version: 1,
+        up(database) {
+            database.exec(`
+        CREATE TABLE metadata (
+          key TEXT PRIMARY KEY NOT NULL,
+          value TEXT NOT NULL
+        );
+
+        CREATE TABLE messages (
+          messageId INTEGER PRIMARY KEY NOT NULL,
+          messageUId TEXT UNIQUE,
+          dialogId TEXT NOT NULL,
+          sentTime INTEGER NOT NULL,
+          receivedStatus INTEGER,
+          burnAfterReadingFlag INTEGER NOT NULL DEFAULT 0,
+          burnAfterReadingTime INTEGER,
+          messageType INTEGER,
+          json TEXT NOT NULL
+        );
+
+        CREATE TABLE dialog_states (
+          dialogId TEXT PRIMARY KEY NOT NULL,
+          isEnd INTEGER NOT NULL,
+          updateTime INTEGER NOT NULL
+        );
+      `);
+        }
+    },
+    {
+        version: 2,
+        up(database) {
+            database.exec(`
+        CREATE INDEX messages_by_dialog_time
+          ON messages (dialogId, sentTime DESC, messageId DESC);
+        CREATE INDEX messages_by_dialog
+          ON messages (dialogId);
+        CREATE INDEX messages_by_receipt
+          ON messages (receivedStatus);
+        CREATE INDEX messages_by_burn
+          ON messages (dialogId, burnAfterReadingFlag, sentTime);
+      `);
+        }
+    },
+    {
+        version: 3,
+        up(database) {
+            database.exec(`
+        ALTER TABLE messages ADD COLUMN searchText TEXT NOT NULL DEFAULT '';
+
+        CREATE VIRTUAL TABLE messages_fts USING fts5(
+          searchText,
+          content='messages',
+          content_rowid='messageId',
+          tokenize='unicode61'
+        );
+
+        CREATE TRIGGER messages_fts_insert AFTER INSERT ON messages BEGIN
+          INSERT INTO messages_fts(rowid, searchText)
+          VALUES (new.messageId, new.searchText);
+        END;
+
+        CREATE TRIGGER messages_fts_delete AFTER DELETE ON messages BEGIN
+          INSERT INTO messages_fts(messages_fts, rowid, searchText)
+          VALUES ('delete', old.messageId, old.searchText);
+        END;
+
+        CREATE TRIGGER messages_fts_update AFTER UPDATE OF searchText ON messages BEGIN
+          INSERT INTO messages_fts(messages_fts, rowid, searchText)
+          VALUES ('delete', old.messageId, old.searchText);
+          INSERT INTO messages_fts(rowid, searchText)
+          VALUES (new.messageId, new.searchText);
+        END;
+      `);
+        }
+    },
+    {
+        version: 4,
+        up(database) {
+            database.exec(`
+        CREATE INDEX messages_by_search_order
+          ON messages (sentTime DESC, messageId DESC);
+      `);
+        }
+    }
+];
+SCHEMA_MIGRATIONS[SCHEMA_MIGRATIONS.length - 1]?.version ?? 0;
+function validateMigrations(migrations) {
+    let previous = 0;
+    for (const migration of migrations) {
+        if (!Number.isSafeInteger(migration.version) || migration.version <= previous) {
+            throw new Error('Schema migration versions must be strictly increasing');
+        }
+        previous = migration.version;
+    }
+}
+function runMigrations(database, migrations = SCHEMA_MIGRATIONS) {
+    validateMigrations(migrations);
+    const currentVersion = Number(database.pragma('user_version', { simple: true }) ?? 0);
+    const latestVersion = migrations[migrations.length - 1]?.version ?? 0;
+    if (currentVersion > latestVersion) {
+        throw new Error(`Database schema version ${currentVersion} is newer than supported version ${latestVersion}`);
+    }
+    for (const migration of migrations) {
+        if (migration.version <= currentVersion) {
+            continue;
+        }
+        database.transaction(() => {
+            migration.up(database);
+            database.pragma(`user_version = ${migration.version}`);
+        })();
+    }
+}
+
+const LEGACY_MIGRATION_KEY = 'legacy_indexeddb_migration';
+function parseMessage(row) {
+    return row ? JSON.parse(row.json) : null;
+}
+function extractSearchText(message) {
+    const content = message.content;
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (content && typeof content.content === 'string') {
+        return content.content;
+    }
+    return '';
+}
+function normalizeInteger(value, name) {
+    const number = typeof value === 'number' ? value : Number(value);
+    if (!Number.isSafeInteger(number)) {
+        throw new Error(`${name} must be a safe integer`);
+    }
+    return number;
+}
+class MessageStore {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    addMessages(messages, dialogId, isEnd) {
+        const upsert = this.database.prepare(`
+      INSERT INTO messages (
+        messageId, messageUId, dialogId, sentTime, receivedStatus,
+        burnAfterReadingFlag, burnAfterReadingTime, messageType, json, searchText
+      ) VALUES (
+        $messageId, $messageUId, $dialogId, $sentTime, $receivedStatus,
+        $burnAfterReadingFlag, $burnAfterReadingTime, $messageType, $json, $searchText
+      )
+      ON CONFLICT(messageId) DO UPDATE SET
+        messageUId = excluded.messageUId,
+        dialogId = excluded.dialogId,
+        sentTime = excluded.sentTime,
+        receivedStatus = excluded.receivedStatus,
+        burnAfterReadingFlag = excluded.burnAfterReadingFlag,
+        burnAfterReadingTime = excluded.burnAfterReadingTime,
+        messageType = excluded.messageType,
+        json = excluded.json,
+        searchText = excluded.searchText;
+    `);
+        this.database.transaction(() => {
+            for (const message of messages) {
+                if (message.isPersited === false) {
+                    continue;
+                }
+                const messageId = normalizeInteger(message.messageId, 'messageId');
+                const sentTime = normalizeInteger(message.sentTime, 'sentTime');
+                upsert.run({
+                    messageId,
+                    messageUId: message.messageUId ?? null,
+                    dialogId,
+                    sentTime,
+                    receivedStatus: message.receivedStatus ?? null,
+                    burnAfterReadingFlag: message.burnAfterReadingFlag ? 1 : 0,
+                    burnAfterReadingTime: message.burnAfterReadingTime ?? null,
+                    messageType: message.messageType ?? null,
+                    json: JSON.stringify(message),
+                    searchText: extractSearchText(message)
+                });
+            }
+            if (isEnd !== undefined) {
+                this.setDialogState(dialogId, isEnd);
+            }
+        })();
+    }
+    upsertMessage(message, dialogId) {
+        this.addMessages([message], dialogId);
+    }
+    getMessages(dialogId, timestamp = '0', count = 20, isForward = true) {
+        const safeCount = Math.max(0, Math.floor(count));
+        const params = {
+            dialogId,
+            limit: safeCount + 1
+        };
+        let timeClause = '';
+        if (timestamp !== '0') {
+            params.timestamp = normalizeInteger(timestamp, 'timestamp');
+            timeClause = isForward ? 'AND sentTime < $timestamp' : 'AND sentTime > $timestamp';
+        }
+        const direction = isForward ? 'DESC' : 'ASC';
+        const rows = this.database
+            .prepare(`SELECT json FROM messages
+         WHERE dialogId = $dialogId ${timeClause}
+         ORDER BY sentTime ${direction}, messageId ${direction}
+         LIMIT $limit;`)
+            .all(params);
+        const hasAdditionalRow = rows.length > safeCount;
+        const messages = rows
+            .slice(0, safeCount)
+            .map(row => parseMessage(row))
+            .sort((left, right) => {
+            const byTime = Number(left.sentTime) - Number(right.sentTime);
+            return byTime || left.messageId - right.messageId;
+        });
+        return {
+            messages,
+            hasMore: hasAdditionalRow || !this.getDialogLoadedState(dialogId)
+        };
+    }
+    getLatestMessage(dialogId) {
+        return parseMessage(this.database
+            .prepare(`SELECT json FROM messages
+           WHERE dialogId = $dialogId
+           ORDER BY sentTime DESC, messageId DESC
+           LIMIT 1;`)
+            .get({ dialogId }));
+    }
+    getLatestMessages(dialogIds) {
+        const result = Object.create(null);
+        for (const dialogId of dialogIds) {
+            result[dialogId] = null;
+        }
+        if (dialogIds.length === 0) {
+            return result;
+        }
+        const placeholders = dialogIds.map(() => '?').join(', ');
+        const rows = this.database
+            .prepare(`SELECT dialogId, json FROM (
+           SELECT dialogId, json,
+             ROW_NUMBER() OVER (
+               PARTITION BY dialogId ORDER BY sentTime DESC, messageId DESC
+             ) AS position
+           FROM messages
+           WHERE dialogId IN (${placeholders})
+         ) WHERE position = 1;`)
+            .all(dialogIds);
+        for (const row of rows) {
+            result[row.dialogId] = parseMessage(row);
+        }
+        return result;
+    }
+    getMessageById(messageId) {
+        return parseMessage(this.database
+            .prepare('SELECT json FROM messages WHERE messageId = $messageId;')
+            .get({ messageId }));
+    }
+    getMessageByUId(messageUId) {
+        return parseMessage(this.database
+            .prepare('SELECT json FROM messages WHERE messageUId = $messageUId;')
+            .get({ messageUId }));
+    }
+    getMessageIdRange() {
+        const row = this.database
+            .prepare('SELECT MIN(messageId) AS oldest, MAX(messageId) AS newest FROM messages;')
+            .get();
+        if (row?.oldest == null || row.newest == null) {
+            return null;
+        }
+        return { oldest: row.oldest, newest: row.newest };
+    }
+    getDialogLoadedState(dialogId) {
+        return (this.database
+            .prepare('SELECT isEnd FROM dialog_states WHERE dialogId = $dialogId;', {
+            pluck: true
+        })
+            .get({ dialogId }) === 1);
+    }
+    clearConversationCache(dialogId) {
+        this.database.transaction(() => {
+            this.database.prepare('DELETE FROM messages WHERE dialogId = $dialogId;').run({ dialogId });
+            this.setDialogState(dialogId, true);
+        })();
+    }
+    clearAllCache() {
+        this.database.transaction(() => {
+            this.database.exec('DELETE FROM messages; DELETE FROM dialog_states;');
+        })();
+    }
+    removeMessagesByUId(messageUIds) {
+        const remove = this.database.prepare('DELETE FROM messages WHERE messageUId = $messageUId;');
+        this.database.transaction(() => {
+            for (const messageUId of messageUIds) {
+                remove.run({ messageUId });
+            }
+        })();
+    }
+    updateMessageReceiptStatus(messageUIds, receivedStatus) {
+        const select = this.database.prepare('SELECT json, receivedStatus FROM messages WHERE messageUId = $messageUId;');
+        const update = this.database.prepare(`
+      UPDATE messages SET receivedStatus = $receivedStatus, json = $json
+      WHERE messageUId = $messageUId;
+    `);
+        this.database.transaction(() => {
+            for (const messageUId of messageUIds) {
+                const row = select.get({ messageUId });
+                if (!row || (row.receivedStatus ?? -1) >= receivedStatus) {
+                    continue;
+                }
+                const message = JSON.parse(row.json);
+                message.receivedStatus = receivedStatus;
+                update.run({ messageUId, receivedStatus, json: JSON.stringify(message) });
+            }
+        })();
+    }
+    clearBurnAfterReadingExpiredMessages(dialogId, now = Date.now()) {
+        const rows = this.database
+            .prepare(`SELECT messageUId FROM messages
+         WHERE dialogId = $dialogId
+           AND burnAfterReadingFlag = 1
+           AND (burnAfterReadingTime IS NULL OR burnAfterReadingTime = 0
+             OR sentTime + burnAfterReadingTime <= $now);`, { pluck: true })
+            .all({ dialogId, now });
+        this.database
+            .prepare(`DELETE FROM messages
+         WHERE dialogId = $dialogId
+           AND burnAfterReadingFlag = 1
+           AND (burnAfterReadingTime IS NULL OR burnAfterReadingTime = 0
+             OR sentTime + burnAfterReadingTime <= $now);`)
+            .run({ dialogId, now });
+        return rows;
+    }
+    convertToRecallMessages(messageUIds, recallMessageType) {
+        const select = this.database.prepare('SELECT json FROM messages WHERE messageUId = $messageUId;');
+        const update = this.database.prepare(`
+      UPDATE messages SET messageType = $messageType, json = $json, searchText = ''
+      WHERE messageUId = $messageUId;
+    `);
+        this.database.transaction(() => {
+            for (const messageUId of messageUIds) {
+                const row = select.get({ messageUId });
+                const message = parseMessage(row);
+                if (!message) {
+                    continue;
+                }
+                message.messageType = recallMessageType;
+                message.content = { messageUId };
+                message.isPersited = true;
+                message.isCounted = false;
+                message.isMentioned = false;
+                message.disableNotification = true;
+                update.run({
+                    messageUId,
+                    messageType: recallMessageType,
+                    json: JSON.stringify(message)
+                });
+            }
+        })();
+    }
+    searchTextMessages(dialogId, keyword) {
+        return this.searchMessages(keyword, dialogId, Number.MAX_SAFE_INTEGER);
+    }
+    searchMessages(keyword, dialogId, limit = dialogId === undefined ? 500 : 100) {
+        const query = keyword.trim();
+        if (!query) {
+            return [];
+        }
+        const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
+        if (safeLimit === 0) {
+            return [];
+        }
+        const dialogClause = dialogId === undefined ? '' : 'AND messages.dialogId = $dialogId';
+        const containsHanText = /[\u3400-\u9fff\uf900-\ufaff]/u.test(query);
+        const searchClause = containsHanText
+            ? 'instr(lower(messages.searchText), lower($plainQuery)) > 0'
+            : `messages.messageId IN (
+           SELECT rowid FROM messages_fts WHERE messages_fts MATCH $ftsQuery
+         )`;
+        const ftsQuery = containsHanText
+            ? ''
+            : query
+                .split(/\s+/u)
+                .map(token => `"${token.replace(/"/g, '""')}"*`)
+                .join(' ');
+        return this.database
+            .prepare(`SELECT messages.json
+         FROM messages
+         WHERE ${searchClause}
+         ${dialogClause}
+         ORDER BY messages.sentTime DESC, messages.messageId DESC
+         LIMIT $limit;`)
+            .all({
+            ftsQuery,
+            plainQuery: query,
+            dialogId: dialogId ?? '',
+            limit: safeLimit
+        })
+            .map(row => parseMessage(row));
+    }
+    getLegacyMigrationState() {
+        const value = this.database
+            .prepare('SELECT value FROM metadata WHERE key = $key;', { pluck: true })
+            .get({ key: LEGACY_MIGRATION_KEY });
+        if (value === 'in_progress' || value === 'complete') {
+            return value;
+        }
+        return 'pending';
+    }
+    importLegacyBatch(batch) {
+        this.database.transaction(() => {
+            this.setMetadata(LEGACY_MIGRATION_KEY, 'in_progress');
+            const byDialog = new Map();
+            for (const message of batch.messages) {
+                const dialogId = message.dialogId;
+                if (!dialogId) {
+                    throw new Error('Legacy message is missing dialogId');
+                }
+                const group = byDialog.get(dialogId) ?? [];
+                group.push(message);
+                byDialog.set(dialogId, group);
+            }
+            for (const [dialogId, messages] of byDialog) {
+                this.addMessages(messages, dialogId);
+            }
+            for (const state of batch.dialogStates) {
+                this.setDialogState(state.dialogId, state.isEnd, state.updateTime);
+            }
+        })();
+    }
+    completeLegacyMigration() {
+        this.setMetadata(LEGACY_MIGRATION_KEY, 'complete');
+    }
+    setDialogState(dialogId, isEnd, updateTime = Date.now()) {
+        this.database
+            .prepare(`
+        INSERT INTO dialog_states (dialogId, isEnd, updateTime)
+        VALUES ($dialogId, $isEnd, $updateTime)
+        ON CONFLICT(dialogId) DO UPDATE SET
+          isEnd = excluded.isEnd,
+          updateTime = excluded.updateTime;
+      `)
+            .run({ dialogId, isEnd: isEnd ? 1 : 0, updateTime });
+    }
+    setMetadata(key, value) {
+        this.database
+            .prepare(`
+        INSERT INTO metadata (key, value) VALUES ($key, $value)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value;
+      `)
+            .run({ key, value });
+    }
+}
+
+function openDatabase(dbPath, key, isPrimary) {
+    if (!/^[0-9a-f]{64}$/i.test(key)) {
+        throw new Error('SQLCipher key must contain exactly 64 hexadecimal characters');
+    }
+    const database = new SQL__default.default(dbPath, { cacheStatements: true });
+    try {
+        database.pragma(`key = "x'${key}'"`);
+        database.pragma('busy_timeout = 5000');
+        database.pragma('foreign_keys = ON');
+        if (isPrimary) {
+            database.pragma('journal_mode = WAL');
+            database.pragma('synchronous = FULL');
+            runMigrations(database);
+        }
+        else {
+            database.pragma('query_only = ON');
+        }
+        return database;
+    }
+    catch (error) {
+        database.close();
+        throw error;
+    }
+}
+class WorkerDispatcher {
+    database = null;
+    store = null;
+    isPrimary = false;
+    handle(request) {
+        if (request.type === 'init') {
+            if (this.database) {
+                throw new Error('Database worker is already initialized');
+            }
+            this.database = openDatabase(request.dbPath, request.key, request.isPrimary);
+            this.store = new MessageStore(this.database);
+            this.isPrimary = request.isPrimary;
+            return undefined;
+        }
+        if (request.type === 'close') {
+            this.database?.close();
+            this.database = null;
+            this.store = null;
+            this.isPrimary = false;
+            return undefined;
+        }
+        if (!this.store) {
+            throw new Error('Database worker is not initialized');
+        }
+        const allowed = request.access === 'read' ? READ_METHODS : WRITE_METHODS;
+        if (!allowed.has(request.method)) {
+            throw new Error(`${request.method} is not an allowed ${request.access} method`);
+        }
+        if (request.access === 'write' && !this.isPrimary) {
+            throw new Error('Writes are only allowed on the primary database worker');
+        }
+        const method = this.store[request.method];
+        if (typeof method !== 'function') {
+            throw new Error(`Database method is not implemented: ${request.method}`);
+        }
+        return method.apply(this.store, request.args);
+    }
+}
+
+if (!node_worker_threads.parentPort) {
+    throw new Error('Database worker must run inside a worker thread');
+}
+const port = node_worker_threads.parentPort;
+const dispatcher = new WorkerDispatcher();
+port.on('message', ({ sequence, request }) => {
+    let response;
+    try {
+        response = {
+            sequence,
+            ok: true,
+            value: dispatcher.handle(request)
+        };
+    }
+    catch (error) {
+        response = {
+            sequence,
+            ok: false,
+            error: serializeDatabaseError(error)
+        };
+    }
+    port.postMessage(response);
+    if (request.type === 'close') {
+        port.close();
+    }
+});