@lordbex/thelounge 4.4.3-blowfish → 4.5.0-blowfish-pre

package/dist/server/plugins/messageStorage/sqlite.js

@@ -1,40 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.newRollbacks = exports.necessaryMigrations = exports.rollbacks = exports.migrations = exports.currentSchemaVersion = void 0;
-const log_1 = __importDefault(require("../../log"));
-const path_1 = __importDefault(require("path"));
-const promises_1 = __importDefault(require("fs/promises"));
-const config_1 = __importDefault(require("../../config"));
-const msg_1 = __importDefault(require("../../models/msg"));
-const helper_1 = __importDefault(require("../../helper"));
-// TODO; type
-let sqlite3;
-try {
-    sqlite3 = require("sqlite3");
-}
-catch (e) {
-    config_1.default.values.messageStorage = config_1.default.values.messageStorage.filter((item) => item !== "sqlite");
-    log_1.default.error("Unable to load sqlite3 module. See https://github.com/mapbox/node-sqlite3/wiki/Binaries");
-}
-exports.currentSchemaVersion = 1703322560448; // use `new Date().getTime()`
+import Database from "better-sqlite3";
+import log from "../../log.js";
+import path from "path";
+import fs from "fs/promises";
+import Config from "../../config.js";
+import Msg from "../../models/msg.js";
+import Helper from "../../helper.js";
+export const currentSchemaVersion = 1703322560448; // use `new Date().getTime()`
 // Desired schema, adapt to the newest version and add migrations to the array below
 const schema = [
     "CREATE TABLE options (name TEXT, value TEXT, CONSTRAINT name_unique UNIQUE (name))",
     "CREATE TABLE messages (id INTEGER PRIMARY KEY AUTOINCREMENT, network TEXT, channel TEXT, time INTEGER, type TEXT, msg TEXT)",
     `CREATE TABLE migrations (
-		id INTEGER PRIMARY KEY AUTOINCREMENT,
-		version INTEGER NOT NULL UNIQUE,
-		rollback_forbidden INTEGER DEFAULT 0 NOT NULL
-	)`,
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        version INTEGER NOT NULL UNIQUE,
+        rollback_forbidden INTEGER DEFAULT 0 NOT NULL
+    )`,
     `CREATE TABLE rollback_steps (
-		id INTEGER PRIMARY KEY AUTOINCREMENT,
-		migration_id INTEGER NOT NULL REFERENCES migrations ON DELETE CASCADE,
-		step INTEGER NOT NULL,
-		statement TEXT NOT NULL
-	)`,
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        migration_id INTEGER NOT NULL REFERENCES migrations ON DELETE CASCADE,
+        step INTEGER NOT NULL,
+        statement TEXT NOT NULL
+    )`,
     "CREATE INDEX network_channel ON messages (network, channel)",
     "CREATE INDEX time ON messages (time)",
     "CREATE INDEX msg_type_idx on messages (type)", // needed for efficient storageCleaner queries
