@pixelbyte-software/pixcode 1.32.0 → 1.33.0

package/dist-server/server/database/db.js

@@ -1,9 +1,13 @@
-import Database from 'better-sqlite3';
-import path from 'path';
-import fs from 'fs';
-import crypto from 'crypto';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
 import { findAppRoot, getModuleDir } from '../utils/runtime-paths.js';
-import { APP_CONFIG_TABLE_SQL, USER_NOTIFICATION_PREFERENCES_TABLE_SQL, VAPID_KEYS_TABLE_SQL, PUSH_SUBSCRIPTIONS_TABLE_SQL, SESSION_NAMES_TABLE_SQL, SESSION_NAMES_LOOKUP_INDEX_SQL, TELEGRAM_CONFIG_TABLE_SQL, TELEGRAM_LINKS_TABLE_SQL, TELEGRAM_LINKS_CHAT_INDEX_SQL, TELEGRAM_LINKS_CODE_INDEX_SQL, DATABASE_SCHEMA_SQL } from './schema.js';
+import { JsonStore, nowIso } from './json-store.js';
+// CommonJS `require` shim — we only reach for it once, during the
+// legacy-to-JSON migration below, to dynamically import better-sqlite3
+// only when an old auth.db is actually present on disk.
+const require = createRequire(import.meta.url);
 const __dirname = getModuleDir(import.meta.url);
 // The compiled backend lives under dist-server/server/database, but the install root we log
 // should still point at the project/app root. Resolving it here avoids build-layout drift.
@@ -20,468 +24,546 @@ const c = {
     bright: (text) => `${colors.bright}${text}${colors.reset}`,
     dim: (text) => `${colors.dim}${text}${colors.reset}`,
 };
