@serifpersia/dango 3.3.8 → 3.4.0

package/server/dist/controllers/watchlist.controller.js

@@ -1,1069 +0,0 @@
-import logger from '../logger.js';
-import { performWriteTransaction } from '../sync.js';
-import { WatchlistRepository } from '../repositories/watchlist.repository.js';
-import { WatchedEpisodesRepository, } from '../repositories/watched-episodes.repository.js';
-import { ShowsMetaRepository } from '../repositories/shows-meta.repository.js';
-import { NotificationsRepository } from '../repositories/notifications.repository.js';
-import { QueueRepository } from '../repositories/queue.repository.js';
-import { SettingsRepository } from '../repositories/settings.repository.js';
-import { discordRPCService } from '../discord-rpc.js';
-import { dbAll, dbGet } from '../utils/db-utils.js';
-import { searchAnilist, searchAnilistByTitle, getAiredEpisodesForShows, getAnilistEpisodes, getShowMetaById, isAnilistRateLimited, batchGetShowStatuses, } from '../lib/anilist.js';
-import { kitsuSearchAnime } from '../lib/kitsu.js';
-import { getMigratedId } from '../lib/migration.js';
-import { offlineDb } from '../lib/offline-db.js';
-const BACKGROUND_DISCOVERY_INTERVAL_MS = 5 * 60 * 1000;
-const NUDGE_THROTTLE_MS = 120 * 1000;
-const SLOW_MAX_RUN_MS = 5 * 60 * 1000;
-export class WatchlistController {
-    triggerDiscovery;
-    discoveryIntervalId = null;
-    lastExternalDiscoveryAt = 0;
-    discoveryBusy = false;
-    lastDiscoveryRunAt = 0;
-    discoveryState = 'idle';
-    discoveryTotal = 0;
-    discoveryDone = 0;
-    stopped = false;
-    stopNotificationDiscovery() {
-        this.stopped = true;
-        if (this.discoveryIntervalId !== null) {
-            clearInterval(this.discoveryIntervalId);
-            this.discoveryIntervalId = null;
-        }
-    }
-    getDiscoveryStatus = () => ({
-        running: this.discoveryBusy,
-        state: this.discoveryState,
-        total: this.discoveryTotal,
-        done: Math.min(this.discoveryDone, this.discoveryTotal),
-        lastRunAt: this.lastDiscoveryRunAt,
-    });
-    startNotificationDiscovery(getDb) {
-        const anilistIdCache = new Map();
-        const getAnilistId = async (showId, showName) => {
-            if (anilistIdCache.has(showId)) {
-                return anilistIdCache.get(showId) || null;
-            }
-            const db = getDb();
-            const meta = (await ShowsMetaRepository.getById(db, showId));
-            if (meta?.anilistId) {
-                anilistIdCache.set(showId, meta.anilistId);
-                return meta.anilistId;
-            }
-            if (/^\d+$/.test(showId)) {
-                const numericId = parseInt(showId);
-                anilistIdCache.set(showId, numericId);
-                return numericId;
-            }
-            anilistIdCache.set(showId, null);
-            return null;
-        };
-        const runDiscovery = async (fast = false) => {
-            if (this.discoveryBusy || this.stopped)
-                return;
-            this.discoveryBusy = true;
-            this.discoveryState = 'running';
-            this.discoveryTotal = 0;
-            this.discoveryDone = 0;
-            const db = getDb();
-            if (!db || db.isClosedCheck()) {
-                this.discoveryBusy = false;
-                return;
-            }
-            const startedAt = Date.now();
-            const MAX_RUN_MS = fast ? 90000 : SLOW_MAX_RUN_MS;
-            try {
-                const watchingShows = await WatchlistRepository.getWatchingShows(db);
-                this.discoveryTotal = watchingShows.length;
-                if (watchingShows.length === 0) {
-                    this.discoveryBusy = false;
-                    return;
-                }
-                const showIdMap = new Map();
-                const MAP_CONCURRENCY = fast ? 4 : 2;
-                const anilistResults = [];
-                let nextIndex = 0;
-                const worker = async () => {
-                    while (nextIndex < watchingShows.length) {
-                        if (Date.now() - startedAt > MAX_RUN_MS)
-                            return;
-                        const show = watchingShows[nextIndex];
-                        nextIndex += 1;
-                        const id = await getAnilistId(show.id, show.name);
-                        this.discoveryDone += 1;
-                        anilistResults.push({ show, id });
-                    }
-                };
-                await Promise.all(Array.from({ length: Math.min(MAP_CONCURRENCY, watchingShows.length) }, () => worker()));
-                for (const { show, id } of anilistResults) {
-                    if (id) {
-                        showIdMap.set(show.id, id);
-                    }
-                }
-                if (Date.now() - startedAt > MAX_RUN_MS || showIdMap.size === 0) {
-                    this.discoveryBusy = false;
-                    return;
-                }
-                const now = new Date();
-                const weekStart = new Date(now);
-                weekStart.setDate(now.getDate() - 7);
-                weekStart.setHours(0, 0, 0, 0);
-                const weekEnd = new Date(now);
-                weekEnd.setHours(23, 59, 59, 999);
-                const schedules = await getAiredEpisodesForShows(Array.from(showIdMap.values()), weekStart, weekEnd);
-                const nowUnix = Math.floor(Date.now() / 1000);
-                const reverseMap = new Map();
-                for (const [watchlistId, anilistId] of showIdMap.entries()) {
-                    reverseMap.set(anilistId, watchlistId);
-                }
-                const finishedShowIds = new Set();
-                const unresolvedStatus = [];
-                for (const [watchlistId, anilistId] of showIdMap.entries()) {
-                    const localMeta = (await ShowsMetaRepository.getById(db, watchlistId));
-                    if (localMeta?.status === 'FINISHED') {
-                        finishedShowIds.add(anilistId);
-                    }
-                    else if (!localMeta?.status) {
-                        unresolvedStatus.push({ watchlistId, anilistId });
-                    }
-                }
-                if (unresolvedStatus.length > 0 && !isAnilistRateLimited()) {
-                    const statuses = await batchGetShowStatuses(unresolvedStatus.map((s) => s.anilistId));
-                    let persisted = 0;
-                    for (const { watchlistId, anilistId } of unresolvedStatus) {
-                        const status = statuses.get(anilistId);
-                        if (status === 'FINISHED') {
-                            finishedShowIds.add(anilistId);
-                            await ShowsMetaRepository.upsert(db, { id: watchlistId, status: 'FINISHED' });
-                            persisted++;
-                        }
-                        else if (status) {
-                            await ShowsMetaRepository.upsert(db, { id: watchlistId, status });
-                            persisted++;
-                        }
-                    }
-                    if (persisted > 0)
-                        db.scheduleSave();
-                }
-                if (finishedShowIds.size > 0) {
-                    const monthStart = new Date(now);
-                    monthStart.setDate(now.getDate() - 30);
-                    monthStart.setHours(0, 0, 0, 0);
-                    const monthEnd = new Date(now);
-                    monthEnd.setHours(23, 59, 59, 999);
-                    const finishedSchedules = await getAiredEpisodesForShows(Array.from(finishedShowIds), monthStart, monthEnd);
-                    const finishedEpisodesByShow = new Map();
-                    const seenFinishedKeys = new Set();
-                    for (const entry of finishedSchedules) {
-                        if (entry.airingAt > nowUnix)
-                            continue;
-                        const watchlistId = reverseMap.get(entry.mediaId);
-                        if (!watchlistId)
-                            continue;
-                        const episodeKey = String(Math.round(entry.episode));
-                        const dedupeKey = `${watchlistId}:${episodeKey}`;
-                        if (seenFinishedKeys.has(dedupeKey))
-                            continue;
-                        seenFinishedKeys.add(dedupeKey);
-                        const list = finishedEpisodesByShow.get(watchlistId);
-                        if (list)
-                            list.push({ episodeKey, airingAt: entry.airingAt });
-                        else
-                            finishedEpisodesByShow.set(watchlistId, [{ episodeKey, airingAt: entry.airingAt }]);
-                    }
-                    for (const [watchlistId, episodes] of finishedEpisodesByShow) {
-                        const [watchedEps, dismissedEps] = await Promise.all([
-                            WatchedEpisodesRepository.getWatchedEpisodeNumbers(db, watchlistId),
-                            NotificationsRepository.getDismissedByShow(db, watchlistId),
-                        ]);
-                        const watchedSet = new Set(watchedEps.map((e) => e.toString()));
-                        const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
-                        let inserted = false;
-                        for (const { episodeKey, airingAt } of episodes) {
-                            if (nowUnix - airingAt > 30 * 24 * 60 * 60)
-                                continue;
-                            if (!watchedSet.has(episodeKey) && !dismissedSet.has(episodeKey)) {
-                                await NotificationsRepository.addDiscovered(db, watchlistId, episodeKey);
-                                inserted = true;
-                            }
-                        }
-                        if (inserted)
-                            db.scheduleSave();
-                    }
-                }
-                const episodesByShow = new Map();
-                const seenEpisodeKeys = new Set();
-                for (const entry of schedules) {
-                    if (entry.airingAt > nowUnix)
-                        continue;
-                    const watchlistId = reverseMap.get(entry.mediaId);
-                    if (!watchlistId)
-                        continue;
-                    const episodeKey = String(Math.round(entry.episode));
-                    const dedupeKey = `${watchlistId}:${episodeKey}`;
-                    if (seenEpisodeKeys.has(dedupeKey))
-                        continue;
-                    seenEpisodeKeys.add(dedupeKey);
-                    const list = episodesByShow.get(watchlistId);
-                    if (list)
-                        list.push({ episodeKey, airingAt: entry.airingAt });
-                    else
-                        episodesByShow.set(watchlistId, [{ episodeKey, airingAt: entry.airingAt }]);
-                }
-                for (const [watchlistId, episodes] of episodesByShow) {
-                    const [watchedEps, dismissedEps] = await Promise.all([
-                        WatchedEpisodesRepository.getWatchedEpisodeNumbers(db, watchlistId),
-                        NotificationsRepository.getDismissedByShow(db, watchlistId),
-                    ]);
-                    const watchedSet = new Set(watchedEps.map((e) => e.toString()));
-                    const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
-                    let inserted = false;
-                    for (const { episodeKey } of episodes) {
-                        if (!watchedSet.has(episodeKey) && !dismissedSet.has(episodeKey)) {
-                            await NotificationsRepository.addDiscovered(db, watchlistId, episodeKey);
-                            inserted = true;
-                        }
-                    }
-                    if (inserted)
-                        db.scheduleSave();
-                }
-                await NotificationsRepository.cleanupWatchedNotifications(db);
-            }
-            catch (e) {
-                this.discoveryState = 'error';
-                if (e?.message === 'Database is closed') {
-                    logger.info('Notification discovery stopped: database is closed');
-                }
-                else {
-                    logger.error({ err: e }, 'AniList notification discovery failed');
-                }
-            }
-            finally {
-                this.discoveryBusy = false;
-                this.lastDiscoveryRunAt = Date.now();
-                if (this.discoveryState === 'running') {
-                    this.discoveryState = this.discoveryTotal === 0 ? 'empty' : 'complete';
-                }
-            }
-        };
-        this.triggerDiscovery = (force = false) => {
-            if (this.stopped || this.discoveryBusy)
-                return false;
-            const now = Date.now();
-            if (!force && now - this.lastExternalDiscoveryAt < NUDGE_THROTTLE_MS)
-                return false;
-            this.lastExternalDiscoveryAt = now;
-            runDiscovery(force);
-            return true;
-        };
-        this.discoveryIntervalId = setInterval(() => {
-            if (!this.stopped)
-                runDiscovery(false);
-        }, BACKGROUND_DISCOVERY_INTERVAL_MS);
-    }
-    showsMetaChanged(db, showId, candidate) {
-        const existing = ShowsMetaRepository.getById(db, showId);
-        if (!existing)
-            return true;
-        const differs = (incoming, stored) => {
-            if (incoming === undefined || incoming === null || incoming === '')
-                return false;
-            return String(incoming) !== String(stored ?? '');
-        };
-        return (differs(candidate.name, existing.name) ||
-            differs(candidate.thumbnail, existing.thumbnail) ||
-            differs(candidate.nativeName, existing.nativeName) ||
-            differs(candidate.englishName, existing.englishName) ||
-            differs(candidate.genres, existing.genres) ||
-            differs(candidate.popularityScore, existing.popularityScore) ||
-            differs(candidate.status, existing.status) ||
-            differs(candidate.episodeCount, existing.episodeCount) ||
-            differs(candidate.type, existing.type) ||
-            differs(candidate.anilistId, existing.anilistId) ||
-            differs(candidate.isAdult, existing.isAdult) ||
-            differs(candidate.episodeDuration, existing.episodeDuration));
-    }
-    normalizeFilterValue(value) {
-        if (typeof value !== 'string')
-            return undefined;
-        const trimmed = value.trim();
-        return trimmed && trimmed !== 'ALL' ? trimmed : undefined;
-    }
-    getWatchlistFilters(query) {
-        return {
-            query: this.normalizeFilterValue(query.query),
-            type: this.normalizeFilterValue(query.type),
-            season: this.normalizeFilterValue(query.season),
-            year: this.normalizeFilterValue(query.year),
-            genres: this.normalizeFilterValue(query.genres),
-            excludeGenres: this.normalizeFilterValue(query.excludeGenres),
-            sortBy: this.normalizeFilterValue(query.sortBy),
-            titlePreference: ['name', 'nativeName', 'englishName'].includes(String(query.titlePreference))
-                ? query.titlePreference
-                : 'name',
-        };
-    }
-    matchesLocalFilters(row, filters) {
-        if (filters.query) {
-            const queryWords = new Set(filters.query
-                .toLowerCase()
-                .split(/\s+/)
-                .filter((w) => w.length >= 2));
-            const rowTitle = (row.englishName || row.name || row.nativeName || '').toLowerCase();
-            const titleWords = rowTitle.split(/\s+/);
-            const overlap = titleWords.filter((w) => queryWords.has(w)).length;
-            if (overlap < queryWords.size)
-                return false;
-        }
-        return true;
-    }
-    sortFilteredRows(rows, filters) {
-        const getSortTitle = (row) => {
-            const preferredTitle = filters.titlePreference ? row[filters.titlePreference] : undefined;
-            return preferredTitle || row.name || '';
-        };
-        if (filters.sortBy === 'name_asc') {
-            return [...rows].sort((a, b) => getSortTitle(a).localeCompare(getSortTitle(b)));
-        }
-        if (filters.sortBy === 'name_desc') {
-            return [...rows].sort((a, b) => getSortTitle(b).localeCompare(getSortTitle(a)));
-        }
-        return rows;
-    }
-    async getAnilistSeasonYearMatches(season, year) {
-        const matched = new Map();
-        if (!year || year === 'ALL') {
-            return matched;
-        }
-        const seasonYear = parseInt(year);
-        if (Number.isNaN(seasonYear))
-            return matched;
-        const perPage = 50;
-        let page = 1;
-        while (true) {
-            const searchVars = {
-                seasonYear,
-                page,
-                perPage,
-            };
-            if (season && season !== 'ALL') {
-                searchVars.season = season.toUpperCase();
-            }
-            const results = await searchAnilist(searchVars);
-            for (const show of results) {
-                if (show.anilistId) {
-                    matched.set(show.anilistId, { title: show.names || {} });
-                }
-            }
-            if (results.length < perPage)
-                break;
-            page++;
-            if (page > 10)
-                break;
-        }
-        return matched;
-    }
-    rowMatchesAnilistSeasonYear(row, anilistMatches) {
-        if (anilistMatches.size === 0)
-            return true;
-        if (/^\d+$/.test(row.id) && anilistMatches.has(parseInt(row.id))) {
-            return true;
-        }
-        const rowTitle = (row.englishName || row.name || row.nativeName || '').toLowerCase();
-        if (!rowTitle)
-            return false;
-        const rowWords = new Set(rowTitle.split(/\s+/).filter((w) => w.length >= 2));
-        if (rowWords.size === 0)
-            return false;
-        for (const [, media] of anilistMatches) {
-            const titles = [media.title?.romaji, media.title?.english, media.title?.native].filter(Boolean);
-            for (const title of titles) {
-                const titleWords = new Set(title
-                    .toLowerCase()
-                    .split(/\s+/)
-                    .filter((w) => w.length >= 2));
-                const overlap = [...rowWords].filter((w) => titleWords.has(w)).length;
-                const minLen = Math.min(rowWords.size, titleWords.size);
-                if (minLen >= 2 && overlap / minLen >= 0.7)
-                    return true;
-            }
-        }
-        return false;
-    }
-    async filterWatchlistRows(rows, filters, db) {
-        let filtered = rows.filter((row) => this.matchesLocalFilters(row, filters));
-        if (filters.type === 'ADULT' && db && filtered.length > 0) {
-            const ids = filtered.map((r) => r.id);
-            const placeholders = ids.map(() => '?').join(',');
-            const adultRows = await dbAll(db, `SELECT id FROM shows_meta WHERE id IN (${placeholders}) AND isAdult = 1`, ids);
-            const adultSet = new Set(adultRows.map((r) => r.id));
-            filtered = filtered.filter((row) => adultSet.has(row.id));
-        }
-        else if (filters.type && filters.type !== 'ALL' && filters.type !== 'ADULT') {
-            filtered = filtered.filter((row) => row.type === filters.type);
-        }
-        if ((filters.genres || filters.excludeGenres) && db) {
-            const ids = filtered.map((r) => r.id);
-            const placeholders = ids.map(() => '?').join(',');
-            const genreRows = await dbAll(db, `SELECT id, genres FROM shows_meta WHERE id IN (${placeholders})`, ids);
-            const idToGenres = new Map(genreRows.map((r) => [r.id, r.genres ? JSON.parse(r.genres) : []]));
-            const includeList = filters.genres
-                ?.split(',')
-                .map((g) => g.trim())
-                .filter(Boolean) || [];
-            const excludeList = filters.excludeGenres
-                ?.split(',')
-                .map((g) => g.trim())
-                .filter(Boolean) || [];
-            filtered = filtered.filter((row) => {
-                const rowGenres = idToGenres.get(row.id) || [];
-                if (includeList.length && !includeList.every((g) => rowGenres.includes(g)))
-                    return false;
-                if (excludeList.length && excludeList.some((g) => rowGenres.includes(g)))
-                    return false;
-                return true;
-            });
-        }
-        if (((filters.season && filters.season !== 'ALL') || (filters.year && filters.year !== 'ALL')) &&
-            filtered.length > 0) {
-            const anilistMatches = await this.getAnilistSeasonYearMatches(filters.season, filters.year);
-            if (anilistMatches.size > 0) {
-                filtered = filtered.filter((row) => this.rowMatchesAnilistSeasonYear(row, anilistMatches));
-            }
-        }
-        return this.sortFilteredRows(filtered, filters);
-    }
-    async backfillMissingPosters(db, rows) {
-        const missing = rows.filter((r) => !r.thumbnail || r.thumbnail.trim() === '');
-        if (missing.length === 0)
-            return;
-        const slice = missing.slice(0, 10);
-        await Promise.allSettled(slice.map(async (row) => {
-            try {
-                const meta = await getShowMetaById(row.id);
-                const poster = meta?.thumbnail?.trim();
-                if (!poster)
-                    return;
-                row.thumbnail = poster;
-                const dual = row;
-                if (dual._id !== undefined)
-                    dual._id = row.id;
-                try {
-                    ShowsMetaRepository.upsert(db, {
-                        id: row.id,
-                        thumbnail: poster,
-                        popularityScore: meta?.score ?? (meta?.averageScore != null ? meta.averageScore / 10 : undefined),
-                    });
-                }
-                catch {
-                    // ignore
-                }
-                try {
-                    await WatchlistRepository.updateThumbnail(db, row.id, poster);
-                }
-                catch {
-                    // ignore
-                }
-            }
-            catch {
-                // ignore
-            }
-        }));
-        db.scheduleSave();
-        await this.sweepOfflinePosters(db);
-    }
-    async sweepOfflinePosters(db) {
-        try {
-            db.run(`UPDATE shows_meta SET name = (SELECT w.name FROM watchlist w WHERE w.id = shows_meta.id)
-         WHERE (name IS NULL OR TRIM(name) = '')
-         AND EXISTS (SELECT 1 FROM watchlist w WHERE w.id = shows_meta.id AND w.name IS NOT NULL AND TRIM(w.name) != '')`);
-        }
-        catch {
-            // ignore
-        }
-        const [wlMissing, metaMissing] = await Promise.all([
-            WatchlistRepository.getMissingThumbnails(db),
-            ShowsMetaRepository.getShowIdsMissingMeta(db),
-        ]);
-        const ids = [
-            ...new Set([...wlMissing.map((r) => r.id), ...metaMissing.map((r) => r.id)]),
-        ].slice(0, 500);
-        if (ids.length === 0)
-            return;
-        for (const id of ids) {
-            const poster = this.resolveOfflinePoster(id);
-            if (poster)
-                await this.applyPoster(db, id, poster);
-        }
-        db.scheduleSave();
-    }
-    resolveOfflinePoster(id) {
-        if (/^\d+$/.test(id)) {
-            return offlineDb.getByAnilistId(Number(id))?.thumbnail?.trim() || null;
-        }
-        const mal = /^mal-(\d+)$/i.exec(id)?.[1];
-        if (mal)
-            return offlineDb.getByMalId(Number(mal))?.thumbnail?.trim() || null;
-        return null;
-    }
-    async applyPoster(db, id, poster) {
-        try {
-            ShowsMetaRepository.upsert(db, { id, thumbnail: poster });
-        }
-        catch {
-            // ignore
-        }
-        try {
-            await WatchlistRepository.updateThumbnail(db, id, poster);
-        }
-        catch {
-            // ignore
-        }
-    }
-    async getContinueWatchingData(req, limit) {
-        const rows = await WatchedEpisodesRepository.getContinueWatching(req.db, limit);
-        const ignoreAdultRow = await SettingsRepository.getByKey(req.db, 'ignoreAdultContent');
-        const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
-        const watchlistOnlyRow = await SettingsRepository.getByKey(req.db, 'cwWatchlistOnly');
-        const watchlistOnly = watchlistOnlyRow
-            ? watchlistOnlyRow.value === 'true' || watchlistOnlyRow.value === '1'
-            : false;
-        const enrichedRows = rows
-            .filter((show) => {
-            if (ignoreAdult && show.isAdult)
-                return false;
-            if (watchlistOnly && show.watchlistStatus !== 'Watching')
-                return false;
-            return true;
-        })
-            .map((show) => ({
-            ...show,
-            episodeCount: show.episodeCount,
-            type: show.type || show.smType,
-            thumbnail: show.thumbnail ?? '',
-        }));
-        await this.backfillMissingPosters(req.db, enrichedRows);
-        return enrichedRows;
-    }
-    getAllContinueWatching = async (req, res) => {
-        const page = parseInt(req.query.page) || 1;
-        const limit = parseInt(req.query.limit) || 10;
-        const offset = (page - 1) * limit;
-        const filters = this.getWatchlistFilters(req.query);
-        const data = await this.filterWatchlistRows(await this.getContinueWatchingData(req), filters, req.db);
-        res.json({
-            data: data.slice(offset, offset + limit),
-            total: data.length,
-            page,
-            limit,
-        });
-    };
-    updateProgress = async (req, res) => {
-        const { showId: showIdRaw, episodeNumber, currentTime, duration, showName, showThumbnail, nativeName, englishName, genres, popularityScore, type, status, episodeCount, isPlaying, sessionId, isAdult, } = req.body;
-        const showId = await getMigratedId(req.db, showIdRaw);
-        const titlePreferenceRow = await SettingsRepository.getByKey(req.db, 'titlePreference');
-        const titlePreference = titlePreferenceRow ? titlePreferenceRow.value : 'englishName';
-        let displayName = showName;
-        if (titlePreference === 'englishName' && englishName) {
-            displayName = englishName;
-        }
-        else if (titlePreference === 'nativeName' && nativeName) {
-            displayName = nativeName;
-        }
-        discordRPCService.updatePresence({
-            title: displayName,
-            episode: String(episodeNumber),
-            totalEpisodes: episodeCount ? String(episodeCount) : undefined,
-            currentTime: currentTime || 0,
-            duration: duration || 0,
-            thumbnail: showThumbnail || '',
-            isPlaying: isPlaying !== false,
-            sessionId,
-            isAdult,
-        });
-        const genresStr = Array.isArray(genres) ? JSON.stringify(genres) : genres;
-        const anilistId = /^\d+$/.test(showId)
-            ? (dbGet(req.db, 'SELECT anilistId FROM shows_meta WHERE id = ? AND anilistId IS NOT NULL', [showId])?.anilistId ?? parseInt(showId))
-            : undefined;
-        const metaCandidate = {
-            name: showName,
-            thumbnail: showThumbnail,
-            nativeName,
-            englishName,
-            genres: genresStr,
-            popularityScore,
-            status,
-            episodeCount,
-            type,
-            anilistId,
-            isAdult: typeof isAdult === 'boolean' ? (isAdult ? 1 : 0) : null,
-            episodeDuration: duration > 0 ? Math.round(duration / 60) : undefined,
-        };
-        const metaChanged = this.showsMetaChanged(req.db, showId, metaCandidate);
-        if (metaChanged) {
-            await performWriteTransaction(req.db, (tx) => {
-                ShowsMetaRepository.upsert(tx, {
-                    id: showId,
-                    ...metaCandidate,
-                });
-            });
-        }
-        await performWriteTransaction(req.db, (tx) => {
-            WatchedEpisodesRepository.upsert(tx, {
-                showId,
-                episodeNumber,
-                currentTime,
-                duration,
-            });
-            NotificationsRepository.deleteSpecificDismissed(tx, showId, episodeNumber);
-            NotificationsRepository.deleteDiscovered(tx, showId, episodeNumber);
-        });
-        req.db.scheduleSave();
-        res.json({ success: true });
-    };
-    removeContinueWatching = async (req, res) => {
-        const { showId: showIdRaw } = req.body;
-        const showId = await getMigratedId(req.db, showIdRaw);
-        await performWriteTransaction(req.db, (tx) => {
-            WatchedEpisodesRepository.deleteByShow(tx, showId);
-            NotificationsRepository.deleteByShow(tx, showId);
-        });
-        res.json({ success: true });
-    };
-    async getAdultNonWatchlistShowIds(db) {
-        const rows = await dbAll(db, `SELECT DISTINCT we.showId as showId
-       FROM watched_episodes we
-       JOIN shows_meta sm ON sm.id = we.showId AND sm.isAdult = 1
-       LEFT JOIN watchlist w ON w.id = we.showId
-       WHERE w.id IS NULL`);
-        return rows.map((r) => r.showId);
-    }
-    getAdultContinueWatchingCount = async (req, res) => {
-        const ids = await this.getAdultNonWatchlistShowIds(req.db);
-        res.json({ count: ids.length });
-    };
-    purgeAdultContinueWatching = async (req, res) => {
-        const ids = await this.getAdultNonWatchlistShowIds(req.db);
-        if (ids.length > 0) {
-            await performWriteTransaction(req.db, (tx) => {
-                for (const id of ids) {
-                    WatchedEpisodesRepository.deleteByShow(tx, id);
-                    NotificationsRepository.deleteByShow(tx, id);
-                }
-            });
-            req.db.scheduleSave();
-        }
-        res.json({ success: true, removed: ids.length });
-    };
-    batchRemoveContinueWatching = async (req, res) => {
-        const { ids: idsRaw } = req.body;
-        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
-            return res.status(400).json({ error: 'ids must be a non-empty array' });
-        }
-        const ids = await Promise.all(idsRaw.map((id) => getMigratedId(req.db, id)));
-        await performWriteTransaction(req.db, (tx) => {
-            for (const id of ids) {
-                WatchedEpisodesRepository.deleteByShow(tx, id);
-                NotificationsRepository.deleteByShow(tx, id);
-            }
-        });
-        req.db.scheduleSave();
-        res.json({ success: true, removed: ids.length });
-    };
-    getWatchlist = async (req, res) => {
-        const { status, page: pageStr, limit: limitStr, showMature } = req.query;
-        const page = parseInt(pageStr) || 1;
-        const limit = parseInt(limitStr) || 10;
-        const offset = (page - 1) * limit;
-        const filters = this.getWatchlistFilters(req.query);
-        const allRows = await WatchlistRepository.getAll(req.db, status);
-        let filteredRows = await this.filterWatchlistRows(allRows, filters, req.db);
-        if (showMature === 'false') {
-            const ids = filteredRows.map((r) => r.id);
-            if (ids.length > 0) {
-                const placeholders = ids.map(() => '?').join(',');
-                const adultIds = await dbAll(req.db, `SELECT id FROM shows_meta WHERE id IN (${placeholders}) AND isAdult = 1`, ids);
-                const adultSet = new Set(adultIds.map((r) => r.id));
-                filteredRows = filteredRows.filter((row) => !adultSet.has(row.id));
-            }
-        }
-        const rows = filteredRows.slice(offset, offset + limit);
-        for (const row of rows) {
-            if (!row.thumbnail || row.thumbnail.trim() === '') {
-                try {
-                    const meta = ShowsMetaRepository.getById(req.db, row.id);
-                    if (meta?.thumbnail && meta.thumbnail.trim() !== '') {
-                        row.thumbnail = meta.thumbnail;
-                    }
-                }
-                catch {
-                    // ignore
-                }
-            }
-        }
-        await this.backfillMissingPosters(req.db, rows);
-        const rowIds = rows.map((r) => r.id);
-        let adultIds = new Set();
-        if (rowIds.length > 0) {
-            const placeholders = rowIds.map(() => '?').join(',');
-            const adultRows = await dbAll(req.db, `SELECT id FROM shows_meta WHERE id IN (${placeholders}) AND isAdult = 1`, rowIds);
-            adultIds = new Set(adultRows.map((r) => r.id));
-        }
-        res.json({
-            data: rows.map((row) => ({
-                ...row,
-                _id: row.id,
-                thumbnail: row.thumbnail || '',
-                isAdult: adultIds.has(row.id),
-            })),
-            total: filteredRows.length,
-            page,
-            limit,
-        });
-    };
-    checkWatchlist = async (req, res) => {
-        const showId = await getMigratedId(req.db, req.params.showId);
-        const item = await WatchlistRepository.getById(req.db, showId);
-        res.json({ inWatchlist: !!item, status: item?.status ?? null });
-    };
-    getQueue = async (req, res) => {
-        const rows = await QueueRepository.getAll(req.db);
-        res.json(rows.map((row) => ({
-            ...row,
-            _id: row.showId,
-            id: row.id,
-            thumbnail: row.thumbnail || '',
-        })));
-    };
-    addToQueue = async (req, res) => {
-        const { showId: showIdRaw, episodeNumber, showName, showThumbnail, nativeName, englishName, type, } = req.body;
-        if (!showIdRaw || !episodeNumber) {
-            return res.status(400).json({ error: 'showId and episodeNumber are required' });
-        }
-        const showId = await getMigratedId(req.db, showIdRaw);
-        const existing = await QueueRepository.getByEpisode(req.db, showId, String(episodeNumber));
-        await performWriteTransaction(req.db, (tx) => {
-            if (showName || showThumbnail || nativeName || englishName || type) {
-                ShowsMetaRepository.upsert(tx, {
-                    id: showId,
-                    name: showName || '',
-                    thumbnail: showThumbnail || '',
-                    nativeName,
-                    englishName,
-                    type,
-                });
-            }
-            if (existing) {
-                QueueRepository.removeEpisode(tx, showId, String(episodeNumber));
-            }
-            else {
-                QueueRepository.addToEnd(tx, showId, String(episodeNumber));
-            }
-        });
-        req.db.scheduleSave();
-        res.json({ success: true, queued: !existing });
-    };
-    removeFromQueue = async (req, res) => {
-        const { showId: showIdRaw, episodeNumber } = req.body;
-        const showId = await getMigratedId(req.db, showIdRaw);
-        await performWriteTransaction(req.db, (tx) => {
-            QueueRepository.removeEpisode(tx, showId, String(episodeNumber));
-        });
-        res.json({ success: true });
-    };
-    clearQueue = async (req, res) => {
-        await performWriteTransaction(req.db, (tx) => {
-            QueueRepository.clear(tx);
-        });
-        res.json({ success: true });
-    };
-    reorderQueue = async (req, res) => {
-        const { items } = req.body;
-        if (!Array.isArray(items)) {
-            return res.status(400).json({ error: 'items must be an array' });
-        }
-        await performWriteTransaction(req.db, (tx) => {
-            QueueRepository.reorder(tx, items);
-        });
-        res.json({ success: true });
-    };
-    async resolveAvailableEpisodes(db, showId) {
-        const episodeData = await getAnilistEpisodes(showId);
-        const episodes = Array.isArray(episodeData) && episodeData.length
-            ? [...episodeData].sort((a, b) => parseFloat(a) - parseFloat(b))
-            : [];
-        return episodes;
-    }
-    getQueueRemainingEpisodes = async (req, res) => {
-        const showIdRaw = req.params.showId;
-        const showId = await getMigratedId(req.db, showIdRaw);
-        const [watchedEpisodes, queuedEpisodes, episodes] = await Promise.all([
-            WatchedEpisodesRepository.getByShow(req.db, showId),
-            QueueRepository.getByShow(req.db, showId),
-            this.resolveAvailableEpisodes(req.db, showId),
-        ]);
-        const watchedSet = new Set(watchedEpisodes.map((ep) => ep.episodeNumber.toString()));
-        const queuedSet = new Set(queuedEpisodes.map((ep) => ep.episodeNumber.toString()));
-        const remaining = episodes.filter((ep) => !watchedSet.has(ep) && !queuedSet.has(ep));
-        res.json({ showId, episodes: remaining });
-    };
-    addToQueueBatch = async (req, res) => {
-        const { showId: showIdRaw, episodeNumbers, showName, showThumbnail, nativeName, englishName, type, } = req.body;
-        if (!showIdRaw || !Array.isArray(episodeNumbers) || episodeNumbers.length === 0) {
-            return res.status(400).json({ error: 'showId and episodeNumbers are required' });
-        }
-        const showId = await getMigratedId(req.db, showIdRaw);
-        const normalized = [...new Set(episodeNumbers.map((ep) => String(ep)))];
-        await performWriteTransaction(req.db, (tx) => {
-            if (showName || showThumbnail || nativeName || englishName || type) {
-                ShowsMetaRepository.upsert(tx, {
-                    id: showId,
-                    name: showName || '',
-                    thumbnail: showThumbnail || '',
-                    nativeName,
-                    englishName,
-                    type,
-                });
-            }
-            return QueueRepository.addManyToEnd(tx, normalized.map((episodeNumber) => ({ showId, episodeNumber })));
-        });
-        req.db.scheduleSave();
-        res.json({ success: true, added: normalized.length });
-    };
-    removeFromQueueBatch = async (req, res) => {
-        const { showId: showIdRaw, episodeNumbers } = req.body;
-        if (!showIdRaw) {
-            return res.status(400).json({ error: 'showId is required' });
-        }
-        const showId = await getMigratedId(req.db, showIdRaw);
-        let removed;
-        await performWriteTransaction(req.db, (tx) => {
-            removed = (QueueRepository.getByShow(tx, showId) || []).map((ep) => ep.episodeNumber);
-            const toRemove = Array.isArray(episodeNumbers) && episodeNumbers.length
-                ? [...new Set(episodeNumbers.map((ep) => String(ep)))]
-                : removed;
-            return QueueRepository.removeMany(tx, showId, toRemove);
-        });
-        res.json({ success: true, removed: removed.length });
-    };
-    getSuggestedQueueEpisode = async (req, res) => {
-        const showIdRaw = req.params.showId;
-        const showId = await getMigratedId(req.db, showIdRaw);
-        const resumeProgress = await WatchedEpisodesRepository.getLatestResumeProgress(req.db, showId);
-        if (resumeProgress) {
-            return res.json({
-                showId,
-                episodeNumber: resumeProgress.episodeNumber,
-                resumeTime: resumeProgress.currentTime || 0,
-            });
-        }
-        const [watchedEpisodes, episodes] = await Promise.all([
-            WatchedEpisodesRepository.getByShow(req.db, showId),
-            this.resolveAvailableEpisodes(req.db, showId),
-        ]);
-        const watchedSet = new Set(watchedEpisodes.map((ep) => ep.episodeNumber.toString()));
-        const finishedEpisodes = watchedEpisodes
-            .filter((ep) => ep.duration > 0 && ep.currentTime >= ep.duration * 0.8)
-            .map((ep) => parseFloat(ep.episodeNumber))
-            .filter((ep) => !Number.isNaN(ep));
-        const nextAfterFinished = finishedEpisodes.length > 0 ? String(Math.max(...finishedEpisodes) + 1) : undefined;
-        const episodeNumber = (nextAfterFinished &&
-            episodes.includes(nextAfterFinished) &&
-            !watchedSet.has(nextAfterFinished)
-            ? nextAfterFinished
-            : episodes.find((ep) => !watchedSet.has(ep))) ||
-            episodes[0] ||
-            '1';
-        res.json({ showId, episodeNumber, resumeTime: 0 });
-    };
-    getEpisodeProgress = async (req, res) => {
-        const showId = await getMigratedId(req.db, req.params.showId);
-        const progress = await WatchedEpisodesRepository.getByShowAndEpisode(req.db, showId, req.params.episodeNumber);
-        res.json(progress || { currentTime: 0, duration: 0 });
-    };
-    getWatchedEpisodes = async (req, res) => {
-        const showId = await getMigratedId(req.db, req.params.showId);
-        const episodes = await WatchedEpisodesRepository.getWatchedEpisodeNumbers(req.db, showId);
-        res.json(episodes);
-    };
-    addToWatchlist = async (req, res) => {
-        const { id: idRaw, status, nativeName, englishName } = req.body;
-        const { name, thumbnail, type, isAdult: isAdultRaw } = req.body;
-        const id = await getMigratedId(req.db, idRaw);
-        await performWriteTransaction(req.db, (tx) => {
-            WatchlistRepository.upsert(tx, {
-                id,
-                name,
-                thumbnail: thumbnail,
-                status: status || 'Watching',
-                nativeName: nativeName || '',
-                englishName: englishName || '',
-                type: type || 'TV',
-            });
-            if (typeof isAdultRaw === 'boolean') {
-                ShowsMetaRepository.upsert(tx, { id, isAdult: isAdultRaw ? 1 : 0 });
-            }
-        });
-        await req.db.saveNow();
-        if (name && !/^\d+$/.test(id)) {
-            const resolveAndSave = async () => {
-                if (!isAnilistRateLimited()) {
-                    const result = await searchAnilistByTitle(name);
-                    if (result?.id) {
-                        ShowsMetaRepository.upsert(req.db, { id, anilistId: result.id });
-                        req.db.scheduleSave();
-                        return;
-                    }
-                }
-                try {
-                    const kitsuResults = await kitsuSearchAnime({ query: name, page: 1, perPage: 3 });
-                    if (kitsuResults.length > 0) {
-                        const anilistId = Math.abs(kitsuResults[0].id);
-                        ShowsMetaRepository.upsert(req.db, { id, anilistId });
-                        req.db.scheduleSave();
-                    }
-                }
-                catch {
-                    // Kitsu failed, show will be skipped in discovery
-                }
-            };
-            resolveAndSave().catch(() => { });
-        }
-        res.json({ success: true });
-    };
-    removeFromWatchlist = async (req, res) => {
-        const { id: idRaw } = req.body;
-        const id = await getMigratedId(req.db, idRaw);
-        await performWriteTransaction(req.db, (tx) => {
-            WatchlistRepository.delete(tx, id);
-            WatchedEpisodesRepository.deleteByShow(tx, id);
-            NotificationsRepository.deleteByShow(tx, id);
-        });
-        res.json({ success: true });
-    };
-    updateWatchlistStatus = async (req, res) => {
-        const { id: idRaw, status } = req.body;
-        const id = await getMigratedId(req.db, idRaw);
-        await performWriteTransaction(req.db, (tx) => {
-            WatchlistRepository.updateStatus(tx, id, status);
-        });
-        res.json({ success: true });
-    };
-    batchUpdateWatchlistStatus = async (req, res) => {
-        const { ids: idsRaw, status } = req.body;
-        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
-            return res.status(400).json({ error: 'ids must be a non-empty array' });
-        }
-        if (!status) {
-            return res.status(400).json({ error: 'status is required' });
-        }
-        const ids = await Promise.all(idsRaw.map((id) => getMigratedId(req.db, id)));
-        await performWriteTransaction(req.db, (tx) => {
-            WatchlistRepository.updateStatusMany(tx, ids, status);
-        });
-        req.db.scheduleSave();
-        res.json({ success: true, updated: ids.length });
-    };
-    batchRemoveFromWatchlist = async (req, res) => {
-        const { ids: idsRaw } = req.body;
-        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
-            return res.status(400).json({ error: 'ids must be a non-empty array' });
-        }
-        const ids = await Promise.all(idsRaw.map((id) => getMigratedId(req.db, id)));
-        await performWriteTransaction(req.db, (tx) => {
-            WatchlistRepository.deleteMany(tx, ids);
-            for (const id of ids) {
-                WatchedEpisodesRepository.deleteByShow(tx, id);
-                NotificationsRepository.deleteByShow(tx, id);
-            }
-        });
-        req.db.scheduleSave();
-        res.json({ success: true, removed: ids.length });
-    };
-    getNotifications = async (req, res) => {
-        const db = req.db;
-        const watchingShows = await WatchlistRepository.getWatchingShows(db);
-        const notifications = [];
-        for (const show of watchingShows) {
-            try {
-                const [watchedEps, dismissedEps, discoveredEps] = await Promise.all([
-                    WatchedEpisodesRepository.getWatchedEpisodeNumbers(db, show.id),
-                    NotificationsRepository.getDismissedByShow(db, show.id),
-                    NotificationsRepository.getDiscoveredByShow(db, show.id),
-                ]);
-                const watchedSet = new Set(watchedEps.map((e) => e.toString()));
-                const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
-                for (const discovered of discoveredEps) {
-                    if (!watchedSet.has(discovered.episodeNumber) &&
-                        !dismissedSet.has(discovered.episodeNumber)) {
-                        notifications.push({
-                            showId: show.id,
-                            name: show.name,
-                            nativeName: show.nativeName,
-                            englishName: show.englishName,
-                            thumbnail: show.thumbnail,
-                            episodeNumber: discovered.episodeNumber,
-                            id: `${show.id}-${discovered.episodeNumber}`,
-                        });
-                    }
-                }
-            }
-            catch (e) {
-                logger.error({ err: e, showId: show.id }, 'Failed to get notifications for show');
-            }
-        }
-        res.json(notifications.sort((a, b) => parseFloat(b.episodeNumber) - parseFloat(a.episodeNumber)));
-    };
-    dismissNotification = async (req, res) => {
-        const { showId, episodeNumber } = req.body;
-        await performWriteTransaction(req.db, (tx) => {
-            NotificationsRepository.addDismissed(tx, showId, episodeNumber);
-        });
-        res.json({ success: true });
-    };
-    clearAllNotifications = async (req, res) => {
-        const { showId } = req.body;
-        await performWriteTransaction(req.db, (tx) => {
-            NotificationsRepository.dismissFromDiscovered(tx, showId);
-        });
-        res.json({ success: true });
-    };
-    getThisWeekSchedule = async (req, res) => {
-        const rows = await dbAll(req.db, `SELECT
-        w.id, w.name, w.thumbnail, w.nativeName, w.englishName, w.type,
-        dn.episodeNumber, dn.discoveredAt
-      FROM discovered_notifications dn
-      JOIN watchlist w ON dn.showId = w.id
-      WHERE w.status = 'Watching'
-        AND EXISTS (
-          SELECT 1 FROM discovered_notifications dn_recent
-          WHERE dn_recent.showId = dn.showId
-            AND dn_recent.discoveredAt >= datetime('now', '-7 days')
-        )
-        AND CAST(dn.episodeNumber AS INTEGER) = (
-          SELECT MIN(CAST(dn2.episodeNumber AS INTEGER))
-          FROM discovered_notifications dn2
-          WHERE dn2.showId = dn.showId
-            AND NOT EXISTS (
-              SELECT 1 FROM watched_episodes we2
-              WHERE we2.showId = dn2.showId AND we2.episodeNumber = dn2.episodeNumber
-            )
-        )
-        AND NOT EXISTS (
-          SELECT 1 FROM watched_episodes we
-          WHERE we.showId = dn.showId AND we.episodeNumber = dn.episodeNumber
-        )
-      ORDER BY CAST(dn.episodeNumber AS INTEGER) ASC`);
-        res.json(rows.map((row) => ({
-            _id: row.id,
-            id: row.id,
-            name: row.name,
-            thumbnail: row.thumbnail || '',
-            nativeName: row.nativeName,
-            englishName: row.englishName,
-            type: row.type,
-            episodeNumber: parseInt(row.episodeNumber) || row.episodeNumber,
-        })));
-    };
-}