ani-web 1.5.8

package/server/dist/providers/provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/dist/rclone.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rcloneService = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = __importDefault(require("./logger"));
+const config_1 = require("./config");
+class RcloneService {
+    activeRemote = null;
+    executeCommand(command) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(command, (err, stdout, stderr) => {
+                if (err) {
+                    if (stderr)
+                        logger_1.default.warn({ stderr }, 'Rclone command warning');
+                    return reject(new Error(stderr || err.message));
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+    executeRcloneArgs(args) {
+        return new Promise((resolve, reject) => {
+            const process = (0, child_process_1.spawn)('rclone', args, { stdio: 'ignore' });
+            process.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Rclone exited with code ${code}`));
+            });
+            process.on('error', (err) => reject(err));
+        });
+    }
+    async listRemotes() {
+        try {
+            const remotesStr = await this.executeCommand('rclone listremotes');
+            return remotesStr
+                .split('\n')
+                .map((r) => r.trim())
+                .filter((r) => r !== '')
+                .map((r) => r.replace(/:$/, ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    async init() {
+        try {
+            await this.executeCommand('rclone version');
+            const remotes = await this.listRemotes();
+            if (config_1.CONFIG.RCLONE_REMOTE) {
+                const found = remotes.find((r) => r.toLowerCase() === config_1.CONFIG.RCLONE_REMOTE?.toLowerCase());
+                if (found) {
+                    this.activeRemote = found;
+                    logger_1.default.info(`Rclone initialized with manual remote: ${this.activeRemote}`);
+                    return true;
+                }
+                else {
+                    logger_1.default.warn(`Configured RCLONE_REMOTE '${config_1.CONFIG.RCLONE_REMOTE}' not found in rclone listremotes.`);
+                }
+            }
+            if (remotes.length > 0 && !config_1.CONFIG.RCLONE_REMOTE) {
+                logger_1.default.info({ remotes }, 'Rclone available but no manual remote is configured in settings.');
+                return false;
+            }
+            return false;
+        }
+        catch (error) {
+            logger_1.default.warn({ err: error }, 'Rclone initialization failed');
+            return false;
+        }
+    }
+    isActive() {
+        return this.activeRemote !== null;
+    }
+    getRemoteName() {
+        return this.activeRemote || 'unknown';
+    }
+    async downloadFile(remoteFolder, fileName, localPath) {
+        if (!this.activeRemote)
+            throw new Error('Rclone not active');
+        const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+        await this.executeRcloneArgs(['copyto', remotePath, localPath]);
+    }
+    async uploadFile(localPath, remoteFolder, fileName) {
+        if (!this.activeRemote)
+            throw new Error('Rclone not active');
+        const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+        await this.executeRcloneArgs(['copyto', localPath, remotePath]);
+    }
+    executeRcloneArgsWithOutput(args) {
+        return new Promise((resolve, reject) => {
+            const process = (0, child_process_1.spawn)('rclone', args, { stdio: 'pipe' });
+            let stdout = '';
+            let stderr = '';
+            process.stdout?.on('data', (data) => (stdout += data));
+            process.stderr?.on('data', (data) => (stderr += data));
+            process.on('close', (code) => {
+                if (code === 0)
+                    resolve(stdout.trim());
+                else {
+                    if (stderr)
+                        logger_1.default.warn({ stderr }, 'Rclone command warning');
+                    reject(new Error(stderr || `Rclone exited with code ${code}`));
+                }
+            });
+            process.on('error', (err) => reject(err));
+        });
+    }
+    async fileExists(remoteFolder, fileName) {
+        if (!this.activeRemote)
+            return false;
+        try {
+            const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+            const output = await this.executeRcloneArgsWithOutput(['lsjson', remotePath]);
+            const json = JSON.parse(output);
+            return json && json.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.rcloneService = new RcloneService();

package/server/dist/repositories/insights.repository.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsightsRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.InsightsRepository = {
+    getCoreStats: (db) => (0, db_utils_1.dbGet)(db, `SELECT
+        (SELECT SUM(currentTime) FROM watched_episodes) as totalSeconds,
+        (SELECT COUNT(*) FROM watched_episodes) as totalEpisodes,
+        (SELECT COUNT(*) FROM watchlist WHERE status = 'Completed') as completedCount,
+        (SELECT COUNT(*) FROM watchlist) as totalWatchlist`),
+    getActivityGrid: (db) => (0, db_utils_1.dbAll)(db, `SELECT date(watchedAt) as day, COUNT(*) as count FROM watched_episodes GROUP BY day`),
+    getHourlyDist: (db) => (0, db_utils_1.dbAll)(db, `SELECT strftime('%H', watchedAt) as hour, COUNT(*) as count FROM watched_episodes GROUP BY hour`),
+    getSeasonality: (db) => (0, db_utils_1.dbAll)(db, `SELECT strftime('%m', watchedAt) as month, SUM(currentTime) as seconds FROM watched_episodes GROUP BY month`),
+    getAllWatches: (db) => (0, db_utils_1.dbAll)(db, 'SELECT watchedAt, currentTime FROM watched_episodes ORDER BY watchedAt ASC'),
+    getWatchedShowsMeta: (db) => (0, db_utils_1.dbAll)(db, `SELECT DISTINCT sm.id, sm.genres, sm.popularityScore
+      FROM shows_meta sm
+      JOIN watched_episodes we ON sm.id = we.showId`),
+    getDroppedShows: (db) => (0, db_utils_1.dbAll)(db, `SELECT w.id, w.name, MAX(we.watchedAt) as lastActivity
+        FROM watchlist w
+        JOIN watched_episodes we ON w.id = we.showId
+        WHERE w.status = 'Watching'
+        GROUP BY w.id
+        HAVING lastActivity < date('now', '-90 days')`),
+    getCompletionVelocities: (db) => (0, db_utils_1.dbAll)(db, `SELECT
+        (julianday(MAX(we.watchedAt)) - julianday(MIN(we.watchedAt))) as daysToFinish
+        FROM watchlist w
+        JOIN watched_episodes we ON w.id = we.showId
+        WHERE w.status = 'Completed'
+        GROUP BY w.id`),
+};

package/server/dist/repositories/notifications.repository.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.NotificationsRepository = {
+    getDismissedByShow: (db, showId) => (0, db_utils_1.dbAll)(db, 'SELECT episodeNumber FROM dismissed_notifications WHERE showId = ?', [showId]),
+    getDiscoveredByShow: (db, showId) => (0, db_utils_1.dbAll)(db, 'SELECT episodeNumber FROM discovered_notifications WHERE showId = ?', [showId]),
+    addDiscovered: (db, showId, episodeNumber) => (0, db_utils_1.dbRun)(db, 'INSERT OR IGNORE INTO discovered_notifications (showId, episodeNumber) VALUES (?, ?)', [showId, episodeNumber]),
+    addDismissed: (db, showId, episodeNumber) => (0, db_utils_1.dbRun)(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) VALUES (?, ?)', [showId, episodeNumber]),
+    dismissFromDiscovered: (db, showId) => {
+        if (showId) {
+            return (0, db_utils_1.dbRun)(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications WHERE showId = ?', [showId]);
+        }
+        else {
+            return (0, db_utils_1.dbRun)(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications');
+        }
+    },
+    deleteByShow: (db, showId) => Promise.all([
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM dismissed_notifications WHERE showId = ?', [showId]),
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM discovered_notifications WHERE showId = ?', [showId]),
+    ]),
+};

package/server/dist/repositories/settings.repository.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.SettingsRepository = {
+    getByKey: (db, key) => (0, db_utils_1.dbGet)(db, 'SELECT value FROM settings WHERE key = ?', [key]),
+    upsert: (db, key, value) => (0, db_utils_1.dbRun)(db, 'INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)', [key, value]),
+    clearWatchlist: (db) => (0, db_utils_1.dbRun)(db, 'DELETE FROM watchlist'),
+    upsertWatchlistBatch: (db, shows) => {
+        const stmt = db.prepare('INSERT OR REPLACE INTO watchlist (id, name, thumbnail, status) VALUES (?, ?, ?, ?)');
+        shows.forEach((show) => stmt.run(show.id, show.name, show.thumbnail, show.status));
+    },
+};

package/server/dist/repositories/shows-meta.repository.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowsMetaRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.ShowsMetaRepository = {
+    getById: (db, id) => (0, db_utils_1.dbGet)(db, 'SELECT * FROM shows_meta WHERE id = ?', [id]),
+    getStatus: async (db, id) => {
+        const row = await (0, db_utils_1.dbGet)(db, 'SELECT status FROM shows_meta WHERE id = ?', [
+            id,
+        ]);
+        return row?.status;
+    },
+    upsert: (db, data) => (0, db_utils_1.dbRun)(db, `INSERT INTO shows_meta (id, name, thumbnail, nativeName, englishName, genres, popularityScore, status, episodeCount, type)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = COALESCE(EXCLUDED.name, shows_meta.name),
+         thumbnail = COALESCE(EXCLUDED.thumbnail, shows_meta.thumbnail),
+         nativeName = COALESCE(EXCLUDED.nativeName, shows_meta.nativeName),
+         englishName = COALESCE(EXCLUDED.englishName, shows_meta.englishName),
+         genres = COALESCE(EXCLUDED.genres, shows_meta.genres),
+         popularityScore = COALESCE(EXCLUDED.popularityScore, shows_meta.popularityScore),
+         status = COALESCE(EXCLUDED.status, shows_meta.status),
+         episodeCount = COALESCE(EXCLUDED.episodeCount, shows_meta.episodeCount),
+         type = COALESCE(EXCLUDED.type, shows_meta.type)`, [
+        data.id,
+        data.name,
+        data.thumbnail,
+        data.nativeName || '',
+        data.englishName || '',
+        data.genres || '',
+        data.popularityScore || 0,
+        data.status || '',
+        data.episodeCount || 0,
+        data.type || '',
+    ]),
+    updateEpisodeCount: (db, id, episodeCount) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET episodeCount = ? WHERE id = ?', [episodeCount, id]),
+    updateType: (db, id, type) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET type = ? WHERE id = ?', [type, id]),
+    updateThumbnail: (db, id, thumbnail) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET thumbnail = ? WHERE id = ?', [thumbnail, id]),
+};

package/server/dist/repositories/watched-episodes.repository.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchedEpisodesRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.WatchedEpisodesRepository = {
+    getByShowAndEpisode: (db, showId, episodeNumber) => (0, db_utils_1.dbGet)(db, 'SELECT currentTime, duration FROM watched_episodes WHERE showId = ? AND episodeNumber = ?', [showId, episodeNumber]),
+    getWatchedEpisodeNumbers: async (db, showId) => {
+        const rows = await (0, db_utils_1.dbAll)(db, 'SELECT episodeNumber FROM watched_episodes WHERE showId = ?', [showId]);
+        return rows.map((r) => r.episodeNumber);
+    },
+    upsert: (db, data) => (0, db_utils_1.dbRun)(db, 'INSERT OR REPLACE INTO watched_episodes (showId, episodeNumber, watchedAt, currentTime, duration) VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?)', [data.showId, data.episodeNumber, data.currentTime, data.duration]),
+    deleteByShow: (db, showId) => (0, db_utils_1.dbRun)(db, 'DELETE FROM watched_episodes WHERE showId = ?', [showId]),
+    getContinueWatching: (db, limit) => {
+        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
+        const query = `
+      SELECT 
+        w.id as _id,
+        w.id as id,
+        w.name as name,
+        w.thumbnail as thumbnail,
+        w.nativeName as nativeName,
+        w.englishName as englishName,
+        w.type as type,
+        sm.episodeCount,
+        sm.type as smType,
+        (SELECT COUNT(DISTINCT episodeNumber) FROM watched_episodes WHERE showId = w.id) as watchedCount,
+        we.episodeNumber, we.currentTime, we.duration, we.watchedAt
+      FROM (
+        SELECT *, ROW_NUMBER() OVER(PARTITION BY showId ORDER BY watchedAt DESC) as rn
+        FROM watched_episodes
+      ) we
+      JOIN watchlist w ON we.showId = w.id
+      LEFT JOIN shows_meta sm ON we.showId = sm.id
+      WHERE we.rn = 1 AND w.status = 'Watching'
+      ORDER BY we.watchedAt DESC
+      ${limitClause}
+    `;
+        return (0, db_utils_1.dbAll)(db, query);
+    },
+    getUpNextShows: (db) => {
+        const query = `
+      SELECT w.id, w.name, w.thumbnail, w.nativeName, w.englishName, w.type, sm.episodeCount, sm.type as smType
+      FROM watchlist w
+      LEFT JOIN shows_meta sm ON w.id = sm.id
+      LEFT JOIN (
+        SELECT showId, MAX(watchedAt) as lastActivity
+        FROM watched_episodes
+        GROUP BY showId
+      ) we ON w.id = we.showId
+      WHERE w.status = 'Watching'
+      ORDER BY we.lastActivity DESC
+      LIMIT 15
+    `;
+        return (0, db_utils_1.dbAll)(db, query);
+    },
+    getEpisodesForShows: (db, showIds) => {
+        const placeholders = showIds.map(() => '?').join(',');
+        return (0, db_utils_1.dbAll)(db, `SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId IN (${placeholders})`, showIds);
+    },
+};

package/server/dist/repositories/watchlist.repository.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchlistRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.WatchlistRepository = {
+    getById: (db, id) => (0, db_utils_1.dbGet)(db, 'SELECT * FROM watchlist WHERE id = ?', [id]),
+    exists: async (db, id) => {
+        const row = await (0, db_utils_1.dbGet)(db, 'SELECT EXISTS(SELECT 1 FROM watchlist WHERE id = ?) as inWatchlist', [id]);
+        return !!(row && row.inWatchlist);
+    },
+    getAll: (db, status, limit, offset) => {
+        let query = 'SELECT * FROM watchlist';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY rowid DESC';
+        if (limit !== undefined && offset !== undefined) {
+            query += ' LIMIT ? OFFSET ?';
+            params.push(limit, offset);
+        }
+        return (0, db_utils_1.dbAll)(db, query, params);
+    },
+    getCount: async (db, status) => {
+        let query = 'SELECT COUNT(*) as total FROM watchlist';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        const row = await (0, db_utils_1.dbGet)(db, query, params);
+        return row?.total || 0;
+    },
+    upsert: (db, data) => (0, db_utils_1.dbRun)(db, 'INSERT OR REPLACE INTO watchlist (id, name, thumbnail, status, nativeName, englishName, type) VALUES (?, ?, ?, ?, ?, ?, ?)', [
+        data.id,
+        data.name,
+        data.thumbnail,
+        data.status,
+        data.nativeName,
+        data.englishName,
+        data.type,
+    ]),
+    updateStatus: (db, id, status) => (0, db_utils_1.dbRun)(db, 'UPDATE watchlist SET status = ? WHERE id = ?', [status, id]),
+    updateType: (db, id, type) => (0, db_utils_1.dbRun)(db, 'UPDATE watchlist SET type = ? WHERE id = ?', [type, id]),
+    updateThumbnail: (db, id, thumbnail) => (0, db_utils_1.dbRun)(db, 'UPDATE watchlist SET thumbnail = ? WHERE id = ?', [thumbnail, id]),
+    delete: (db, id) => (0, db_utils_1.dbRun)(db, 'DELETE FROM watchlist WHERE id = ?', [id]),
+    getWatchingShows: (db) => (0, db_utils_1.dbAll)(db, "SELECT id, name, thumbnail, nativeName, englishName FROM watchlist WHERE status = 'Watching'"),
+};

package/server/dist/routes/auth.routes.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthRouter = createAuthRouter;
+const express_1 = require("express");
+const auth_controller_1 = require("../controllers/auth.controller");
+function createAuthRouter(runSyncSequence) {
+    const router = (0, express_1.Router)();
+    const controller = new auth_controller_1.AuthController(runSyncSequence);
+    router.get('/config-status', controller.getConfigStatus);
+    router.get('/google-auth', controller.getGoogleAuthSettings);
+    router.post('/google-auth', controller.updateGoogleAuthSettings);
+    router.get('/github/status', controller.getGitHubAuthStatus);
+    router.post('/github/start', controller.startGitHubDeviceAuth);
+    router.get('/github/poll', controller.pollGitHubDeviceAuth);
+    router.post('/github/logout', controller.logoutGitHub);
+    router.get('/settings/rclone', controller.getRcloneSettings);
+    router.post('/settings/rclone', controller.updateRcloneSettings);
+    router.get('/google', controller.getAuthUrl);
+    router.get('/google/callback', controller.handleCallback);
+    router.get('/user', controller.getUserProfile);
+    router.post('/logout', controller.logout);
+    return router;
+}

package/server/dist/routes/data.routes.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDataRouter = createDataRouter;
+const express_1 = require("express");
+const data_controller_1 = require("../controllers/data.controller");
+function makeCacheMiddleware(cache, keyFn, ttl, validate = (d) => Array.isArray(d) && d.length > 0) {
+    return (req, res, next) => {
+        const cacheKey = keyFn(req);
+        const cached = cache.get(cacheKey);
+        if (cached)
+            return res.json(cached);
+        const originalJson = res.json.bind(res);
+        res.json = (data) => {
+            if (validate(data)) {
+                if (ttl !== undefined) {
+                    cache.set(cacheKey, data, ttl);
+                }
+                else {
+                    cache.set(cacheKey, data);
+                }
+            }
+            return originalJson(data);
+        };
+        next();
+    };
+}
+function createDataRouter(apiCache, providers) {
+    const router = (0, express_1.Router)();
+    const controller = new data_controller_1.DataController(providers);
+    router.get('/popular/:timeframe', makeCacheMiddleware(apiCache, (req) => `popular-${req.params.timeframe.toLowerCase()}`), controller.getPopular);
+    router.get('/schedule/:date', makeCacheMiddleware(apiCache, (req) => `schedule-${req.params.date}`), controller.getSchedule);
+    router.get('/latest-releases', makeCacheMiddleware(apiCache, () => 'latest-releases', 300), controller.getLatestReleases);
+    router.get('/search', makeCacheMiddleware(apiCache, (req) => `search-${JSON.stringify(req.query)}`, 1800), controller.search);
+    router.get('/skip-times/:showId/:episodeNumber', controller.getSkipTimes);
+    router.get('/video', controller.getVideo);
+    router.get('/episodes', controller.getEpisodes);
+    router.get('/seasonal', makeCacheMiddleware(apiCache, (req) => `seasonal-14-${req.query.page || 1}`, 1800), controller.getSeasonal);
+    router.get('/show-meta/:id', makeCacheMiddleware(apiCache, (req) => `meta-${req.params.id}`, 3600, (d) => !!d), controller.getShowMeta);
+    router.get('/show-details/:id', controller.getShowDetails);
+    router.get('/allmanga-details/:id', controller.getAllmangaDetails);
+    router.get('/genres-and-tags', controller.getGenresAndTags);
+    return router;
+}

package/server/dist/routes/insights.routes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInsightsRouter = createInsightsRouter;
+const express_1 = require("express");
+const insights_controller_1 = require("../controllers/insights.controller");
+function createInsightsRouter(provider) {
+    const router = (0, express_1.Router)();
+    const controller = new insights_controller_1.InsightsController(provider);
+    router.get('/insights', controller.getWatchInsights);
+    return router;
+}

package/server/dist/routes/proxy.routes.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxyRouter = createProxyRouter;
+const express_1 = require("express");
+const proxy_controller_1 = require("../controllers/proxy.controller");
+function createProxyRouter() {
+    const router = (0, express_1.Router)();
+    const controller = new proxy_controller_1.ProxyController();
+    router.get('/proxy', controller.handleProxy);
+    router.get('/subtitle-proxy', controller.handleSubtitleProxy);
+    router.get('/image-proxy', controller.handleImageProxy);
+    return router;
+}

package/server/dist/routes/settings.routes.js

@@ -0,0 +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.createSettingsRouter = createSettingsRouter;
+const express_1 = require("express");
+const settings_controller_1 = require("../controllers/settings.controller");
+const multer_1 = __importDefault(require("multer"));
+const config_1 = require("../config");
+function createSettingsRouter(provider, getDb, initializeDatabase, setDb) {
+    const router = (0, express_1.Router)();
+    const controller = new settings_controller_1.SettingsController(provider);
+    router.get('/settings', controller.getSettings);
+    router.post('/settings', controller.updateSettings);
+    router.get('/backup-db', controller.backupDatabase);
+    const restoreStorage = (0, multer_1.default)({
+        storage: multer_1.default.diskStorage({
+            destination: (_req, _f, cb) => cb(null, config_1.CONFIG.ROOT),
+            filename: (_r, _f, cb) => cb(null, `restore_temp.db`),
+        }),
+    });
+    router.post('/restore-db', restoreStorage.single('dbfile'), (req, res) => controller.restoreDatabase(req, res, getDb(), initializeDatabase, setDb));
+    router.post('/import/mal-xml', (0, multer_1.default)().single('xmlfile'), controller.importMalXml);
+    return router;
+}

package/server/dist/routes/watchlist.routes.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchlistRouter = createWatchlistRouter;
+const express_1 = require("express");
+const watchlist_controller_1 = require("../controllers/watchlist.controller");
+function createWatchlistRouter(provider) {
+    const router = (0, express_1.Router)();
+    const controller = new watchlist_controller_1.WatchlistController(provider);
+    router.get('/continue-watching', controller.getContinueWatching);
+    router.get('/continue-watching/fast', controller.getContinueWatchingFast);
+    router.get('/continue-watching/up-next', controller.getContinueWatchingUpNext);
+    router.get('/continue-watching/all', controller.getAllContinueWatching);
+    router.post('/continue-watching/remove', controller.removeContinueWatching);
+    router.post('/update-progress', controller.updateProgress);
+    router.get('/watchlist', controller.getWatchlist);
+    router.get('/watchlist/check/:showId', controller.checkWatchlist);
+    router.post('/watchlist/add', controller.addToWatchlist);
+    router.post('/watchlist/remove', controller.removeFromWatchlist);
+    router.post('/watchlist/status', controller.updateWatchlistStatus);
+    router.get('/episode-progress/:showId/:episodeNumber', controller.getEpisodeProgress);
+    router.get('/watched-episodes/:showId', controller.getWatchedEpisodes);
+    router.get('/notifications', controller.getNotifications);
+    router.post('/notifications/dismiss', controller.dismissNotification);
+    router.post('/notifications/clear-all', controller.clearAllNotifications);
+    return router;
+}