-// Use DATABASE_PATH environment variable if set, otherwise use default location
-const DB_PATH = process.env.DATABASE_PATH || path.join(__dirname, 'auth.db');
-// Ensure database directory exists if custom path is provided
-if (process.env.DATABASE_PATH) {
-    const dbDir = path.dirname(DB_PATH);
+// DATABASE_PATH keeps its historical meaning (user override), but points
+// at a `.json` file now. If the user's env var still names a `.db`
+// extension, we swap to the corresponding `.json` sibling — the auth
+// store moved off SQLite in v1.33.0.
+const rawDbPath = process.env.DATABASE_PATH || path.join(__dirname, 'auth.db');
+const JSON_PATH = rawDbPath.endsWith('.db')
+    ? rawDbPath.replace(/\.db$/, '.json')
+    : (rawDbPath.endsWith('.json') ? rawDbPath : `${rawDbPath}.json`);
+const LEGACY_SQLITE_PATH = rawDbPath.endsWith('.db')
+    ? rawDbPath
+    : rawDbPath.replace(/\.json$/, '.db');
+// Ensure parent dir exists before migration / initial write.
+{
+    const dir = path.dirname(JSON_PATH);
+    if (!fs.existsSync(dir)) {
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        catch (err) {
+            console.error(`Failed to create database directory ${dir}:`, err.message);
+            throw err;
+        }
+    }
+}
+/**
+ * One-time migration from the previous better-sqlite3 auth.db to the
+ * new JSON format. Triggered only when:
+ *   - The legacy .db exists
+ *   - AND no .json has been created yet
+ * The legacy file is kept in place as `<name>.db.migrated-<timestamp>`
+ * so a user can roll back by moving it into place and reinstalling
+ * better-sqlite3 if they hit a showstopper. Runs synchronously because
+ * all downstream modules (auth.js, vapid-keys.js) import `db` at module
+ * load and can't wait for async startup.
+ */
+function migrateSqliteIfPresent() {
+    if (fs.existsSync(JSON_PATH))
+        return; // Already migrated or fresh install.
+    if (!fs.existsSync(LEGACY_SQLITE_PATH))
+        return; // Nothing to migrate.
+    console.log(`${c.info('[MIGRATION]')} Converting ${c.bright(LEGACY_SQLITE_PATH)} → ${c.bright(JSON_PATH)} (JSON auth store, v1.33.0)`);
+    let Database;
     try {
-        if (!fs.existsSync(dbDir)) {
-            fs.mkdirSync(dbDir, { recursive: true });
-            console.log(`Created database directory: ${dbDir}`);
+        const mod = require('better-sqlite3');
+        Database = mod.default || mod;
+    }
+    catch {
+        // Auto-install path fell through — the user has a legacy file but
+        // better-sqlite3 isn't present (they may have a trimmed dep tree).
+        // Surface a clear error; we'd rather fail startup than silently
+        // skip migration and strand the user's saved credentials.
+        console.error('[MIGRATION] Legacy auth.db present but better-sqlite3 not installed.');
+        console.error('[MIGRATION] Install it once to migrate: `npm install better-sqlite3` in your pixcode install dir, then restart.');
+        throw new Error('Auth DB migration requires better-sqlite3 (legacy file detected).');
+    }
+    const legacy = new Database(LEGACY_SQLITE_PATH, { readonly: true });
+    const store = new JsonStore(JSON_PATH);
+    // Pull every table, skipping silently when it doesn't exist (old
+    // installs that never ran some migrations). We rely on `IF NOT EXISTS`
+    // patterns from the old schema.js — missing tables throw a SQLite
+    // error which we catch per-table.
+    const safeAll = (sql) => {
+        try {
+            return legacy.prepare(sql).all();
         }
+        catch {
+            return [];
+        }
+    };
+    const users = safeAll('SELECT id, username, password_hash, created_at, last_login, is_active, git_name, git_email, has_completed_onboarding FROM users');
+    for (const u of users) {
+        store.raw.users.push({
+            id: u.id,
+            username: u.username,
+            password_hash: u.password_hash,
+            created_at: u.created_at || nowIso(),
+            last_login: u.last_login || null,
+            is_active: u.is_active !== 0,
+            git_name: u.git_name || null,
+            git_email: u.git_email || null,
+            has_completed_onboarding: u.has_completed_onboarding === 1,
+        });
+        store.raw._sequences.users = Math.max(store.raw._sequences.users, u.id);
     }
-    catch (error) {
-        console.error(`Failed to create database directory ${dbDir}:`, error.message);
-        throw error;
+    const apiKeys = safeAll('SELECT id, user_id, key_name, api_key, created_at, last_used, is_active FROM api_keys');
+    for (const k of apiKeys) {
+        store.raw.api_keys.push({
+            id: k.id,
+            user_id: k.user_id,
+            key_name: k.key_name,
+            api_key: k.api_key,
+            created_at: k.created_at || nowIso(),
+            last_used: k.last_used || null,
+            is_active: k.is_active !== 0,
+        });
+        store.raw._sequences.api_keys = Math.max(store.raw._sequences.api_keys, k.id);
     }
-}
-// As part of 1.19.2 we are introducing a new location for auth.db. The below handles exisitng moving legacy database from install directory to new location
-const LEGACY_DB_PATH = path.join(__dirname, 'auth.db');
-if (DB_PATH !== LEGACY_DB_PATH && !fs.existsSync(DB_PATH) && fs.existsSync(LEGACY_DB_PATH)) {
+    const credentials = safeAll('SELECT id, user_id, credential_name, credential_type, credential_value, description, created_at, is_active FROM user_credentials');
+    for (const cr of credentials) {
+        store.raw.user_credentials.push({
+            id: cr.id,
+            user_id: cr.user_id,
+            credential_name: cr.credential_name,
+            credential_type: cr.credential_type,
+            credential_value: cr.credential_value,
+            description: cr.description || null,
+            created_at: cr.created_at || nowIso(),
+            is_active: cr.is_active !== 0,
+        });
+        store.raw._sequences.user_credentials = Math.max(store.raw._sequences.user_credentials, cr.id);
+    }
+    const prefs = safeAll('SELECT user_id, preferences_json, updated_at FROM user_notification_preferences');
+    for (const p of prefs) {
+        store.raw.user_notification_preferences.push({
+            user_id: p.user_id,
+            preferences_json: p.preferences_json,
+            updated_at: p.updated_at || nowIso(),
+        });
+    }
+    const vapid = safeAll('SELECT id, public_key, private_key, created_at FROM vapid_keys');
+    for (const v of vapid) {
+        store.raw.vapid_keys.push({
+            id: v.id,
+            public_key: v.public_key,
+            private_key: v.private_key,
+            created_at: v.created_at || nowIso(),
+        });
+        store.raw._sequences.vapid_keys = Math.max(store.raw._sequences.vapid_keys, v.id);
+    }
+    const pushSubs = safeAll('SELECT id, user_id, endpoint, keys_p256dh, keys_auth, created_at FROM push_subscriptions');
+    for (const s of pushSubs) {
+        store.raw.push_subscriptions.push({
+            id: s.id,
+            user_id: s.user_id,
+            endpoint: s.endpoint,
+            keys_p256dh: s.keys_p256dh,
+            keys_auth: s.keys_auth,
+            created_at: s.created_at || nowIso(),
+        });
+        store.raw._sequences.push_subscriptions = Math.max(store.raw._sequences.push_subscriptions, s.id);
+    }
+    const sessionNames = safeAll('SELECT session_id, provider, custom_name, created_at, updated_at FROM session_names');
+    for (const sn of sessionNames) {
+        store.raw.session_names.push({
+            session_id: sn.session_id,
+            provider: sn.provider,
+            custom_name: sn.custom_name,
+            created_at: sn.created_at || nowIso(),
+            updated_at: sn.updated_at || nowIso(),
+        });
+    }
+    const appConfig = safeAll('SELECT key, value, created_at FROM app_config');
+    for (const a of appConfig) {
+        store.raw.app_config.push({
+            key: a.key,
+            value: a.value,
+            created_at: a.created_at || nowIso(),
+        });
+    }
+    const telegramConfig = safeAll('SELECT id, bot_token, bot_username, updated_at FROM telegram_config');
+    for (const t of telegramConfig) {
+        store.raw.telegram_config.push({
+            id: 1,
+            bot_token: t.bot_token,
+            bot_username: t.bot_username || null,
+            updated_at: t.updated_at || nowIso(),
+        });
+    }
+    const telegramLinks = safeAll('SELECT user_id, chat_id, telegram_username, language, pairing_code, pairing_code_expires_at, verified_at, notifications_enabled, bridge_enabled, updated_at FROM telegram_links');
+    for (const tl of telegramLinks) {
+        store.raw.telegram_links.push({
+            user_id: tl.user_id,
+            chat_id: tl.chat_id || null,
+            telegram_username: tl.telegram_username || null,
+            language: tl.language || 'en',
+            pairing_code: tl.pairing_code || null,
+            pairing_code_expires_at: tl.pairing_code_expires_at || null,
+            verified_at: tl.verified_at || null,
+            notifications_enabled: tl.notifications_enabled !== 0,
+            bridge_enabled: tl.bridge_enabled !== 0,
+            updated_at: tl.updated_at || nowIso(),
+        });
+    }
+    store.save();
+    legacy.close();
+    // Rename the old .db out of the way so we never migrate it twice.
+    // Keep it (not delete) so the user can roll back if needed.
+    const backup = `${LEGACY_SQLITE_PATH}.migrated-${Date.now()}`;
     try {
-        fs.copyFileSync(LEGACY_DB_PATH, DB_PATH);
-        console.log(`[MIGRATION] Copied database from ${LEGACY_DB_PATH} to ${DB_PATH}`);
+        fs.renameSync(LEGACY_SQLITE_PATH, backup);
         for (const suffix of ['-wal', '-shm']) {
-            if (fs.existsSync(LEGACY_DB_PATH + suffix)) {
-                fs.copyFileSync(LEGACY_DB_PATH + suffix, DB_PATH + suffix);
+            if (fs.existsSync(LEGACY_SQLITE_PATH + suffix)) {
+                try {
+                    fs.renameSync(LEGACY_SQLITE_PATH + suffix, backup + suffix);
+                }
+                catch { /* noop */ }
             }
         }
     }
     catch (err) {
-        console.warn(`[MIGRATION] Could not copy legacy database: ${err.message}`);
+        console.warn(`[MIGRATION] Migration succeeded but could not rename old DB: ${err.message}`);
     }
+    console.log(`${c.info('[MIGRATION]')} Migration complete. Old DB preserved as ${c.dim(backup)}.`);
 }
-// Create database connection
-const db = new Database(DB_PATH);
-// app_config must exist before any other module imports (auth.js reads the JWT secret at load time).
-// runMigrations() also creates this table, but it runs too late for existing installations
-// where auth.js is imported before initializeDatabase() is called.
-db.exec(APP_CONFIG_TABLE_SQL);
-// Show app installation path prominently
-const appInstallPath = APP_ROOT;
+// Module-load order matters — auth middleware imports `db` and reads the
+// JWT secret before anything else gets to boot. So the store has to be
+// ready synchronously at the first `import { db } from './db.js'`.
+migrateSqliteIfPresent();
+const store = new JsonStore(JSON_PATH);
 console.log('');
 console.log(c.dim('═'.repeat(60)));
-console.log(`${c.info('[INFO]')} App Installation: ${c.bright(appInstallPath)}`);
-console.log(`${c.info('[INFO]')} Database: ${c.dim(path.relative(appInstallPath, DB_PATH))}`);
+console.log(`${c.info('[INFO]')} App Installation: ${c.bright(APP_ROOT)}`);
+console.log(`${c.info('[INFO]')} Auth store: ${c.dim(path.relative(APP_ROOT, JSON_PATH))}`);
 if (process.env.DATABASE_PATH) {
     console.log(`       ${c.dim('(Using custom DATABASE_PATH from environment)')}`);
 }
 console.log(c.dim('═'.repeat(60)));
 console.log('');
-const runMigrations = () => {
-    try {
-        const tableInfo = db.prepare("PRAGMA table_info(users)").all();
-        const columnNames = tableInfo.map(col => col.name);
-        if (!columnNames.includes('git_name')) {
-            console.log('Running migration: Adding git_name column');
-            db.exec('ALTER TABLE users ADD COLUMN git_name TEXT');
-        }
-        if (!columnNames.includes('git_email')) {
-            console.log('Running migration: Adding git_email column');
-            db.exec('ALTER TABLE users ADD COLUMN git_email TEXT');
-        }
-        if (!columnNames.includes('has_completed_onboarding')) {
-            console.log('Running migration: Adding has_completed_onboarding column');
-            db.exec('ALTER TABLE users ADD COLUMN has_completed_onboarding BOOLEAN DEFAULT 0');
-        }
-        db.exec(USER_NOTIFICATION_PREFERENCES_TABLE_SQL);
-        db.exec(VAPID_KEYS_TABLE_SQL);
-        db.exec(PUSH_SUBSCRIPTIONS_TABLE_SQL);
-        db.exec(APP_CONFIG_TABLE_SQL);
-        db.exec(SESSION_NAMES_TABLE_SQL);
-        db.exec(SESSION_NAMES_LOOKUP_INDEX_SQL);
-        db.exec(TELEGRAM_CONFIG_TABLE_SQL);
-        db.exec(TELEGRAM_LINKS_TABLE_SQL);
-        db.exec(TELEGRAM_LINKS_CHAT_INDEX_SQL);
-        db.exec(TELEGRAM_LINKS_CODE_INDEX_SQL);
-        console.log('Database migrations completed successfully');
-    }
-    catch (error) {
-        console.error('Error running migrations:', error.message);
-        throw error;
-    }
-};
-// Initialize database with schema
-const initializeDatabase = async () => {
-    try {
-        db.exec(DATABASE_SCHEMA_SQL);
-        console.log('Database initialized successfully');
-        runMigrations();
-    }
-    catch (error) {
-        console.error('Error initializing database:', error.message);
-        throw error;
-    }
+// initializeDatabase used to run `CREATE TABLE IF NOT EXISTS` + migrations.
+// The JSON store always has its shape pre-baked, so this is a no-op —
+// keeping the export preserves the server boot sequence.
+const initializeDatabase = async () => { };
+// ---------------------------------------------------------------------------
+// Back-compat `db` shim — a few modules outside database/db.js imported `db`
+// and called `db.prepare(sql)` directly. Most of those uses were for trivial
+// transaction markers (BEGIN/COMMIT/ROLLBACK — no-op under our JSON store)
+// or very specific SELECTs we've wrapped in explicit helpers. This shim
+// lets those call sites keep working without a bigger refactor.
+// ---------------------------------------------------------------------------
+const db = {
+    prepare(sql) {
+        const normalized = sql.trim().toUpperCase();
+        // Transaction markers — our store writes atomically per op, so
+        // there's no real transaction to start. No-op + success result.
+        if (normalized === 'BEGIN' || normalized === 'COMMIT' || normalized === 'ROLLBACK') {
+            return {
+                run: () => ({ changes: 0, lastInsertRowid: 0 }),
+            };
+        }
+        // Specific query routed through the new helpers — used by
+        // server/routes/projects.js to fetch a single github credential.
+        if (/FROM USER_CREDENTIALS\s+WHERE ID = \?\s+AND USER_ID = \?\s+AND CREDENTIAL_TYPE = \?\s+AND IS_ACTIVE = 1/.test(normalized)) {
+            return {
+                get: (id, userId, credentialType) => store.findWhere('user_credentials', (r) => r.id === id && r.user_id === userId && r.credential_type === credentialType && r.is_active)
+                    || undefined,
+            };
+        }
+        throw new Error(`db.prepare: unsupported SQL passed through the compat shim: ${sql.slice(0, 80)}`
+            + '\nExtend server/database/db.js or use a dedicated helper (userDb, credentialsDb, …).');
+    },
 };
-// User database operations
+// ---------------------------------------------------------------------------
+// User operations
+// ---------------------------------------------------------------------------
 const userDb = {
-    // Check if any users exist
-    hasUsers: () => {
-        try {
-            const row = db.prepare('SELECT COUNT(*) as count FROM users').get();
-            return row.count > 0;
-        }
-        catch (err) {
-            throw err;
-        }
-    },
-    // Create a new user
+    hasUsers: () => store.count('users', (r) => r.is_active) > 0,
     createUser: (username, passwordHash) => {
-        try {
-            const stmt = db.prepare('INSERT INTO users (username, password_hash) VALUES (?, ?)');
-            const result = stmt.run(username, passwordHash);
-            return { id: result.lastInsertRowid, username };
-        }
-        catch (err) {
-            throw err;
-        }
-    },
-    // Get user by username
-    getUserByUsername: (username) => {
-        try {
-            const row = db.prepare('SELECT * FROM users WHERE username = ? AND is_active = 1').get(username);
-            return row;
-        }
-        catch (err) {
-            throw err;
-        }
-    },
-    // Update last login time (non-fatal — logged but not thrown)
+        const row = store.insert('users', {
+            username,
+            password_hash: passwordHash,
+            created_at: nowIso(),
+            last_login: null,
+            is_active: true,
+            git_name: null,
+            git_email: null,
+            has_completed_onboarding: false,
+        });
+        return { id: row.id, username: row.username };
+    },
+    getUserByUsername: (username) => store.findWhere('users', (r) => r.username === username && r.is_active) || undefined,
     updateLastLogin: (userId) => {
         try {
-            db.prepare('UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = ?').run(userId);
+            store.updateWhere('users', (r) => r.id === userId, { last_login: nowIso() });
         }
         catch (err) {
             console.warn('Failed to update last login:', err.message);
         }
     },
-    // Get user by ID
     getUserById: (userId) => {
-        try {
-            const row = db.prepare('SELECT id, username, created_at, last_login FROM users WHERE id = ? AND is_active = 1').get(userId);
-            return row;
-        }
-        catch (err) {
-            throw err;
-        }
+        const row = store.findWhere('users', (r) => r.id === userId && r.is_active);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id,
+            username: row.username,
+            created_at: row.created_at,
+            last_login: row.last_login,
+        };
     },
     getFirstUser: () => {
-        try {
-            const row = db.prepare('SELECT id, username, created_at, last_login FROM users WHERE is_active = 1 LIMIT 1').get();
-            return row;
-        }
-        catch (err) {
-            throw err;
-        }
+        const row = store.raw.users.find((r) => r.is_active);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id,
+            username: row.username,
+            created_at: row.created_at,
+            last_login: row.last_login,
+        };
     },
     updateGitConfig: (userId, gitName, gitEmail) => {
-        try {
-            const stmt = db.prepare('UPDATE users SET git_name = ?, git_email = ? WHERE id = ?');
-            stmt.run(gitName, gitEmail, userId);
-        }
-        catch (err) {
-            throw err;
-        }
+        store.updateWhere('users', (r) => r.id === userId, { git_name: gitName, git_email: gitEmail });
     },
     getGitConfig: (userId) => {
-        try {
-            const row = db.prepare('SELECT git_name, git_email FROM users WHERE id = ?').get(userId);
-            return row;
-        }
-        catch (err) {
-            throw err;
-        }
+        const row = store.findWhere('users', (r) => r.id === userId);
+        if (!row)
+            return undefined;
+        return { git_name: row.git_name || null, git_email: row.git_email || null };
     },
     completeOnboarding: (userId) => {
-        try {
-            const stmt = db.prepare('UPDATE users SET has_completed_onboarding = 1 WHERE id = ?');
-            stmt.run(userId);
-        }
-        catch (err) {
-            throw err;
-        }
+        store.updateWhere('users', (r) => r.id === userId, { has_completed_onboarding: true });
     },
     hasCompletedOnboarding: (userId) => {
-        try {
-            const row = db.prepare('SELECT has_completed_onboarding FROM users WHERE id = ?').get(userId);
-            return row?.has_completed_onboarding === 1;
-        }
-        catch (err) {
-            throw err;
-        }
-    }
+        const row = store.findWhere('users', (r) => r.id === userId);
+        return Boolean(row?.has_completed_onboarding);
+    },
 };
-// API Keys database operations
+// ---------------------------------------------------------------------------
+// API key operations
+// ---------------------------------------------------------------------------
 const apiKeysDb = {
-    // Generate a new API key
-    generateApiKey: () => {
-        return 'ck_' + crypto.randomBytes(32).toString('hex');
-    },
-    // Create a new API key
+    generateApiKey: () => 'ck_' + crypto.randomBytes(32).toString('hex'),
     createApiKey: (userId, keyName) => {
-        try {
-            const apiKey = apiKeysDb.generateApiKey();
-            const stmt = db.prepare('INSERT INTO api_keys (user_id, key_name, api_key) VALUES (?, ?, ?)');
-            const result = stmt.run(userId, keyName, apiKey);
-            return { id: result.lastInsertRowid, keyName, apiKey };
-        }
-        catch (err) {
-            throw err;
-        }
+        const apiKey = apiKeysDb.generateApiKey();
+        const row = store.insert('api_keys', {
+            user_id: userId,
+            key_name: keyName,
+            api_key: apiKey,
+            created_at: nowIso(),
+            last_used: null,
+            is_active: true,
+        });
+        return { id: row.id, keyName, apiKey };
     },
-    // Get all API keys for a user
     getApiKeys: (userId) => {
-        try {
-            const rows = db.prepare('SELECT id, key_name, api_key, created_at, last_used, is_active FROM api_keys WHERE user_id = ? ORDER BY created_at DESC').all(userId);
-            return rows;
-        }
-        catch (err) {
-            throw err;
-        }
+        const rows = store.filterWhere('api_keys', (r) => r.user_id === userId);
+        // Match the old ORDER BY created_at DESC behaviour.
+        return rows
+            .slice()
+            .sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)))
+            .map((r) => ({
+            id: r.id,
+            key_name: r.key_name,
+            api_key: r.api_key,
+            created_at: r.created_at,
+            last_used: r.last_used,
+            is_active: r.is_active ? 1 : 0,
+        }));
     },