@@ -42,7 +28,7 @@ const schema = [
 // the migrations will be executed in an exclusive transaction as a whole
 // add new migrations to the end, with the version being the new 'currentSchemaVersion'
 // write a corresponding down migration into rollbacks
-exports.migrations = [
+export const migrations = [
     {
         version: 1672236339873,
         stmts: [
@@ -58,16 +44,16 @@ exports.migrations = [
         version: 1679743888000,
         stmts: [
             `CREATE TABLE IF NOT EXISTS migrations (
-				id INTEGER PRIMARY KEY AUTOINCREMENT,
-				version INTEGER NOT NULL UNIQUE,
-				rollback_forbidden INTEGER DEFAULT 0 NOT NULL
-			)`,
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                version INTEGER NOT NULL UNIQUE,
+                rollback_forbidden INTEGER DEFAULT 0 NOT NULL
+            )`,
             `CREATE TABLE IF NOT EXISTS rollback_steps (
-				id INTEGER PRIMARY KEY AUTOINCREMENT,
-				migration_id INTEGER NOT NULL REFERENCES migrations ON DELETE CASCADE,
-				step INTEGER NOT NULL,
-				statement TEXT NOT NULL
-			)`,
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                migration_id INTEGER NOT NULL REFERENCES migrations ON DELETE CASCADE,
+                step INTEGER NOT NULL,
+                statement TEXT NOT NULL
+            )`,
         ],
     },
     {
@@ -77,7 +63,7 @@ exports.migrations = [
 ];
 // down migrations need to restore the state of the prior version.
 // rollback can be disallowed by adding rollback_forbidden: true to it
-exports.rollbacks = [
+export const rollbacks = [
     {
         version: 1672236339873,
         stmts: [], // changes aren't visible, left empty on purpose
@@ -105,31 +91,39 @@ class SqliteMessageStorage {
     database;
     initDone;
     userName;
+    // Message batching for improved write performance
+    batchQueue = [];
+    batchSize = 50; // Flush after 50 messages
+    batchTimeout = 1000; // Flush after 1 second
+    batchTimer = null;
+    insertStmt = null;
     constructor(userName) {
         this.userName = userName;
         this.isEnabled = false;
         this.initDone = new Deferred();
     }
     async _enable(connection_string) {
-        this.database = new sqlite3.Database(connection_string);
         try {
+            this.database = new Database(connection_string);
             await this.run_pragmas(); // must be done outside of a transaction
             await this.run_migrations();
+            // Prepare insert statement for batching
+            this.insertStmt = this.database.prepare("INSERT INTO messages(network, channel, time, type, msg) VALUES(?, ?, ?, ?, ?)");
         }
         catch (e) {
             this.isEnabled = false;
-            throw helper_1.default.catch_to_error("Migration failed", e);
+            throw Helper.catch_to_error("Migration failed", e);
         }
         this.isEnabled = true;
     }
     async enable() {
-        const logsPath = config_1.default.getUserLogsPath();
-        const sqlitePath = path_1.default.join(logsPath, `${this.userName}.sqlite3`);
+        const logsPath = Config.getUserLogsPath();
+        const sqlitePath = path.join(logsPath, `${this.userName}.sqlite3`);
         try {
-            await promises_1.default.mkdir(logsPath, { recursive: true });
+            await fs.mkdir(logsPath, { recursive: true });
         }
         catch (e) {
-            throw helper_1.default.catch_to_error("Unable to create logs directory", e);
+            throw Helper.catch_to_error("Unable to create logs directory", e);
         }
         try {
             await this._enable(sqlitePath);
@@ -142,7 +136,7 @@ class SqliteMessageStorage {
         for (const stmt of schema) {
             await this.serialize_run(stmt);
         }
-        await this.serialize_run("INSERT INTO options (name, value) VALUES ('schema_version', ?)", exports.currentSchemaVersion.toString());
+        await this.serialize_run("INSERT INTO options (name, value) VALUES ('schema_version', ?)", currentSchemaVersion.toString());
     }
     async current_version() {
         const have_options = await this.serialize_get("select 1 from sqlite_master where type = 'table' and name = 'options'");
@@ -159,10 +153,10 @@ class SqliteMessageStorage {
         return storedSchemaVersion;
     }
     async update_version_in_db() {
-        return this.serialize_run("UPDATE options SET value = ? WHERE name = 'schema_version'", exports.currentSchemaVersion.toString());
+        return this.serialize_run("UPDATE options SET value = ? WHERE name = 'schema_version'", currentSchemaVersion.toString());
     }
     async _run_migrations(dbVersion) {
-        log_1.default.info(`sqlite messages schema version is out of date (${dbVersion} < ${exports.currentSchemaVersion}). Running migrations.`);
+        log.info(`sqlite messages schema version is out of date (${dbVersion} < ${currentSchemaVersion}). Running migrations.`);
         const to_execute = necessaryMigrations(dbVersion);
         for (const stmt of to_execute.map((m) => m.stmts).flat()) {
             await this.serialize_run(stmt);
@@ -174,10 +168,10 @@ class SqliteMessageStorage {
     }
     async run_migrations() {
         const version = await this.current_version();
-        if (version > exports.currentSchemaVersion) {
-            throw `sqlite messages schema version is higher than expected (${version} > ${exports.currentSchemaVersion}). Is The Lounge out of date?`;
+        if (version > currentSchemaVersion) {
+            throw new Error(`sqlite messages schema version is higher than expected (${version} > ${currentSchemaVersion}). Is NexusIRC out of date?`);
         }
-        else if (version === exports.currentSchemaVersion) {
+        else if (version === currentSchemaVersion) {
             return; // nothing to do
         }
         await this.serialize_run("BEGIN EXCLUSIVE TRANSACTION");
@@ -205,37 +199,82 @@ class SqliteMessageStorage {
         if (!this.isEnabled) {
             return;
         }
+        // Flush any pending batched messages
+        await this.flushBatch();
+        // Clear batch timer
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
         this.isEnabled = false;
-        return new Promise((resolve, reject) => {
-            this.database.close((err) => {
-                if (err) {
-                    reject(`Failed to close sqlite database: ${err.message}`);
-                    return;
+        try {
+            this.database.close();
+        }
+        catch (err) {
+            throw new Error(`Failed to close sqlite database: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Flush batched messages to database using a transaction
+     */
+    async flushBatch() {
+        if (this.batchQueue.length === 0) {
+            return Promise.resolve();
+        }
+        if (!this.insertStmt) {
+            log.error("Cannot flush batch: insert statement not prepared");
+            return Promise.resolve();
+        }
+        const messages = this.batchQueue.splice(0); // Take all messages and clear queue
+        try {
+            // Use transaction for batch insert (much faster than individual inserts)
+            const transaction = this.database.transaction((msgs) => {
+                for (const msg of msgs) {
+                    this.insertStmt.run(msg.network, msg.channel, msg.time, msg.type, msg.msg);
                 }
-                resolve();
             });
-        });
+            transaction(messages);
+        }
+        catch (err) {
+            log.error(`Failed to flush message batch: ${err instanceof Error ? err.message : String(err)}`);
+            // Re-add messages to queue on failure
+            this.batchQueue.unshift(...messages);
+            throw err;
+        }
+    }
+    /**
+     * Schedule a batch flush
+     */
+    scheduleBatchFlush() {
+        if (this.batchTimer) {
+            return; // Timer already scheduled
+        }
+        this.batchTimer = setTimeout(() => {
+            this.batchTimer = null;
+            this.flushBatch().catch((err) => log.error(`Batch flush error: ${err}`));
+        }, this.batchTimeout);
     }
     async fetch_rollbacks(since_version) {
         const res = await this.serialize_fetchall(`select version, rollback_forbidden, statement
-			from rollback_steps
-			join migrations on migrations.id=rollback_steps.migration_id
-			where version > ?
-			order by version desc, step asc`, since_version);
+            from rollback_steps
+            join migrations on migrations.id=rollback_steps.migration_id
+            where version > ?
+            order by version desc, step asc`, since_version);
         const result = [];
         // convert to Rollback[]
         // requires ordering in the sql statement
         for (const raw of res) {
             const last = result.at(-1);
-            if (!last || raw.version !== last.version) {
+            const r = raw;
+            if (!last || r.version !== last.version) {
                 result.push({
-                    version: raw.version,
-                    rollback_forbidden: Boolean(raw.rollback_forbidden),
-                    stmts: [raw.statement],
+                    version: r.version,
+                    rollback_forbidden: Boolean(r.rollback_forbidden),
+                    stmts: [r.statement],
                 });
             }
             else {
-                last.stmts.push(raw.statement);
+                last.stmts.push(r.statement);
             }
         }
         return result;
@@ -278,21 +317,21 @@ class SqliteMessageStorage {
         return new_version;
     }
     async downgrade() {
-        const res = await this.downgrade_to(exports.currentSchemaVersion);
+        const res = await this.downgrade_to(currentSchemaVersion);
         return res;
     }
     async insert_rollback_since(version) {
         const missing = newRollbacks(version);
         for (const rollback of missing) {
             const migration = await this.serialize_get(`insert into migrations
-				(version, rollback_forbidden)
-				values (?, ?)
-				returning id`, rollback.version, rollback.rollback_forbidden || 0);
+                (version, rollback_forbidden)
+                values (?, ?)
+                returning id`, rollback.version, rollback.rollback_forbidden || 0);
             for (const stmt of rollback.stmts) {
                 let step = 0;
                 await this.serialize_run(`insert into rollback_steps
-					(migration_id, step, statement)
-					values (?, ?, ?)`, migration.id, step, stmt);
+                    (migration_id, step, statement)
+                    values (?, ?, ?)`, migration.id, step, stmt);
                 step++;
             }
         }
@@ -303,15 +342,30 @@ class SqliteMessageStorage {
             return;
         }
         const clonedMsg = Object.keys(msg).reduce((newMsg, prop) => {
-            // id is regenerated when messages are retrieved
             // previews are not stored because storage is cleared on lounge restart
             // type and time are stored in a separate column
-            if (prop !== "id" && prop !== "previews" && prop !== "type" && prop !== "time") {
+            // id IS now stored so it can be retrieved consistently
+            if (prop !== "previews" && prop !== "type" && prop !== "time") {
                 newMsg[prop] = msg[prop];
             }
             return newMsg;
         }, {});
-        await this.serialize_run("INSERT INTO messages(network, channel, time, type, msg) VALUES(?, ?, ?, ?, ?)", network.uuid, channel.name.toLowerCase(), msg.time.getTime(), msg.type, JSON.stringify(clonedMsg));
+        // Add to batch queue instead of immediate insert
+        this.batchQueue.push({
+            network: network.uuid,
+            channel: channel.name.toLowerCase(),
+            time: msg.time.getTime(),
+            type: msg.type,
+            msg: JSON.stringify(clonedMsg),
+        });
+        // Flush batch if it reaches the size limit
+        if (this.batchQueue.length >= this.batchSize) {
+            await this.flushBatch();
+        }
+        else {
+            // Schedule flush after timeout
+            this.scheduleBatchFlush();
+        }
     }
     async deleteChannel(network, channel) {
         await this.initDone.promise;
@@ -322,20 +376,42 @@ class SqliteMessageStorage {
     }
     async getMessages(network, channel, nextID) {
         await this.initDone.promise;
-        if (!this.isEnabled || config_1.default.values.maxHistory === 0) {
+        if (!this.isEnabled || Config.values.maxHistory === 0) {
             return [];
         }
+        // Flush any pending batched writes before reading
+        await this.flushBatch();
         // If unlimited history is specified, load 100k messages
-        const limit = config_1.default.values.maxHistory < 0 ? 100000 : config_1.default.values.maxHistory;
-        const rows = await this.serialize_fetchall("SELECT msg, type, time FROM messages WHERE network = ? AND channel = ? ORDER BY time DESC LIMIT ?", network.uuid, channel.name.toLowerCase(), limit);
-        return rows.reverse().map((row) => {
-            const msg = JSON.parse(row.msg);
-            msg.time = row.time;
-            msg.type = row.type;
-            const newMsg = new msg_1.default(msg);
-            newMsg.id = nextID();
+        const limit = Config.values.maxHistory < 0 ? 100000 : Config.values.maxHistory;
+        // Select id from SQLite to use as the canonical message ID
+        const rows = await this.serialize_fetchall("SELECT id, msg, type, time FROM messages WHERE network = ? AND channel = ? ORDER BY time DESC LIMIT ?", network.uuid, channel.name.toLowerCase(), limit);
+        // Track max ID so we can update client.idMsg
+        let maxId = 0;
+        const messages = rows.reverse().map((row) => {
+            const r = row;
+            const msg = JSON.parse(r.msg);
+            msg.time = r.time;
+            msg.type = r.type;
+            const newMsg = new Msg(msg);
+            // Use ID from stored JSON if available (new messages)
+            // Fall back to SQLite row ID for old messages without stored ID
+            if (typeof msg.id === "number") {
+                newMsg.id = msg.id;
+            }
+            else {
+                newMsg.id = r.id;
+            }
+            if (newMsg.id > maxId) {
+                maxId = newMsg.id;
+            }
             return newMsg;
         });
+        // Ensure client.idMsg is higher than any loaded message ID
+        // by calling nextID until it surpasses maxId
+        while (nextID() <= maxId) {
+            // Keep incrementing until we're past the max
+        }
+        return messages;
     }
     async search(query) {
         await this.initDone.promise;
@@ -343,9 +419,37 @@ class SqliteMessageStorage {
             // this should never be hit as messageProvider is checked in client.search()
             throw new Error("search called but sqlite provider not enabled. This is a programming error");
         }
+        // Flush any pending batched writes before searching
+        await this.flushBatch();
+        const searchTermParts = query.searchTerm.split(" ");
+        let userFilter = null;
+        let dateEndFilter = null;
+        let dateStartFilter = null;
+        for (const part of [...searchTermParts]) {
+            if (part.startsWith("from:") && userFilter === null) {
+                userFilter = part.slice(5);
+                searchTermParts.splice(searchTermParts.indexOf(part), 1);
+            }
+            if (part.startsWith("datebefore:") && dateEndFilter === null) {
+                const dateStr = part.slice(11);
+                const date = new Date(dateStr);
+                if (!Number.isNaN(date.getTime())) {
+                    dateEndFilter = date.getTime();
+                    searchTermParts.splice(searchTermParts.indexOf(part), 1);
+                }
+            }
+            if (part.startsWith("dateafter:") && dateStartFilter === null) {
+                const dateStr = part.slice(10);
+                const date = new Date(dateStr);
+                if (!Number.isNaN(date.getTime())) {
+                    dateStartFilter = date.getTime();
+                    searchTermParts.splice(searchTermParts.indexOf(part), 1);
+                }
+            }
+        }
         // Using the '@' character to escape '%' and '_' in patterns.
-        const escapedSearchTerm = query.searchTerm.replace(/([%_@])/g, "@$1");
-        let select = 'SELECT msg, type, time, network, channel FROM messages WHERE type = "message" AND json_extract(msg, "$.text") LIKE ? ESCAPE \'@\'';
+        const escapedSearchTerm = searchTermParts.join(" ").replace(/([%_@])/g, "@$1");
+        let select = "SELECT id, msg, type, time, network, channel FROM messages WHERE type = 'message' AND json_extract(msg, '$.text') LIKE ? ESCAPE '@'";
         const params = [`%${escapedSearchTerm}%`];
         if (query.networkUuid) {
             select += " AND network = ? ";
@@ -355,6 +459,18 @@ class SqliteMessageStorage {
             select += " AND channel = ? ";
             params.push(query.channelName.toLowerCase());
         }
+        if (userFilter !== null) {
+            select += " AND LOWER(json_extract(msg, '$.from.nick')) = ? ";
+            params.push(userFilter.toLowerCase());
+        }
+        if (dateEndFilter !== null) {
+            select += " AND time <= ? ";
+            params.push(dateEndFilter);
+        }
+        if (dateStartFilter !== null) {
+            select += " AND time >= ? ";
+            params.push(dateStartFilter);
+        }
         const maxResults = 100;
         select += " ORDER BY time DESC LIMIT ? OFFSET ? ";
         params.push(maxResults);
@@ -362,11 +478,13 @@ class SqliteMessageStorage {
         const rows = await this.serialize_fetchall(select, ...params);
         return {
             ...query,
-            results: parseSearchRowsToMessages(query.offset, rows).reverse(),
+            results: parseSearchRowsToMessages(rows).reverse(),
         };
     }
     async deleteMessages(req) {
         await this.initDone.promise;
+        // Flush any pending batched writes before deleting
+        await this.flushBatch();
         let sql = "delete from messages where id in (select id from messages where\n";
         // We roughly get a timestamp from N days before.
         // We don't adjust for daylight savings time or other weird time jumps
@@ -385,70 +503,133 @@ class SqliteMessageStorage {
         sql += ")";
         return this.serialize_run(sql);
     }
+    /**
+     * Get last N messages for a channel (for initial load)
+     */
+    async getLastMessages(networkUuid, channelName, limit) {
+        await this.initDone.promise;
+        if (!this.isEnabled) {
+            return [];
+        }
+        // Flush any pending batched writes before reading
+        await this.flushBatch();
+        const rows = await this.serialize_fetchall("SELECT msg, type, time FROM messages WHERE network = ? AND channel = ? ORDER BY time DESC LIMIT ?", networkUuid, channelName.toLowerCase(), limit);
+        return rows.reverse().map((row) => {
+            const r = row;
+            const msg = JSON.parse(r.msg);
+            msg.time = r.time;
+            msg.type = r.type;
+            return new Msg(msg);
+        });
+    }
+    /**
+     * Get messages before a specific timestamp (for lazy loading)
+     */
+    async getMessagesBefore(networkUuid, channelName, beforeTime, limit) {
+        await this.initDone.promise;
+        if (!this.isEnabled) {
+            return [];
+        }
+        const rows = await this.serialize_fetchall("SELECT msg, type, time FROM messages WHERE network = ? AND channel = ? AND time < ? ORDER BY time DESC LIMIT ?", networkUuid, channelName.toLowerCase(), beforeTime, limit);
+        return rows.reverse().map((row) => {
+            const r = row;
+            const msg = JSON.parse(r.msg);
+            msg.time = r.time;
+            msg.type = r.type;
+            return new Msg(msg);
+        });
+    }
+    /**
+     * Get messages around a specific timestamp (for jumping to search results)
+     * Returns messages before and after the target time
+     */
+    async getMessagesAround(networkUuid, channelName, targetTime, limit = 200) {
+        await this.initDone.promise;
+        if (!this.isEnabled) {
+            return [];
+        }
+        const halfLimit = Math.floor(limit / 2);
+        // Get messages before the target time
+        const beforeRows = await this.serialize_fetchall("SELECT id, msg, type, time FROM messages WHERE network = ? AND channel = ? AND time <= ? ORDER BY time DESC LIMIT ?", networkUuid, channelName.toLowerCase(), targetTime, halfLimit);
+        // Get messages after the target time
+        const afterRows = await this.serialize_fetchall("SELECT id, msg, type, time FROM messages WHERE network = ? AND channel = ? AND time > ? ORDER BY time ASC LIMIT ?", networkUuid, channelName.toLowerCase(), targetTime, halfLimit);
+        // Combine: before (reversed) + after
+        const allRows = [...beforeRows.reverse(), ...afterRows];
+        return allRows.map((row) => {
+            const r = row;
+            const msg = JSON.parse(r.msg);
+            msg.time = r.time;
+            msg.type = r.type;
+            // Use stored ID from JSON if available, fall back to SQLite row ID
+            if (typeof msg.id !== "number") {
+                msg.id = r.id;
+            }
+            return new Msg(msg);
+        });
+    }
+    /**
+     * Get total message count for a channel
+     */
+    async getMessageCount(networkUuid, channelName) {
+        await this.initDone.promise;
+        if (!this.isEnabled) {
+            return 0;
+        }
+        const row = await this.serialize_get("SELECT COUNT(*) as count FROM messages WHERE network = ? AND channel = ?", networkUuid, channelName.toLowerCase());
+        return row ? row.count : 0;
+    }
     canProvideMessages() {
         return this.isEnabled;
     }
     serialize_run(stmt, ...params) {
-        return new Promise((resolve, reject) => {
-            this.database.serialize(() => {
-                this.database.run(stmt, params, function (err) {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(this.changes); // number of affected rows, `this` is re-bound by sqlite3
-                });
-            });
-        });
+        try {
+            const result = this.database.prepare(stmt).run(...params);
+            return Promise.resolve(result.changes);
+        }
+        catch (err) {
+            return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+        }
     }
     serialize_fetchall(stmt, ...params) {
-        return new Promise((resolve, reject) => {
-            this.database.serialize(() => {
-                this.database.all(stmt, params, (err, rows) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(rows);
-                });
-            });
-        });
+        try {
+            const rows = this.database.prepare(stmt).all(...params);
+            return Promise.resolve(rows);
+        }
+        catch (err) {
+            return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+        }
     }
     serialize_get(stmt, ...params) {
-        return new Promise((resolve, reject) => {
-            this.database.serialize(() => {
-                this.database.get(stmt, params, (err, row) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(row);
-                });
-            });
-        });
+        try {
+            const row = this.database.prepare(stmt).get(...params);
+            return Promise.resolve(row);
+        }
+        catch (err) {
+            return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+        }
     }
 }
-// TODO: type any
-function parseSearchRowsToMessages(id, rows) {
+function parseSearchRowsToMessages(rows) {
     const messages = [];
     for (const row of rows) {
-        const msg = JSON.parse(row.msg);
-        msg.time = row.time;
-        msg.type = row.type;
-        msg.networkUuid = row.network;
-        msg.channelName = row.channel;
-        msg.id = id;
-        messages.push(new msg_1.default(msg));
-        id += 1;
+        const r = row;
+        const msg = JSON.parse(r.msg);
+        msg.time = r.time;
+        msg.type = r.type;
+        msg.networkUuid = r.network;
+        msg.channelName = r.channel;
+        // Use stored ID from JSON if available, fall back to SQLite row ID
+        if (typeof msg.id !== "number") {
+            msg.id = r.id;
+        }
+        messages.push(new Msg(msg));
     }
     return messages;
 }
-function necessaryMigrations(since) {
-    return exports.migrations.filter((m) => m.version > since);
+export function necessaryMigrations(since) {
+    return migrations.filter((m) => m.version > since);
 }
-exports.necessaryMigrations = necessaryMigrations;
-function newRollbacks(since) {
-    return exports.rollbacks.filter((r) => r.version > since);
+export function newRollbacks(since) {
+    return rollbacks.filter((r) => r.version > since);
 }
-exports.newRollbacks = newRollbacks;
-exports.default = SqliteMessageStorage;
+export default SqliteMessageStorage;