ani-web 1.5.8

package/server/dist/server.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+process.setMaxListeners(100);
+const events_1 = require("events");
+events_1.EventEmitter.defaultMaxListeners = 100;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const cors_1 = __importDefault(require("cors"));
+const compression_1 = __importDefault(require("compression"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const fs_1 = __importDefault(require("fs"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const logger_1 = __importDefault(require("./logger"));
+const allanime_provider_1 = require("./providers/allanime.provider");
+const animepahe_provider_1 = require("./providers/animepahe.provider");
+const _123anime_provider_1 = require("./providers/123anime.provider");
+const animeya_provider_1 = require("./providers/animeya.provider");
+const config_1 = require("./config");
+const sync_1 = require("./sync");
+const auth_routes_1 = require("./routes/auth.routes");
+const watchlist_routes_1 = require("./routes/watchlist.routes");
+const data_routes_1 = require("./routes/data.routes");
+const proxy_routes_1 = require("./routes/proxy.routes");
+const settings_routes_1 = require("./routes/settings.routes");
+const insights_routes_1 = require("./routes/insights.routes");
+const app = (0, express_1.default)();
+const apiCache = new node_cache_1.default({ stdTTL: 3600 });
+const allAnimeProvider = new allanime_provider_1.AllAnimeProvider(apiCache);
+const animePaheProvider = new animepahe_provider_1.AnimePaheProvider(apiCache);
+const _123AnimeProvider = new _123anime_provider_1._123AnimeProvider(apiCache);
+const animeyaProvider = new animeya_provider_1.AnimeyaProvider(apiCache);
+const providers = {
+    allanime: allAnimeProvider,
+    animepahe: animePaheProvider,
+    '123anime': _123AnimeProvider,
+    animeya: animeyaProvider,
+};
+let db;
+let isShuttingDown = false;
+async function runSyncSequence(database) {
+    const dbName = config_1.CONFIG.IS_DEV ? config_1.CONFIG.DB_NAME_DEV : config_1.CONFIG.DB_NAME_PROD;
+    const dbPath = path_1.default.join(config_1.CONFIG.ROOT, dbName);
+    const remoteFolder = config_1.CONFIG.IS_DEV ? config_1.CONFIG.REMOTE_FOLDER_DEV : config_1.CONFIG.REMOTE_FOLDER_PROD;
+    await (0, sync_1.initSyncProvider)();
+    const didDownload = await (0, sync_1.syncDownOnBoot)(database, dbPath, remoteFolder, () => {
+        return new Promise((resolve) => {
+            if (database && !database.isClosedCheck()) {
+                database.checkpoint();
+                database.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+    if (didDownload) {
+        db = await (0, sync_1.initializeDatabase)(dbPath);
+        logger_1.default.info('Database re-initialized after sync.');
+    }
+}
+app.use((req, res, next) => {
+    if (isShuttingDown) {
+        return res.status(503).send('Server is shutting down...');
+    }
+    if (!db) {
+        return res.status(503).send('Database initializing...');
+    }
+    req.db = db;
+    next();
+});
+// axiosRetry is applied only on the dedicated proxy axiosInstance (proxy.controller.ts)
+// to avoid amplifying retries on providers that already have their own fallback logic.
+app.use((0, compression_1.default)({
+    level: 2,
+    threshold: 1024,
+    filter: (req, res) => {
+        if (req.headers['x-no-compression']) {
+            return false;
+        }
+        return compression_1.default.filter(req, res);
+    },
+}));
+app.use((0, cors_1.default)());
+app.use(express_1.default.json({ limit: '10mb' }));
+app.use('/api/auth', (0, auth_routes_1.createAuthRouter)((database) => runSyncSequence(database)));
+app.use('/api', (0, watchlist_routes_1.createWatchlistRouter)(allAnimeProvider));
+app.use('/api', (0, data_routes_1.createDataRouter)(apiCache, providers));
+app.use('/api', (0, proxy_routes_1.createProxyRouter)());
+app.use('/api', (0, insights_routes_1.createInsightsRouter)(allAnimeProvider));
+app.use('/api', (0, settings_routes_1.createSettingsRouter)(allAnimeProvider, () => db, sync_1.initializeDatabase, (newDb) => {
+    db = newDb;
+}));
+if (!config_1.CONFIG.IS_DEV) {
+    const frontendPath = path_1.default.join(config_1.CONFIG.PACKAGE_ROOT, 'client', 'dist');
+    logger_1.default.info(`Serving frontend from: ${frontendPath}`);
+    app.use(express_1.default.static(frontendPath));
+    app.get(/^(?!\/api).+/, (req, res) => {
+        res.sendFile('index.html', { root: frontendPath }, (err) => {
+            if (err) {
+                logger_1.default.error({ err }, `Failed to serve index.html from ${frontendPath}`);
+                if (!res.headersSent) {
+                    res.status(500).send('Server Error: Frontend build not found.');
+                }
+            }
+        });
+    });
+}
+async function main() {
+    logger_1.default.info('DEBUG: main() started');
+    const dbName = config_1.CONFIG.IS_DEV ? config_1.CONFIG.DB_NAME_DEV : config_1.CONFIG.DB_NAME_PROD;
+    const dbPath = path_1.default.join(config_1.CONFIG.ROOT, dbName);
+    const remoteFolder = config_1.CONFIG.IS_DEV ? config_1.CONFIG.REMOTE_FOLDER_DEV : config_1.CONFIG.REMOTE_FOLDER_PROD;
+    db = await (0, sync_1.initializeDatabase)(dbPath);
+    logger_1.default.info(`Database initialized at ${dbPath}`);
+    await runSyncSequence(db);
+    if (!fs_1.default.existsSync(config_1.CONFIG.LOCAL_MANIFEST_PATH)) {
+        fs_1.default.writeFileSync(config_1.CONFIG.LOCAL_MANIFEST_PATH, JSON.stringify({ version: 0 }));
+    }
+    const watcher = chokidar_1.default.watch(config_1.CONFIG.LOCAL_MANIFEST_PATH, {
+        persistent: true,
+        ignoreInitial: true,
+    });
+    let debounceTimer;
+    const expressServer = app.listen(config_1.CONFIG.PORT, () => {
+        logger_1.default.info(`Server running on http://localhost:${config_1.CONFIG.PORT}`);
+    });
+    watcher.on('change', () => {
+        clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => (0, sync_1.syncUp)(db, dbPath, remoteFolder), 30000);
+    });
+    const shutdown = async (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        clearTimeout(debounceTimer);
+        // Close the watcher first to prevent a stale 'change' event from arming
+        // a new debounce timer that would call syncUp on an already-closed database.
+        await watcher.close();
+        if (expressServer) {
+            expressServer.close();
+        }
+        try {
+            await (0, sync_1.syncUp)(db, dbPath, remoteFolder);
+        }
+        catch (e) {
+            console.error('Sync failed:', e);
+        }
+        db.close(() => {
+            console.log('[SERVER_EXIT]');
+            setTimeout(() => {
+                if (signal === 'SIGUSR2') {
+                    process.kill(process.pid, 'SIGUSR2');
+                }
+                else {
+                    process.exit(0);
+                }
+            }, 600);
+        });
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.once('SIGUSR2', () => shutdown('SIGUSR2'));
+    app.post('/api/internal/shutdown', (req, res) => {
+        if (req.ip === '::1' || req.ip === '127.0.0.1' || req.ip === '::ffff:127.0.0.1') {
+            res.status(200).json({ message: 'Shutting down' });
+            setTimeout(() => shutdown(), 500);
+        }
+        else {
+            res.status(403).send('Forbidden');
+        }
+    });
+}
+main().catch((err) => {
+    console.error('Server failed to start:', err);
+    process.exit(1);
+});

package/server/dist/sync-config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setActiveRemote = setActiveRemote;
+exports.getActiveRemote = getActiveRemote;
+exports.initialize = initialize;
+exports.getRemoteString = getRemoteString;
+const log = (message) => console.log(`[Sync Config] ${new Date().toISOString()} - ${message}`);
+let activeRemote;
+function setActiveRemote(remote) {
+    log(`Setting active sync remote to: ${remote}`);
+    activeRemote = remote;
+}
+function getActiveRemote() {
+    return activeRemote;
+}
+async function initialize() {
+    if (activeRemote !== 'gdrive') {
+        log('Active remote is not gdrive, skipping gdrive-specific initialization.');
+        return;
+    }
+    log('gdrive is the active remote.');
+}
+function getRemoteString(remoteDir) {
+    if (!activeRemote) {
+        throw new Error('Cannot get remote string: active remote is not set.');
+    }
+    return `${activeRemote}:${remoteDir}`;
+}

package/server/dist/sync.js

@@ -0,0 +1,383 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSyncProvider = initSyncProvider;
+exports.getLocalManifestVersion = getLocalManifestVersion;
+exports.setLocalManifestVersion = setLocalManifestVersion;
+exports.syncDownOnBoot = syncDownOnBoot;
+exports.syncUp = syncUp;
+exports.performWriteTransaction = performWriteTransaction;
+exports.initializeDatabase = initializeDatabase;
+const fs = __importStar(require("fs/promises"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const logger_1 = __importDefault(require("./logger"));
+const google_1 = require("./google");
+const rclone_1 = require("./rclone");
+const github_sync_1 = require("./github-sync");
+const config_1 = require("./config");
+const db_1 = require("./db");
+const db_utils_1 = require("./utils/db-utils");
+const log = logger_1.default.child({ module: 'Sync' });
+class Mutex {
+    _locked = false;
+    _waiting = [];
+    async lock() {
+        return new Promise((resolve) => {
+            if (!this._locked) {
+                this._locked = true;
+                resolve();
+            }
+            else {
+                this._waiting.push(resolve);
+            }
+        });
+    }
+    unlock() {
+        if (this._waiting.length > 0) {
+            const resolve = this._waiting.shift();
+            resolve();
+        }
+        else {
+            this._locked = false;
+        }
+    }
+}
+const syncMutex = new Mutex();
+let isSyncing = false;
+let activeProvider = 'none';
+async function initSyncProvider() {
+    if (github_sync_1.githubSyncService.isAuthenticated()) {
+        activeProvider = 'github';
+        log.info('Sync Provider: GitHub');
+        return;
+    }
+    if (google_1.googleDriveService.isAuthenticated()) {
+        activeProvider = 'google';
+        log.info('Sync Provider: Google Drive API');
+        return;
+    }
+    const rcloneAvailable = await rclone_1.rcloneService.init();
+    if (rcloneAvailable) {
+        activeProvider = 'rclone';
+        log.info(`Sync Provider: Rclone (${rclone_1.rcloneService.getRemoteName()})`);
+        return;
+    }
+    activeProvider = 'none';
+    log.info('No sync provider available.');
+}
+async function getLocalManifestVersion() {
+    if ((0, fs_1.existsSync)(config_1.CONFIG.LOCAL_MANIFEST_PATH)) {
+        try {
+            const content = await fs.readFile(config_1.CONFIG.LOCAL_MANIFEST_PATH, 'utf-8');
+            return JSON.parse(content).version || 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    return 0;
+}
+async function setLocalManifestVersion(version) {
+    await fs.writeFile(config_1.CONFIG.LOCAL_MANIFEST_PATH, JSON.stringify({ version }));
+}
+async function getRemoteManifestVersion(remoteFolder) {
+    try {
+        if (activeProvider === 'github') {
+            return { version: await github_sync_1.githubSyncService.getRemoteVersion() };
+        }
+        else if (activeProvider === 'google') {
+            const folderId = await google_1.googleDriveService.ensureFolder(remoteFolder);
+            const file = await google_1.googleDriveService.findFile(config_1.CONFIG.MANIFEST_FILENAME, folderId);
+            if (!file)
+                return { version: 0 };
+            const tempPath = path_1.default.join(config_1.CONFIG.ROOT, `temp_${Date.now()}_manifest.json`);
+            try {
+                await google_1.googleDriveService.downloadFile(file.id, tempPath);
+                const content = await fs.readFile(tempPath, 'utf-8');
+                return { version: JSON.parse(content).version || 0, fileId: file.id };
+            }
+            finally {
+                if ((0, fs_1.existsSync)(tempPath))
+                    await fs.unlink(tempPath);
+            }
+        }
+        else if (activeProvider === 'rclone') {
+            const exists = await rclone_1.rcloneService.fileExists(remoteFolder, config_1.CONFIG.MANIFEST_FILENAME);
+            if (!exists)
+                return { version: 0 };
+            const tempPath = path_1.default.join(config_1.CONFIG.ROOT, `temp_${Date.now()}_manifest.json`);
+            try {
+                await rclone_1.rcloneService.downloadFile(remoteFolder, config_1.CONFIG.MANIFEST_FILENAME, tempPath);
+                const content = await fs.readFile(tempPath, 'utf-8');
+                return { version: JSON.parse(content).version || 0 };
+            }
+            finally {
+                if ((0, fs_1.existsSync)(tempPath))
+                    await fs.unlink(tempPath);
+            }
+        }
+    }
+    catch (err) {
+        log.warn({ err }, 'Could not read remote manifest.');
+    }
+    return { version: 0 };
+}
+async function syncDownOnBoot(db, dbPath, remoteFolderName, closeMainDb) {
+    let localVersion = await getLocalManifestVersion();
+    if (localVersion === 0 && db) {
+        const row = await (0, db_utils_1.dbGet)(db, "SELECT value FROM sync_metadata WHERE key = 'db_version'");
+        localVersion = row?.value ?? 0;
+        if (localVersion > 0) {
+            await setLocalManifestVersion(localVersion);
+        }
+    }
+    if (activeProvider === 'none')
+        return false;
+    await syncMutex.lock();
+    if (isSyncing) {
+        syncMutex.unlock();
+        return false;
+    }
+    isSyncing = true;
+    try {
+        console.log(`[SYNC_START] Initial sync check (${activeProvider})`);
+        const { version: remoteVersion } = await getRemoteManifestVersion(remoteFolderName);
+        console.log('[SYNC_END]');
+        log.info(`Sync Check: Local v${localVersion} vs Remote v${remoteVersion}`);
+        if (remoteVersion > localVersion) {
+            if (activeProvider === 'github') {
+                console.log(`[SYNC_START] Importing GitHub sync data (Remote v${remoteVersion})`);
+                const importedVersion = await github_sync_1.githubSyncService.syncDown(db);
+                await setLocalManifestVersion(importedVersion || remoteVersion);
+                console.log('[SYNC_END]');
+                log.info('GitHub sync down complete.');
+                return false;
+            }
+            console.log(`[SYNC_START] Downloading remote database (Remote v${remoteVersion})`);
+            await closeMainDb();
+            const backupPath = `${dbPath}.bak`;
+            const dbName = path_1.default.basename(dbPath);
+            try {
+                if ((0, fs_1.existsSync)(dbPath)) {
+                    await fs.copyFile(dbPath, backupPath);
+                }
+                try {
+                    await fs.unlink(`${dbPath}-wal`);
+                }
+                catch (e) {
+                    void e;
+                }
+                try {
+                    await fs.unlink(`${dbPath}-shm`);
+                }
+                catch (e) {
+                    void e;
+                }
+                if (activeProvider === 'google') {
+                    const folderId = await google_1.googleDriveService.ensureFolder(remoteFolderName);
+                    const remoteDb = await google_1.googleDriveService.findFile(dbName, folderId);
+                    const remoteManifest = await google_1.googleDriveService.findFile(config_1.CONFIG.MANIFEST_FILENAME, folderId);
+                    if (remoteDb)
+                        await google_1.googleDriveService.downloadFile(remoteDb.id, dbPath);
+                    if (remoteManifest)
+                        await google_1.googleDriveService.downloadFile(remoteManifest.id, config_1.CONFIG.LOCAL_MANIFEST_PATH);
+                }
+                else if (activeProvider === 'rclone') {
+                    await rclone_1.rcloneService.downloadFile(remoteFolderName, dbName, dbPath);
+                    await rclone_1.rcloneService.downloadFile(remoteFolderName, config_1.CONFIG.MANIFEST_FILENAME, config_1.CONFIG.LOCAL_MANIFEST_PATH);
+                }
+                if ((0, fs_1.existsSync)(backupPath)) {
+                    await fs.unlink(backupPath);
+                }
+                console.log('[SYNC_END]');
+                log.info('Sync down complete.');
+                return true;
+            }
+            catch (err) {
+                console.log('[SYNC_END]');
+                log.error({ err }, 'Sync down failed. Restoring backup.');
+                if ((0, fs_1.existsSync)(backupPath)) {
+                    try {
+                        await fs.copyFile(backupPath, dbPath);
+                        log.info('Backup restored successfully after failed sync down.');
+                    }
+                    catch (restoreErr) {
+                        log.error({ err: restoreErr }, 'Critical: restore from backup also failed.');
+                        // The DB may be corrupt – propagate so the caller can exit cleanly.
+                        throw new Error('Sync down and restore both failed. Database may be corrupt.', {
+                            cause: restoreErr,
+                        });
+                    }
+                }
+                // DB was already closed before the attempt; re-open is required regardless.
+                return true;
+            }
+        }
+        else {
+            log.info('Local DB is up to date.');
+            return false;
+        }
+    }
+    catch (err) {
+        console.log('[SYNC_END]');
+        log.error({ err }, 'Sync boot error.');
+        return false;
+    }
+    finally {
+        isSyncing = false;
+        syncMutex.unlock();
+    }
+}
+async function syncUp(db, dbPath, remoteFolderName) {
+    if (activeProvider === 'none')
+        return;
+    await syncMutex.lock();
+    if (isSyncing) {
+        syncMutex.unlock();
+        return;
+    }
+    isSyncing = true;
+    try {
+        const localVersion = await getLocalManifestVersion();
+        console.log(`[SYNC_START] Syncing up (Local v${localVersion})`);
+        const { version: remoteVersion, fileId: manifestId } = await getRemoteManifestVersion(remoteFolderName);
+        if (localVersion > remoteVersion) {
+            const dbName = path_1.default.basename(dbPath);
+            const syncDbPath = `${dbPath}.sync.db`;
+            try {
+                if (activeProvider === 'github') {
+                    await github_sync_1.githubSyncService.syncUp(db);
+                }
+                else {
+                    db.backup(syncDbPath);
+                }
+                if (activeProvider === 'google') {
+                    const folderId = await google_1.googleDriveService.ensureFolder(remoteFolderName);
+                    const remoteDbFile = await google_1.googleDriveService.findFile(dbName, folderId);
+                    await google_1.googleDriveService.uploadFile(syncDbPath, dbName, 'application/x-sqlite3', folderId, remoteDbFile?.id);
+                    await google_1.googleDriveService.uploadFile(config_1.CONFIG.LOCAL_MANIFEST_PATH, config_1.CONFIG.MANIFEST_FILENAME, 'application/json', folderId, manifestId);
+                }
+                else if (activeProvider === 'rclone') {
+                    await rclone_1.rcloneService.uploadFile(syncDbPath, remoteFolderName, dbName);
+                    await rclone_1.rcloneService.uploadFile(config_1.CONFIG.LOCAL_MANIFEST_PATH, remoteFolderName, config_1.CONFIG.MANIFEST_FILENAME);
+                }
+            }
+            finally {
+                if ((0, fs_1.existsSync)(syncDbPath))
+                    await fs.unlink(syncDbPath).catch(() => { });
+            }
+            console.log('[SYNC_END]');
+            log.info('Sync up complete.');
+        }
+        else {
+            console.log('[SYNC_END]');
+            log.info('No changes to sync up or remote is newer.');
+        }
+    }
+    catch (err) {
+        console.log('[SYNC_END]');
+        log.error({ err }, 'Sync up failed.');
+    }
+    finally {
+        isSyncing = false;
+        syncMutex.unlock();
+    }
+}
+async function performWriteTransaction(db, runnable) {
+    // node:sqlite is fully synchronous — serialize/run/get all complete before returning,
+    // so we can avoid the nested Promise/callback pattern that could hang forever if
+    // setLocalManifestVersion threw after resolve/reject was no longer reachable.
+    db.serialize(() => {
+        runnable(db);
+        db.run("UPDATE sync_metadata SET value = value + 1 WHERE key = 'db_version'");
+    });
+    // Capture version synchronously; the callback fires immediately with node:sqlite.
+    const row = await (0, db_utils_1.dbGet)(db, "SELECT value FROM sync_metadata WHERE key = 'db_version'");
+    const newVersion = row?.value ?? 1;
+    // Only the manifest write is truly async (disk I\O); errors here propagate normally.
+    await setLocalManifestVersion(newVersion);
+}
+async function initializeDatabase(dbPath) {
+    try {
+        const db = await db_1.DatabaseWrapper.create(dbPath);
+        db.configure('busyTimeout', 5000);
+        db.run('PRAGMA journal_mode = WAL;');
+        db.run('PRAGMA synchronous = NORMAL;');
+        db.run('PRAGMA cache_size = -20000;');
+        db.run('PRAGMA temp_store = MEMORY;');
+        db.run('PRAGMA mmap_size = 268435456;');
+        db.run('PRAGMA foreign_keys = ON;');
+        const initOpts = { skipSave: true };
+        db.run(`CREATE TABLE IF NOT EXISTS watchlist (id TEXT NOT NULL, name TEXT, thumbnail TEXT, status TEXT, nativeName TEXT, englishName TEXT, type TEXT, PRIMARY KEY (id))`, undefined, undefined, initOpts);
+        db.run(`CREATE TABLE IF NOT EXISTS watched_episodes (showId TEXT NOT NULL, episodeNumber TEXT NOT NULL, watchedAt DATETIME DEFAULT CURRENT_TIMESTAMP, currentTime REAL DEFAULT 0, duration REAL DEFAULT 0, PRIMARY KEY (showId, episodeNumber))`, undefined, undefined, initOpts);
+        db.run(`CREATE TABLE IF NOT EXISTS settings (key TEXT NOT NULL, value TEXT, PRIMARY KEY (key))`, undefined, undefined, initOpts);
+        db.run(`CREATE TABLE IF NOT EXISTS shows_meta (id TEXT PRIMARY KEY, name TEXT, thumbnail TEXT, nativeName TEXT, englishName TEXT, episodeCount INTEGER, status TEXT, genres TEXT, popularityScore INTEGER, type TEXT)`, undefined, undefined, initOpts);
+        db.run(`CREATE TABLE IF NOT EXISTS dismissed_notifications (showId TEXT NOT NULL, episodeNumber TEXT NOT NULL, dismissedAt DATETIME DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (showId, episodeNumber))`, undefined, undefined, initOpts);
+        db.run(`CREATE TABLE IF NOT EXISTS discovered_notifications (showId TEXT NOT NULL, episodeNumber TEXT NOT NULL, discoveredAt DATETIME DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (showId, episodeNumber))`, undefined, undefined, initOpts);
+        db.run(`CREATE TABLE IF NOT EXISTS sync_metadata (key TEXT PRIMARY KEY, value INTEGER)`, undefined, undefined, initOpts);
+        db.run(`INSERT OR IGNORE INTO sync_metadata (key, value) VALUES ('db_version', 1)`, undefined, undefined, initOpts);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_watched_episodes_showId ON watched_episodes(showId)`, undefined, undefined, initOpts);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_watched_episodes_showId_episodeNumber ON watched_episodes(showId, episodeNumber)`, undefined, undefined, initOpts);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_watched_episodes_watchedAt ON watched_episodes(watchedAt)`, undefined, undefined, initOpts);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_watchlist_status ON watchlist(status)`, undefined, undefined, initOpts);
+        const addCol = (tbl, col, type) => {
+            db.all(`PRAGMA table_info(${tbl})`, (e, r) => {
+                const columns = r;
+                if (!columns.some((c) => c.name === col))
+                    db.run(`ALTER TABLE ${tbl} ADD COLUMN ${col} ${type}`, undefined, undefined, initOpts);
+            });
+        };
+        addCol('watchlist', 'nativeName', 'TEXT');
+        addCol('watchlist', 'englishName', 'TEXT');
+        addCol('shows_meta', 'nativeName', 'TEXT');
+        addCol('shows_meta', 'englishName', 'TEXT');
+        addCol('shows_meta', 'episodeCount', 'INTEGER');
+        addCol('shows_meta', 'status', 'TEXT');
+        addCol('shows_meta', 'genres', 'TEXT');
+        addCol('shows_meta', 'popularityScore', 'INTEGER');
+        addCol('watchlist', 'type', 'TEXT');
+        addCol('shows_meta', 'type', 'TEXT');
+        await db.saveNow();
+        return db;
+    }
+    catch (err) {
+        log.error({ err }, 'Database opening error');
+        throw err;
+    }
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbRun = exports.dbGet = exports.dbAll = void 0;
+const dbAll = (db, sql, params = []) => {
+    return new Promise((resolve, reject) => {
+        db.all(sql, params, (err, rows) => {
+            if (err)
+                reject(err);
+            else
+                resolve(rows);
+        });
+    });
+};
+exports.dbAll = dbAll;
+const dbGet = (db, sql, params = []) => {
+    return new Promise((resolve, reject) => {
+        db.get(sql, params, (err, row) => {
+            if (err)
+                reject(err);
+            else
+                resolve(row);
+        });
+    });
+};
+exports.dbGet = dbGet;
+const dbRun = (db, sql, params = []) => {
+    return new Promise((resolve, reject) => {
+        db.run(sql, params, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+};
+exports.dbRun = dbRun;