-    // Validate API key and get user
     validateApiKey: (apiKey) => {
-        try {
-            const row = db.prepare(`
-        SELECT u.id, u.username, ak.id as api_key_id
-        FROM api_keys ak
-        JOIN users u ON ak.user_id = u.id
-        WHERE ak.api_key = ? AND ak.is_active = 1 AND u.is_active = 1
-      `).get(apiKey);
-            if (row) {
-                // Update last_used timestamp
-                db.prepare('UPDATE api_keys SET last_used = CURRENT_TIMESTAMP WHERE id = ?').run(row.api_key_id);
-            }
-            return row;
-        }
-        catch (err) {
-            throw err;
-        }
-    },
-    // Delete an API key
-    deleteApiKey: (userId, apiKeyId) => {
-        try {
-            const stmt = db.prepare('DELETE FROM api_keys WHERE id = ? AND user_id = ?');
-            const result = stmt.run(apiKeyId, userId);
-            return result.changes > 0;
-        }
-        catch (err) {
-            throw err;
-        }
-    },
-    // Toggle API key active status
-    toggleApiKey: (userId, apiKeyId, isActive) => {
-        try {
-            const stmt = db.prepare('UPDATE api_keys SET is_active = ? WHERE id = ? AND user_id = ?');
-            const result = stmt.run(isActive ? 1 : 0, apiKeyId, userId);
-            return result.changes > 0;
-        }
-        catch (err) {
-            throw err;
-        }
-    }
+        const key = store.findWhere('api_keys', (r) => r.api_key === apiKey && r.is_active);
+        if (!key)
+            return undefined;
+        const user = store.findWhere('users', (r) => r.id === key.user_id && r.is_active);
+        if (!user)
+            return undefined;
+        // Mirror the SQL-era side effect: stamp last_used. Only relevant
+        // for the "which key was used last" display in the UI.
+        store.updateWhere('api_keys', (r) => r.id === key.id, { last_used: nowIso() });
+        return {
+            id: user.id,
+            username: user.username,
+            api_key_id: key.id,
+        };
+    },
+    deleteApiKey: (userId, apiKeyId) => store.deleteWhere('api_keys', (r) => r.id === apiKeyId && r.user_id === userId) > 0,
+    toggleApiKey: (userId, apiKeyId, isActive) => store.updateWhere('api_keys', (r) => r.id === apiKeyId && r.user_id === userId, { is_active: Boolean(isActive) }) > 0,
 };
-// User credentials database operations (for GitHub tokens, GitLab tokens, etc.)
+// ---------------------------------------------------------------------------
+// Credentials (GitHub tokens, etc.) operations
+// ---------------------------------------------------------------------------
 const credentialsDb = {
-    // Create a new credential
     createCredential: (userId, credentialName, credentialType, credentialValue, description = null) => {
-        try {
-            const stmt = db.prepare('INSERT INTO user_credentials (user_id, credential_name, credential_type, credential_value, description) VALUES (?, ?, ?, ?, ?)');
-            const result = stmt.run(userId, credentialName, credentialType, credentialValue, description);
-            return { id: result.lastInsertRowid, credentialName, credentialType };
-        }
-        catch (err) {
-            throw err;
-        }
+        const row = store.insert('user_credentials', {
+            user_id: userId,
+            credential_name: credentialName,
+            credential_type: credentialType,
+            credential_value: credentialValue,
+            description,
+            created_at: nowIso(),
+            is_active: true,
+        });
+        return { id: row.id, credentialName, credentialType };
     },
-    // Get all credentials for a user, optionally filtered by type
     getCredentials: (userId, credentialType = null) => {
-        try {
-            let query = 'SELECT id, credential_name, credential_type, description, created_at, is_active FROM user_credentials WHERE user_id = ?';
-            const params = [userId];
-            if (credentialType) {
-                query += ' AND credential_type = ?';
-                params.push(credentialType);
-            }
-            query += ' ORDER BY created_at DESC';
-            const rows = db.prepare(query).all(...params);
-            return rows;
-        }
-        catch (err) {
-            throw err;
-        }
+        const rows = store.filterWhere('user_credentials', (r) => r.user_id === userId && (credentialType == null || r.credential_type === credentialType));
+        return rows
+            .slice()
+            .sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)))
+            .map((r) => ({
+            id: r.id,
+            credential_name: r.credential_name,
+            credential_type: r.credential_type,
+            description: r.description,
+            created_at: r.created_at,
+            is_active: r.is_active ? 1 : 0,
+        }));
     },
-    // Get active credential value for a user by type (returns most recent active)
     getActiveCredential: (userId, credentialType) => {
-        try {
-            const row = db.prepare('SELECT credential_value FROM user_credentials WHERE user_id = ? AND credential_type = ? AND is_active = 1 ORDER BY created_at DESC LIMIT 1').get(userId, credentialType);
-            return row?.credential_value || null;
-        }
-        catch (err) {
-            throw err;
-        }
+        const rows = store.filterWhere('user_credentials', (r) => r.user_id === userId && r.credential_type === credentialType && r.is_active);
+        if (rows.length === 0)
+            return null;
+        // "Most recent active" — mirror ORDER BY created_at DESC LIMIT 1
+        rows.sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
+        return rows[0].credential_value;
     },
-    // Delete a credential
-    deleteCredential: (userId, credentialId) => {
-        try {
-            const stmt = db.prepare('DELETE FROM user_credentials WHERE id = ? AND user_id = ?');
-            const result = stmt.run(credentialId, userId);
-            return result.changes > 0;
-        }
-        catch (err) {
-            throw err;
-        }
+    getCredentialById: (userId, credentialId, credentialType = null) => {
+        const row = store.findWhere('user_credentials', (r) => r.id === credentialId && r.user_id === userId && r.is_active
+            && (credentialType == null || r.credential_type === credentialType));
+        return row || undefined;
     },
-    // Toggle credential active status
-    toggleCredential: (userId, credentialId, isActive) => {
-        try {
-            const stmt = db.prepare('UPDATE user_credentials SET is_active = ? WHERE id = ? AND user_id = ?');
-            const result = stmt.run(isActive ? 1 : 0, credentialId, userId);
-            return result.changes > 0;
-        }
-        catch (err) {
-            throw err;
-        }
-    }
+    deleteCredential: (userId, credentialId) => store.deleteWhere('user_credentials', (r) => r.id === credentialId && r.user_id === userId) > 0,
+    toggleCredential: (userId, credentialId, isActive) => store.updateWhere('user_credentials', (r) => r.id === credentialId && r.user_id === userId, { is_active: Boolean(isActive) }) > 0,
 };
+// ---------------------------------------------------------------------------
+// Notification preferences
+// ---------------------------------------------------------------------------
 const DEFAULT_NOTIFICATION_PREFERENCES = {
-    channels: {
-        inApp: false,
-        webPush: false
-    },
-    events: {
-        actionRequired: true,
-        stop: true,
-        error: true
-    }
+    channels: { inApp: false, webPush: false },
+    events: { actionRequired: true, stop: true, error: true },
 };
 const normalizeNotificationPreferences = (value) => {
     const source = value && typeof value === 'object' ? value : {};
     return {
         channels: {
             inApp: source.channels?.inApp === true,
-            webPush: source.channels?.webPush === true
+            webPush: source.channels?.webPush === true,
         },
         events: {
             actionRequired: source.events?.actionRequired !== false,
             stop: source.events?.stop !== false,
-            error: source.events?.error !== false
-        }
+            error: source.events?.error !== false,
+        },
     };
 };
 const notificationPreferencesDb = {
     getPreferences: (userId) => {
+        const row = store.findWhere('user_notification_preferences', (r) => r.user_id === userId);
+        if (!row) {
+            const defaults = normalizeNotificationPreferences(DEFAULT_NOTIFICATION_PREFERENCES);
+            store.insert('user_notification_preferences', {
+                user_id: userId,
+                preferences_json: JSON.stringify(defaults),
+                updated_at: nowIso(),
+            }, { autoId: false });
+            return defaults;
+        }
         try {
-            const row = db.prepare('SELECT preferences_json FROM user_notification_preferences WHERE user_id = ?').get(userId);
-            if (!row) {
-                const defaults = normalizeNotificationPreferences(DEFAULT_NOTIFICATION_PREFERENCES);
-                db.prepare('INSERT INTO user_notification_preferences (user_id, preferences_json, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)').run(userId, JSON.stringify(defaults));
-                return defaults;
-            }
-            let parsed;
-            try {
-                parsed = JSON.parse(row.preferences_json);
-            }
-            catch {
-                parsed = DEFAULT_NOTIFICATION_PREFERENCES;
-            }
-            return normalizeNotificationPreferences(parsed);
+            return normalizeNotificationPreferences(JSON.parse(row.preferences_json));
         }
-        catch (err) {
-            throw err;
+        catch {
+            return normalizeNotificationPreferences(DEFAULT_NOTIFICATION_PREFERENCES);
         }
     },
     updatePreferences: (userId, preferences) => {
-        try {
-            const normalized = normalizeNotificationPreferences(preferences);
-            db.prepare(`INSERT INTO user_notification_preferences (user_id, preferences_json, updated_at)
-         VALUES (?, ?, CURRENT_TIMESTAMP)
-         ON CONFLICT(user_id) DO UPDATE SET
-           preferences_json = excluded.preferences_json,
-           updated_at = CURRENT_TIMESTAMP`).run(userId, JSON.stringify(normalized));
-            return normalized;
-        }
-        catch (err) {
-            throw err;
-        }
-    }
+        const normalized = normalizeNotificationPreferences(preferences);
+        store.upsertWhere('user_notification_preferences', (r) => r.user_id === userId, { user_id: userId, preferences_json: JSON.stringify(normalized), updated_at: nowIso() });
+        return normalized;
+    },
 };
+// ---------------------------------------------------------------------------
+// Push subscriptions
+// ---------------------------------------------------------------------------
 const pushSubscriptionsDb = {
     saveSubscription: (userId, endpoint, keysP256dh, keysAuth) => {
-        try {
-            db.prepare(`INSERT INTO push_subscriptions (user_id, endpoint, keys_p256dh, keys_auth)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(endpoint) DO UPDATE SET
-           user_id = excluded.user_id,
-           keys_p256dh = excluded.keys_p256dh,
-           keys_auth = excluded.keys_auth`).run(userId, endpoint, keysP256dh, keysAuth);
-        }
-        catch (err) {
-            throw err;
-        }
-    },
-    getSubscriptions: (userId) => {
-        try {
-            return db.prepare('SELECT endpoint, keys_p256dh, keys_auth FROM push_subscriptions WHERE user_id = ?').all(userId);
-        }
-        catch (err) {
-            throw err;
+        // The old SQL path upserted on `endpoint`, updating user_id as
+        // well. Preserve that exact behaviour.
+        const existing = store.findWhere('push_subscriptions', (r) => r.endpoint === endpoint);
+        if (existing) {
+            store.updateWhere('push_subscriptions', (r) => r.endpoint === endpoint, {
+                user_id: userId,
+                keys_p256dh: keysP256dh,
+                keys_auth: keysAuth,
+            });
+            return;
         }
-    },
+        store.insert('push_subscriptions', {
+            user_id: userId,
+            endpoint,
+            keys_p256dh: keysP256dh,
+            keys_auth: keysAuth,
+            created_at: nowIso(),
+        });
+    },
+    getSubscriptions: (userId) => store.filterWhere('push_subscriptions', (r) => r.user_id === userId).map((r) => ({
+        endpoint: r.endpoint,
+        keys_p256dh: r.keys_p256dh,
+        keys_auth: r.keys_auth,
+    })),
     removeSubscription: (endpoint) => {
-        try {
-            db.prepare('DELETE FROM push_subscriptions WHERE endpoint = ?').run(endpoint);
-        }
-        catch (err) {
-            throw err;
-        }
+        store.deleteWhere('push_subscriptions', (r) => r.endpoint === endpoint);
     },
     removeAllForUser: (userId) => {
-        try {
-            db.prepare('DELETE FROM push_subscriptions WHERE user_id = ?').run(userId);
-        }
-        catch (err) {
-            throw err;
-        }
-    }
+        store.deleteWhere('push_subscriptions', (r) => r.user_id === userId);
+    },
+};
+// ---------------------------------------------------------------------------
+// VAPID key storage (for web push)
+// ---------------------------------------------------------------------------
+const vapidKeysDb = {
+    getLatest: () => {
+        if (store.raw.vapid_keys.length === 0)
+            return null;
+        // Mirror ORDER BY id DESC LIMIT 1 — take the newest row.
+        const rows = store.raw.vapid_keys.slice().sort((a, b) => b.id - a.id);
+        return { public_key: rows[0].public_key, private_key: rows[0].private_key };
+    },
+    insert: (publicKey, privateKey) => {
+        store.insert('vapid_keys', {
+            public_key: publicKey,
+            private_key: privateKey,
+            created_at: nowIso(),
+        });
+    },
 };
-// Session custom names database operations
+// ---------------------------------------------------------------------------
+// Session custom names
+// ---------------------------------------------------------------------------
 const sessionNamesDb = {
-    // Set (insert or update) a custom session name
     setName: (sessionId, provider, customName) => {
-        db.prepare(`
-      INSERT INTO session_names (session_id, provider, custom_name)
-      VALUES (?, ?, ?)
-      ON CONFLICT(session_id, provider)
-      DO UPDATE SET custom_name = excluded.custom_name, updated_at = CURRENT_TIMESTAMP
-    `).run(sessionId, provider, customName);
-    },
-    // Get a single custom session name
+        store.upsertWhere('session_names', (r) => r.session_id === sessionId && r.provider === provider, { session_id: sessionId, provider, custom_name: customName, updated_at: nowIso(), created_at: nowIso() });
+    },
     getName: (sessionId, provider) => {
-        const row = db.prepare('SELECT custom_name FROM session_names WHERE session_id = ? AND provider = ?').get(sessionId, provider);
+        const row = store.findWhere('session_names', (r) => r.session_id === sessionId && r.provider === provider);
         return row?.custom_name || null;
     },
-    // Batch lookup — returns Map<sessionId, customName>
     getNames: (sessionIds, provider) => {
         if (!sessionIds.length)
             return new Map();
-        const placeholders = sessionIds.map(() => '?').join(',');
-        const rows = db.prepare(`SELECT session_id, custom_name FROM session_names
-       WHERE session_id IN (${placeholders}) AND provider = ?`).all(...sessionIds, provider);
-        return new Map(rows.map(r => [r.session_id, r.custom_name]));
-    },
-    // Delete a custom session name
-    deleteName: (sessionId, provider) => {
-        return db.prepare('DELETE FROM session_names WHERE session_id = ? AND provider = ?').run(sessionId, provider).changes > 0;
+        const lookup = new Set(sessionIds);
+        const matches = store.filterWhere('session_names', (r) => r.provider === provider && lookup.has(r.session_id));
+        return new Map(matches.map((r) => [r.session_id, r.custom_name]));
     },
+    deleteName: (sessionId, provider) => store.deleteWhere('session_names', (r) => r.session_id === sessionId && r.provider === provider) > 0,
 };
-// Apply custom session names from the database (overrides CLI-generated summaries)
 function applyCustomSessionNames(sessions, provider) {
     if (!sessions?.length)
         return;
     try {
-        const ids = sessions.map(s => s.id);
+        const ids = sessions.map((s) => s.id);
         const customNames = sessionNamesDb.getNames(ids, provider);
         for (const session of sessions) {
             const custom = customNames.get(session.id);
@@ -493,19 +575,16 @@ function applyCustomSessionNames(sessions, provider) {
         console.warn(`[DB] Failed to apply custom session names for ${provider}:`, error.message);
     }
 }
-// App config database operations
+// ---------------------------------------------------------------------------
+// App config (key/value)
+// ---------------------------------------------------------------------------
 const appConfigDb = {
     get: (key) => {
-        try {
-            const row = db.prepare('SELECT value FROM app_config WHERE key = ?').get(key);
-            return row?.value || null;
-        }
-        catch (err) {
-            return null;
-        }
+        const row = store.findWhere('app_config', (r) => r.key === key);
+        return row?.value || null;
     },
     set: (key, value) => {
-        db.prepare('INSERT INTO app_config (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value').run(key, value);
+        store.upsertWhere('app_config', (r) => r.key === key, { key, value, created_at: nowIso() });
     },
     getOrCreateJwtSecret: () => {
         let secret = appConfigDb.get('jwt_secret');
@@ -514,114 +593,117 @@ const appConfigDb = {
             appConfigDb.set('jwt_secret', secret);
         }
         return secret;
-    }
+    },
 };
-// Telegram integration database operations
+// ---------------------------------------------------------------------------
+// Telegram — singleton config + per-user links
+// ---------------------------------------------------------------------------
 const telegramConfigDb = {
     get: () => {
-        try {
-            return db.prepare('SELECT bot_token, bot_username, updated_at FROM telegram_config WHERE id = 1').get() || null;
-        }
-        catch (err) {
-            console.warn('telegramConfigDb.get failed:', err.message);
+        const row = store.raw.telegram_config[0];
+        if (!row)
             return null;
-        }
+        return { bot_token: row.bot_token, bot_username: row.bot_username, updated_at: row.updated_at };
     },
     set: (botToken, botUsername = null) => {
-        db.prepare(`INSERT INTO telegram_config (id, bot_token, bot_username, updated_at)
-       VALUES (1, ?, ?, CURRENT_TIMESTAMP)
-       ON CONFLICT(id) DO UPDATE SET
-         bot_token = excluded.bot_token,
-         bot_username = excluded.bot_username,
-         updated_at = CURRENT_TIMESTAMP`).run(botToken, botUsername);
+        store.raw.telegram_config = [{
+                id: 1,
+                bot_token: botToken,
+                bot_username: botUsername,
+                updated_at: nowIso(),
+            }];
+        store.save();
     },
     clear: () => {
-        db.prepare('DELETE FROM telegram_config WHERE id = 1').run();
+        store.raw.telegram_config = [];
+        store.save();
     },
 };
 const telegramLinksDb = {
-    // Write a fresh pairing code for a user and wipe any prior verification —
-    // regenerating a code implies "start over", not "keep the old binding".
     setPairingCode: (userId, code, expiresAt, language) => {
-        db.prepare(`INSERT INTO telegram_links (user_id, pairing_code, pairing_code_expires_at, language, updated_at)
-       VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
-       ON CONFLICT(user_id) DO UPDATE SET
-         pairing_code = excluded.pairing_code,
-         pairing_code_expires_at = excluded.pairing_code_expires_at,
-         language = excluded.language,
-         chat_id = NULL,
-         telegram_username = NULL,
-         verified_at = NULL,
-         updated_at = CURRENT_TIMESTAMP`).run(userId, code, expiresAt, language);
+        store.upsertWhere('telegram_links', (r) => r.user_id === userId, {
+            user_id: userId,
+            pairing_code: code,
+            pairing_code_expires_at: expiresAt,
+            language,
+            chat_id: null,
+            telegram_username: null,
+            verified_at: null,
+            notifications_enabled: true,
+            bridge_enabled: true,
+            updated_at: nowIso(),
+        });
     },
     findByPairingCode: (code) => {
-        return db.prepare(`SELECT user_id, pairing_code, pairing_code_expires_at, language
-       FROM telegram_links WHERE pairing_code = ?`).get(code) || null;
+        const row = store.findWhere('telegram_links', (r) => r.pairing_code === code);
+        if (!row)
+            return null;
+        return {
+            user_id: row.user_id,
+            pairing_code: row.pairing_code,
+            pairing_code_expires_at: row.pairing_code_expires_at,
+            language: row.language,
+        };
     },
     verify: (userId, chatId, telegramUsername) => {
-        db.prepare(`UPDATE telegram_links
-       SET chat_id = ?, telegram_username = ?, verified_at = CURRENT_TIMESTAMP,
-           pairing_code = NULL, pairing_code_expires_at = NULL, updated_at = CURRENT_TIMESTAMP
-       WHERE user_id = ?`).run(chatId, telegramUsername, userId);
+        store.updateWhere('telegram_links', (r) => r.user_id === userId, {
+            chat_id: chatId,
+            telegram_username: telegramUsername,
+            verified_at: nowIso(),
+            pairing_code: null,
+            pairing_code_expires_at: null,
+            updated_at: nowIso(),
+        });
     },
     getByUserId: (userId) => {
-        return db.prepare(`SELECT user_id, chat_id, telegram_username, language, pairing_code, pairing_code_expires_at,
-              verified_at, notifications_enabled, bridge_enabled, updated_at
-       FROM telegram_links WHERE user_id = ?`).get(userId) || null;
+        const row = store.findWhere('telegram_links', (r) => r.user_id === userId);
+        return row ? { ...row } : null;
     },
     getByChatId: (chatId) => {
-        return db.prepare(`SELECT user_id, chat_id, telegram_username, language, notifications_enabled, bridge_enabled
-       FROM telegram_links WHERE chat_id = ?`).get(chatId) || null;
-    },
-    listVerified: () => {
-        return db.prepare(`SELECT user_id, chat_id, telegram_username, language, notifications_enabled, bridge_enabled
-       FROM telegram_links WHERE chat_id IS NOT NULL AND verified_at IS NOT NULL`).all();
-    },
+        const row = store.findWhere('telegram_links', (r) => r.chat_id === chatId);
+        if (!row)
+            return null;
+        return {
+            user_id: row.user_id,
+            chat_id: row.chat_id,
+            telegram_username: row.telegram_username,
+            language: row.language,
+            notifications_enabled: row.notifications_enabled,
+            bridge_enabled: row.bridge_enabled,
+        };
+    },
+    listVerified: () => store.filterWhere('telegram_links', (r) => r.chat_id && r.verified_at).map((r) => ({
+        user_id: r.user_id,
+        chat_id: r.chat_id,
+        telegram_username: r.telegram_username,
+        language: r.language,
+        notifications_enabled: r.notifications_enabled,
+        bridge_enabled: r.bridge_enabled,
+    })),
     updatePreferences: (userId, { language, notificationsEnabled, bridgeEnabled }) => {
-        // Only update keys the caller provided — partial updates are expected
-        // from the UI (toggling one switch at a time).
-        const sets = [];
-        const params = [];
-        if (language !== undefined) {
-            sets.push('language = ?');
-            params.push(language);
-        }
-        if (notificationsEnabled !== undefined) {
-            sets.push('notifications_enabled = ?');
-            params.push(notificationsEnabled ? 1 : 0);
-        }
-        if (bridgeEnabled !== undefined) {
-            sets.push('bridge_enabled = ?');
-            params.push(bridgeEnabled ? 1 : 0);
-        }
-        if (!sets.length)
-            return;
-        sets.push('updated_at = CURRENT_TIMESTAMP');
-        params.push(userId);
-        db.prepare(`UPDATE telegram_links SET ${sets.join(', ')} WHERE user_id = ?`).run(...params);
+        const patch = { updated_at: nowIso() };
+        if (language !== undefined)
+            patch.language = language;
+        if (notificationsEnabled !== undefined)
+            patch.notifications_enabled = Boolean(notificationsEnabled);
+        if (bridgeEnabled !== undefined)
+            patch.bridge_enabled = Boolean(bridgeEnabled);
+        if (Object.keys(patch).length === 1)
+            return; // only updated_at → no real change
+        store.updateWhere('telegram_links', (r) => r.user_id === userId, patch);
     },
     unlink: (userId) => {
-        db.prepare('DELETE FROM telegram_links WHERE user_id = ?').run(userId);
+        store.deleteWhere('telegram_links', (r) => r.user_id === userId);
     },
 };
-// Backward compatibility - keep old names pointing to new system
+// Back-compat surface — older callers used `githubTokensDb.*`; internally
+// they always delegated to credentialsDb with `credential_type='github_token'`.
 const githubTokensDb = {
-    createGithubToken: (userId, tokenName, githubToken, description = null) => {
-        return credentialsDb.createCredential(userId, tokenName, 'github_token', githubToken, description);
-    },
-    getGithubTokens: (userId) => {
-        return credentialsDb.getCredentials(userId, 'github_token');
-    },
-    getActiveGithubToken: (userId) => {
-        return credentialsDb.getActiveCredential(userId, 'github_token');
-    },
-    deleteGithubToken: (userId, tokenId) => {
-        return credentialsDb.deleteCredential(userId, tokenId);
-    },
-    toggleGithubToken: (userId, tokenId, isActive) => {
-        return credentialsDb.toggleCredential(userId, tokenId, isActive);
-    }
+    createGithubToken: (userId, tokenName, githubToken, description = null) => credentialsDb.createCredential(userId, tokenName, 'github_token', githubToken, description),
+    getGithubTokens: (userId) => credentialsDb.getCredentials(userId, 'github_token'),
+    getActiveGithubToken: (userId) => credentialsDb.getActiveCredential(userId, 'github_token'),
+    deleteGithubToken: (userId, tokenId) => credentialsDb.deleteCredential(userId, tokenId),
+    toggleGithubToken: (userId, tokenId, isActive) => credentialsDb.toggleCredential(userId, tokenId, isActive),
 };
-export { db, initializeDatabase, userDb, apiKeysDb, credentialsDb, notificationPreferencesDb, pushSubscriptionsDb, sessionNamesDb, applyCustomSessionNames, appConfigDb, telegramConfigDb, telegramLinksDb, githubTokensDb // Backward compatibility
- };
+export { db, initializeDatabase, userDb, apiKeysDb, credentialsDb, notificationPreferencesDb, pushSubscriptionsDb, vapidKeysDb, sessionNamesDb, applyCustomSessionNames, appConfigDb, telegramConfigDb, telegramLinksDb, githubTokensDb, };
 //# sourceMappingURL=db.js.map