@serifpersia/dango 3.3.4

package/server/dist/repositories/mal-cache.repository.js

@@ -0,0 +1,55 @@
+import { DatabaseSync } from 'node:sqlite';
+import fs from 'fs';
+import path from 'path';
+import { CONFIG } from '../config.js';
+import { DatabaseWrapper } from '../db.js';
+import { dbGet, dbRun } from '../utils/db-utils.js';
+export const MAL_CACHE_MAX_ROWS = 5000;
+const DEFAULT_TTL_SECONDS = 6 * 3600;
+function cacheFile() {
+    return path.join(CONFIG.ROOT, CONFIG.IS_DEV ? 'mal-cache.dev.db' : 'mal-cache.db');
+}
+let handle = null;
+function db() {
+    if (!handle) {
+        const file = cacheFile();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        handle = new DatabaseWrapper(file, new DatabaseSync(file));
+        dbRun(handle, `CREATE TABLE IF NOT EXISTS mal_cache (key TEXT PRIMARY KEY, payload TEXT NOT NULL, fetched_at TEXT NOT NULL, expires_at TEXT NOT NULL)`);
+    }
+    return handle;
+}
+export function malCacheGet(key) {
+    const row = dbGet(db(), 'SELECT payload, fetched_at AS fetchedAt, expires_at AS expiresAt FROM mal_cache WHERE key = ?', [key]);
+    if (!row)
+        return null;
+    return { payload: row.payload, fresh: Date.now() < Date.parse(row.expiresAt) };
+}
+export function malCachePut(key, payload, ttlSeconds = DEFAULT_TTL_SECONDS) {
+    const database = db();
+    const now = new Date();
+    dbRun(database, 'INSERT OR REPLACE INTO mal_cache (key, payload, fetched_at, expires_at) VALUES (?, ?, ?, ?)', [key, payload, now.toISOString(), new Date(now.getTime() + ttlSeconds * 1000).toISOString()]);
+    const count = dbGet(database, 'SELECT COUNT(*) AS rows FROM mal_cache')?.rows ?? 0;
+    if (count < MAL_CACHE_MAX_ROWS)
+        return;
+    malCachePruneExpired();
+    const remaining = dbGet(database, 'SELECT COUNT(*) AS rows FROM mal_cache')?.rows ?? 0;
+    if (remaining < MAL_CACHE_MAX_ROWS)
+        return;
+    dbRun(database, `DELETE FROM mal_cache WHERE key NOT IN (SELECT key FROM mal_cache ORDER BY fetched_at DESC LIMIT ${MAL_CACHE_MAX_ROWS})`);
+}
+export function malCachePruneExpired() {
+    const now = new Date().toISOString();
+    const row = dbGet(db(), 'SELECT COUNT(*) AS rows FROM mal_cache WHERE expires_at < ?', [now]);
+    dbRun(db(), 'DELETE FROM mal_cache WHERE expires_at < ?', [now]);
+    return row?.rows ?? 0;
+}
+export function malCacheDelete(key) {
+    dbRun(db(), 'DELETE FROM mal_cache WHERE key = ?', [key]);
+}
+export function malCacheStore() {
+    return {
+        get: (key) => malCacheGet(key),
+        put: (key, payload, ttl) => malCachePut(key, payload, ttl),
+    };
+}

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

@@ -0,0 +1,138 @@
+import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+export const MANGA_STATUSES = [
+    'Reading',
+    'Completed',
+    'On-Hold',
+    'Dropped',
+    'Planned',
+];
+export function buildMangaId(provider, mangaId) {
+    return `${provider.toLowerCase()}:${mangaId}`;
+}
+export const MangaLibraryRepository = {
+    getById: (db, id) => dbGet(db, 'SELECT * FROM manga_library WHERE id = ?', [id]),
+    exists: (db, id) => {
+        const row = dbGet(db, 'SELECT EXISTS(SELECT 1 FROM manga_library WHERE id = ?) as inLibrary', [id]);
+        return !!(row && row.inLibrary);
+    },
+    getAll: (db, status, limit, offset) => {
+        let query = 'SELECT * FROM manga_library';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY updatedAt DESC';
+        if (limit !== undefined && offset !== undefined) {
+            query += ' LIMIT ? OFFSET ?';
+            params.push(limit, offset);
+        }
+        return dbAll(db, query, params);
+    },
+    getCount: (db, status) => {
+        let query = 'SELECT COUNT(*) as total FROM manga_library';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        const row = dbGet(db, query, params);
+        return row?.total || 0;
+    },
+    getIds: (db) => dbAll(db, 'SELECT id FROM manga_library').map((r) => r.id),
+    upsert: (db, data) => dbRun(db, `INSERT INTO manga_library (id, provider, mangaId, title, cover, status, author, altTitle, contentRating, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
+       ON CONFLICT(id) DO UPDATE SET
+          provider = COALESCE(NULLIF(EXCLUDED.provider, ''), manga_library.provider),
+          title = COALESCE(NULLIF(EXCLUDED.title, ''), manga_library.title),
+          cover = COALESCE(NULLIF(EXCLUDED.cover, ''), manga_library.cover),
+          status = COALESCE(NULLIF(EXCLUDED.status, ''), manga_library.status),
+          author = COALESCE(NULLIF(EXCLUDED.author, ''), manga_library.author),
+          altTitle = COALESCE(NULLIF(EXCLUDED.altTitle, ''), manga_library.altTitle),
+          contentRating = COALESCE(EXCLUDED.contentRating, manga_library.contentRating),
+          updatedAt = strftime('%s', 'now')`, [
+        data.id,
+        data.provider,
+        data.mangaId,
+        data.title,
+        data.cover,
+        data.status,
+        data.author || null,
+        data.altTitle || null,
+        data.contentRating || null,
+    ]),
+    updateStatus: (db, id, status) => dbRun(db, "UPDATE manga_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id = ?", [status, id]),
+    updateStatusMany: (db, ids, status) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `UPDATE manga_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id IN (${placeholders})`, [status, ...ids]);
+    },
+    touchProgress: (db, id, progress) => dbRun(db, `UPDATE manga_library SET lastChapterId = ?, lastChapterNumber = ?, lastPage = ?, updatedAt = strftime('%s', 'now') WHERE id = ?`, [progress.chapterId, progress.chapterNumber, progress.page, id]),
+    delete: (db, id) => dbRun(db, 'DELETE FROM manga_library WHERE id = ?', [id]),
+    deleteMany: (db, ids) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `DELETE FROM manga_library WHERE id IN (${placeholders})`, ids);
+    },
+};
+export const MangaProgressRepository = {
+    getByManga: (db, mangaId) => dbAll(db, 'SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ? ORDER BY updatedAt DESC', [mangaId]),
+    getChapter: (db, mangaId, chapterId) => dbGet(db, 'SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ? AND chapterId = ?', [mangaId, chapterId]),
+    getLatest: (db, mangaId) => dbGet(db, 'SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ? ORDER BY updatedAt DESC LIMIT 1', [mangaId]),
+    upsert: (db, data) => dbRun(db, `INSERT INTO manga_progress (mangaId, chapterId, chapterNumber, page, pageCount, title, cover, provider, altTitle, contentRating, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
+       ON CONFLICT(mangaId, chapterId) DO UPDATE SET
+          chapterNumber = COALESCE(NULLIF(EXCLUDED.chapterNumber, ''), manga_progress.chapterNumber),
+          page = EXCLUDED.page,
+          pageCount = EXCLUDED.pageCount,
+          title = COALESCE(EXCLUDED.title, manga_progress.title),
+          cover = COALESCE(EXCLUDED.cover, manga_progress.cover),
+          provider = COALESCE(EXCLUDED.provider, manga_progress.provider),
+          altTitle = COALESCE(EXCLUDED.altTitle, manga_progress.altTitle),
+          contentRating = COALESCE(EXCLUDED.contentRating, manga_progress.contentRating),
+          updatedAt = strftime('%s', 'now')`, [
+        data.mangaId,
+        data.chapterId,
+        data.chapterNumber,
+        data.page,
+        data.pageCount,
+        data.title ?? null,
+        data.cover ?? null,
+        data.provider ?? null,
+        data.altTitle ?? null,
+        data.contentRating ?? null,
+    ]),
+    deleteByManga: (db, mangaId) => dbRun(db, 'DELETE FROM manga_progress WHERE mangaId = ?', [mangaId]),
+    deleteMany: (db, ids) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `DELETE FROM manga_progress WHERE mangaId IN (${placeholders})`, ids);
+    },
+    deleteChapter: (db, mangaId, chapterId) => dbRun(db, 'DELETE FROM manga_progress WHERE mangaId = ? AND chapterId = ?', [
+        mangaId,
+        chapterId,
+    ]),
+    getContinueReading: (db, limit) => {
+        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
+        return dbAll(db, `SELECT p.mangaId as id,
+              COALESCE(l.mangaId, SUBSTR(p.mangaId, INSTR(p.mangaId, ':') + 1)) as mangaId,
+              COALESCE(l.provider, p.provider) as provider,
+              COALESCE(l.title, p.title) as title, COALESCE(l.cover, p.cover) as cover,
+              COALESCE(l.author, '') as author, COALESCE(l.altTitle, p.altTitle) as altTitle,
+              COALESCE(l.contentRating, p.contentRating) as contentRating,
+              l.status as watchlistStatus,
+              p.chapterId, p.chapterNumber, p.page, p.pageCount, p.updatedAt as progressAt
+       FROM (
+         SELECT *, ROW_NUMBER() OVER (PARTITION BY mangaId ORDER BY updatedAt DESC) as rn
+         FROM manga_progress
+       ) p
+       LEFT JOIN manga_library l ON p.mangaId = l.id
+       WHERE p.rn = 1
+         AND (l.status IS NULL OR l.status = 'Reading')
+       ORDER BY p.updatedAt DESC
+       ${limitClause}`);
+    },
+};

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

@@ -0,0 +1,41 @@
+import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+export const NotificationsRepository = {
+    getDismissedByShow: (db, showId) => dbAll(db, 'SELECT episodeNumber FROM dismissed_notifications WHERE showId = ?', [showId]),
+    getDiscoveredByShow: (db, showId) => dbAll(db, 'SELECT episodeNumber FROM discovered_notifications WHERE showId = ?', [showId]),
+    addDiscovered: (db, showId, episodeNumber) => dbRun(db, 'INSERT OR IGNORE INTO discovered_notifications (showId, episodeNumber) VALUES (?, ?)', [showId, episodeNumber]),
+    addDismissed: (db, showId, episodeNumber) => dbRun(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) VALUES (?, ?)', [showId, episodeNumber]),
+    dismissFromDiscovered: (db, showId) => {
+        if (showId) {
+            return dbRun(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications WHERE showId = ?', [showId]);
+        }
+        else {
+            return dbRun(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications');
+        }
+    },
+    deleteByShow: (db, showId) => Promise.all([
+        dbRun(db, 'DELETE FROM dismissed_notifications WHERE showId = ?', [showId]),
+        dbRun(db, 'DELETE FROM discovered_notifications WHERE showId = ?', [showId]),
+    ]),
+    deleteSpecificDismissed: (db, showId, episodeNumber) => dbRun(db, 'DELETE FROM dismissed_notifications WHERE showId = ? AND episodeNumber = ?', [
+        showId,
+        episodeNumber,
+    ]),
+    deleteDiscovered: (db, showId, episodeNumber) => dbRun(db, 'DELETE FROM discovered_notifications WHERE showId = ? AND episodeNumber = ?', [
+        showId,
+        episodeNumber,
+    ]),
+    cleanupWatchedNotifications: (db) => Promise.all([
+        dbRun(db, 'DELETE FROM dismissed_notifications WHERE EXISTS (SELECT 1 FROM watched_episodes we WHERE we.showId = dismissed_notifications.showId AND we.episodeNumber = dismissed_notifications.episodeNumber)'),
+        dbRun(db, 'DELETE FROM discovered_notifications WHERE EXISTS (SELECT 1 FROM watched_episodes we WHERE we.showId = discovered_notifications.showId AND we.episodeNumber = discovered_notifications.episodeNumber)'),
+    ]),
+    hasAnyDiscovered: (db) => Promise.resolve(dbGet(db, 'SELECT COUNT(*) as count FROM discovered_notifications')).then((row) => (row?.count || 0) > 0),
+    hasActiveNotifications: (db) => Promise.resolve(dbGet(db, `SELECT COUNT(*) as count FROM discovered_notifications dn
+         WHERE NOT EXISTS (
+           SELECT 1 FROM dismissed_notifications dn2 
+           WHERE dn2.showId = dn.showId AND dn2.episodeNumber = dn.episodeNumber
+         )
+         AND NOT EXISTS (
+           SELECT 1 FROM watched_episodes we 
+           WHERE we.showId = dn.showId AND we.episodeNumber = dn.episodeNumber
+         )`)).then((row) => (row?.count || 0) > 0),
+};

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

@@ -0,0 +1,61 @@
+import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+export const QueueRepository = {
+    getAll: (db) => dbAll(db, `SELECT
+        q.id,
+        q.showId,
+        q.episodeNumber,
+        q.queue_order,
+        COALESCE(NULLIF(sm.name, ''), w.name) as name,
+        COALESCE(NULLIF(sm.thumbnail, ''), NULLIF(w.thumbnail, ''), '') as thumbnail,
+        COALESCE(NULLIF(sm.nativeName, ''), w.nativeName) as nativeName,
+        COALESCE(NULLIF(sm.englishName, ''), w.englishName) as englishName,
+        COALESCE(NULLIF(sm.type, ''), w.type) as type
+      FROM queue q
+      LEFT JOIN shows_meta sm ON q.showId = sm.id
+      LEFT JOIN watchlist w ON q.showId = w.id
+      ORDER BY q.queue_order ASC, q.id ASC`),
+    getByEpisode: (db, showId, episodeNumber) => dbGet(db, 'SELECT * FROM queue WHERE showId = ? AND episodeNumber = ?', [
+        showId,
+        episodeNumber,
+    ]),
+    getByShow: (db, showId) => dbAll(db, 'SELECT * FROM queue WHERE showId = ? ORDER BY queue_order ASC', [showId]),
+    getMaxOrder: async (db) => {
+        const row = await dbGet(db, 'SELECT COALESCE(MAX(queue_order), -1) as maxOrder FROM queue');
+        return row?.maxOrder ?? -1;
+    },
+    addToEnd: (db, showId, episodeNumber) => dbRun(db, 'INSERT INTO queue (showId, episodeNumber, queue_order) VALUES (?, ?, (SELECT COALESCE(MAX(queue_order), -1) + 1 FROM queue))', [showId, episodeNumber]),
+    removeEpisode: (db, showId, episodeNumber) => dbRun(db, 'DELETE FROM queue WHERE showId = ? AND episodeNumber = ?', [showId, episodeNumber]),
+    addManyToEnd: async (db, episodes) => {
+        if (episodes.length === 0)
+            return;
+        let nextOrder = (await QueueRepository.getMaxOrder(db)) + 1;
+        for (const episode of episodes) {
+            const existing = await QueueRepository.getByEpisode(db, episode.showId, episode.episodeNumber);
+            if (existing)
+                continue;
+            await dbRun(db, 'INSERT INTO queue (showId, episodeNumber, queue_order) VALUES (?, ?, ?)', [
+                episode.showId,
+                episode.episodeNumber,
+                nextOrder,
+            ]);
+            nextOrder += 1;
+        }
+    },
+    removeMany: (db, showId, episodeNumbers) => {
+        if (episodeNumbers.length === 0)
+            return Promise.resolve();
+        const placeholders = episodeNumbers.map(() => '?').join(', ');
+        return dbRun(db, `DELETE FROM queue WHERE showId = ? AND episodeNumber IN (${placeholders})`, [
+            showId,
+            ...episodeNumbers,
+        ]);
+    },
+    clear: (db) => dbRun(db, 'DELETE FROM queue'),
+    reorder: (db, items) => Promise.all(items.map((item, index) => {
+        if (item.id !== undefined) {
+            return dbRun(db, 'UPDATE queue SET queue_order = ? WHERE id = ?', [index, item.id]);
+        }
+        return dbRun(db, 'UPDATE queue SET queue_order = ? WHERE showId = ? AND episodeNumber = ?', [index, item.showId, item.episodeNumber]);
+    })),
+    cleanupOrphanedShowsMeta: (db) => dbRun(db, 'DELETE FROM shows_meta WHERE id NOT IN (SELECT id FROM watchlist) AND id NOT IN (SELECT showId FROM queue)'),
+};

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

@@ -0,0 +1,12 @@
+import { dbGet, dbRun } from '../utils/db-utils.js';
+export const SettingsRepository = {
+    getByKey: (db, key) => dbGet(db, 'SELECT value FROM settings WHERE key = ?', [key]),
+    upsert: (db, key, value) => dbRun(db, 'INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)', [key, value]),
+    deleteByKey: (db, key) => dbRun(db, 'DELETE FROM settings WHERE key = ?', [key]),
+    clearWatchlist: (db) => dbRun(db, 'DELETE FROM watchlist'),
+    upsertWatchlistBatch: (db, shows) => {
+        for (const show of shows) {
+            dbRun(db, 'INSERT OR REPLACE INTO watchlist (id, name, thumbnail, status) VALUES (?, ?, ?, ?)', [show.id, show.name, show.thumbnail ?? null, show.status]);
+        }
+    },
+};

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

@@ -0,0 +1,42 @@
+import { dbGet, dbRun } from '../utils/db-utils.js';
+export const ShowsMetaRepository = {
+    getById: (db, id) => dbGet(db, 'SELECT * FROM shows_meta WHERE id = ?', [id]),
+    getStatus: async (db, id) => {
+        const row = await dbGet(db, 'SELECT status FROM shows_meta WHERE id = ?', [
+            id,
+        ]);
+        return row?.status;
+    },
+    upsert: (db, data) => dbRun(db, `INSERT INTO shows_meta (id, name, thumbnail, nativeName, englishName, genres, popularityScore, status, episodeCount, type, anilistId, isAdult, episodeDuration)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+          name = COALESCE(NULLIF(EXCLUDED.name, ''), shows_meta.name),
+          thumbnail = COALESCE(NULLIF(EXCLUDED.thumbnail, ''), shows_meta.thumbnail),
+          nativeName = COALESCE(NULLIF(EXCLUDED.nativeName, ''), shows_meta.nativeName),
+          englishName = COALESCE(NULLIF(EXCLUDED.englishName, ''), shows_meta.englishName),
+          genres = COALESCE(NULLIF(EXCLUDED.genres, ''), shows_meta.genres),
+          popularityScore = COALESCE(EXCLUDED.popularityScore, shows_meta.popularityScore),
+          status = COALESCE(NULLIF(EXCLUDED.status, ''), shows_meta.status),
+          episodeCount = COALESCE(EXCLUDED.episodeCount, shows_meta.episodeCount),
+          type = COALESCE(NULLIF(EXCLUDED.type, ''), shows_meta.type),
+          anilistId = COALESCE(EXCLUDED.anilistId, shows_meta.anilistId),
+          isAdult = COALESCE(EXCLUDED.isAdult, shows_meta.isAdult),
+          episodeDuration = COALESCE(NULLIF(EXCLUDED.episodeDuration, 0), shows_meta.episodeDuration)`, [
+        data.id,
+        data.name ?? null,
+        data.thumbnail ?? null,
+        data.nativeName ?? null,
+        data.englishName ?? null,
+        data.genres ?? null,
+        data.popularityScore ?? null,
+        data.status ?? null,
+        data.episodeCount ?? null,
+        data.type ?? null,
+        data.anilistId ?? null,
+        data.isAdult ?? null,
+        data.episodeDuration ?? null,
+    ]),
+    updateEpisodeCount: (db, id, episodeCount) => dbRun(db, 'UPDATE shows_meta SET episodeCount = ? WHERE id = ?', [episodeCount, id]),
+    updateStatus: (db, id, status) => dbRun(db, 'UPDATE shows_meta SET status = ? WHERE id = ?', [status, id]),
+    cleanupOrphanedMeta: (db) => dbRun(db, 'DELETE FROM shows_meta WHERE id NOT IN (SELECT id FROM watchlist) AND id NOT IN (SELECT showId FROM queue)'),
+};

package/server/dist/repositories/temp-show-ids.repository.js

@@ -0,0 +1,51 @@
+import { dbGet, dbRun } from '../utils/db-utils.js';
+import { TEMP_SHOW_ID_PREFIX } from '../lib/temp-ids.js';
+export const TempShowIdsRepository = {
+    getById: (db, id) => dbGet(db, 'SELECT * FROM temp_show_ids WHERE id = ?', [id]),
+    getByProviderNative: (db, provider, nativeId) => dbGet(db, 'SELECT * FROM temp_show_ids WHERE provider = ? AND nativeId = ?', [
+        provider,
+        nativeId,
+    ]),
+    count: (db) => {
+        const row = dbGet(db, 'SELECT COUNT(*) as total FROM temp_show_ids');
+        return row?.total || 0;
+    },
+    allocate: (db, data) => {
+        const existing = TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
+        if (existing)
+            return existing;
+        const prefixLen = TEMP_SHOW_ID_PREFIX.length + 1;
+        const maxRow = dbGet(db, `SELECT MAX(CAST(SUBSTR(id, ?) AS INTEGER)) as maxId FROM temp_show_ids WHERE id LIKE '${TEMP_SHOW_ID_PREFIX}%'`, [prefixLen]);
+        const next = (maxRow?.maxId || 0) + 1;
+        const id = `${TEMP_SHOW_ID_PREFIX}${next}`;
+        try {
+            dbRun(db, 'INSERT INTO temp_show_ids (id, provider, nativeId, title, thumbnail, createdAt) VALUES (?, ?, ?, ?, ?, ?)', [id, data.provider, data.nativeId, data.title, data.thumbnail || '', Date.now()]);
+        }
+        catch {
+            // Lost a race with a concurrent allocate — return whatever won.
+            const winner = TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
+            if (winner)
+                return winner;
+            throw new Error('temp id allocation failed');
+        }
+        return TempShowIdsRepository.getById(db, id);
+    },
+    purge: (db) => {
+        const total = TempShowIdsRepository.count(db);
+        if (total === 0)
+            return 0;
+        const like = `${TEMP_SHOW_ID_PREFIX}%`;
+        dbRun(db, 'DELETE FROM watchlist WHERE id LIKE ?', [like]);
+        dbRun(db, 'DELETE FROM watched_episodes WHERE showId LIKE ?', [like]);
+        dbRun(db, 'DELETE FROM queue WHERE showId LIKE ?', [like]);
+        dbRun(db, 'DELETE FROM shows_meta WHERE id LIKE ?', [like]);
+        dbRun(db, 'DELETE FROM dismissed_notifications WHERE showId LIKE ?', [like]);
+        dbRun(db, 'DELETE FROM discovered_notifications WHERE showId LIKE ?', [like]);
+        dbRun(db, 'DELETE FROM legacy_id_mapping WHERE legacyId LIKE ? OR numericId LIKE ?', [
+            like,
+            like,
+        ]);
+        dbRun(db, 'DELETE FROM temp_show_ids');
+        return total;
+    },
+};

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

@@ -0,0 +1,151 @@
+import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+export const TV_STATUSES = ['Watching', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
+export function buildTvId(mediaType, tmdbId) {
+    const t = String(mediaType).toLowerCase() === 'movie' ? 'movie' : 'tv';
+    return `${t}:${tmdbId}`;
+}
+export function normalizeTvMediaId(raw) {
+    const s = String(raw ?? '').trim();
+    const m = /^(movie|tv)[:-](\d+)$/i.exec(s);
+    if (m)
+        return `${m[1].toLowerCase()}:${m[2]}`;
+    return s;
+}
+export const TvLibraryRepository = {
+    getById: (db, id) => dbGet(db, 'SELECT * FROM tv_library WHERE id = ?', [id]),
+    exists: (db, id) => {
+        const row = dbGet(db, 'SELECT EXISTS(SELECT 1 FROM tv_library WHERE id = ?) as inLibrary', [id]);
+        return !!(row && row.inLibrary);
+    },
+    getAll: (db, status, limit, offset) => {
+        let query = 'SELECT * FROM tv_library';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY updatedAt DESC';
+        if (limit !== undefined && offset !== undefined) {
+            query += ' LIMIT ? OFFSET ?';
+            params.push(limit, offset);
+        }
+        return dbAll(db, query, params);
+    },
+    getCount: (db, status) => {
+        let query = 'SELECT COUNT(*) as total FROM tv_library';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        const row = dbGet(db, query, params);
+        return row?.total || 0;
+    },
+    getIds: (db) => dbAll(db, 'SELECT id FROM tv_library').map((r) => r.id),
+    upsert: (db, data) => dbRun(db, `INSERT INTO tv_library (id, tmdbId, mediaType, title, poster, backdrop, year, overview, status, adult, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
+       ON CONFLICT(id) DO UPDATE SET
+          tmdbId = EXCLUDED.tmdbId,
+          mediaType = EXCLUDED.mediaType,
+          title = COALESCE(NULLIF(EXCLUDED.title, ''), tv_library.title),
+          poster = COALESCE(NULLIF(EXCLUDED.poster, ''), tv_library.poster),
+          backdrop = COALESCE(NULLIF(EXCLUDED.backdrop, ''), tv_library.backdrop),
+          year = COALESCE(NULLIF(EXCLUDED.year, ''), tv_library.year),
+          overview = COALESCE(NULLIF(EXCLUDED.overview, ''), tv_library.overview),
+          status = COALESCE(NULLIF(EXCLUDED.status, ''), tv_library.status),
+          adult = COALESCE(EXCLUDED.adult, tv_library.adult),
+          updatedAt = strftime('%s', 'now')`, [
+        data.id,
+        data.tmdbId,
+        data.mediaType,
+        data.title,
+        data.poster,
+        data.backdrop || null,
+        data.year || null,
+        data.overview || null,
+        data.status,
+        data.adult ? 1 : 0,
+    ]),
+    updateStatus: (db, id, status) => dbRun(db, "UPDATE tv_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id = ?", [
+        status,
+        id,
+    ]),
+    updateStatusMany: (db, ids, status) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `UPDATE tv_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id IN (${placeholders})`, [status, ...ids]);
+    },
+    touchProgress: (db, id, progress) => dbRun(db, `UPDATE tv_library SET lastSeason = ?, lastEpisode = ?, updatedAt = strftime('%s', 'now') WHERE id = ?`, [progress.season, progress.episode, id]),
+    delete: (db, id) => dbRun(db, 'DELETE FROM tv_library WHERE id = ?', [id]),
+    deleteMany: (db, ids) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `DELETE FROM tv_library WHERE id IN (${placeholders})`, ids);
+    },
+};
+export const TvProgressRepository = {
+    getByMedia: (db, mediaId) => dbAll(db, 'SELECT mediaId, season, episode, currentTime, duration, updatedAt FROM tv_progress WHERE mediaId = ? ORDER BY updatedAt DESC', [mediaId]),
+    getEpisode: (db, mediaId, season, episode) => dbGet(db, 'SELECT mediaId, season, episode, currentTime, duration, updatedAt FROM tv_progress WHERE mediaId = ? AND season = ? AND episode = ?', [mediaId, season, episode]),
+    getLatest: (db, mediaId) => dbGet(db, 'SELECT mediaId, season, episode, currentTime, duration, updatedAt FROM tv_progress WHERE mediaId = ? ORDER BY updatedAt DESC LIMIT 1', [mediaId]),
+    upsert: (db, data) => dbRun(db, `INSERT INTO tv_progress (mediaId, season, episode, currentTime, duration, title, poster, backdrop, year, overview, tmdbId, mediaType, adult, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
+       ON CONFLICT(mediaId, season, episode) DO UPDATE SET
+          currentTime = EXCLUDED.currentTime,
+          duration = EXCLUDED.duration,
+          title = COALESCE(EXCLUDED.title, tv_progress.title),
+          poster = COALESCE(EXCLUDED.poster, tv_progress.poster),
+          backdrop = COALESCE(EXCLUDED.backdrop, tv_progress.backdrop),
+          year = COALESCE(EXCLUDED.year, tv_progress.year),
+          overview = COALESCE(EXCLUDED.overview, tv_progress.overview),
+          tmdbId = COALESCE(EXCLUDED.tmdbId, tv_progress.tmdbId),
+          mediaType = COALESCE(EXCLUDED.mediaType, tv_progress.mediaType),
+          adult = COALESCE(EXCLUDED.adult, tv_progress.adult),
+          updatedAt = strftime('%s', 'now')`, [
+        data.mediaId,
+        data.season,
+        data.episode,
+        data.currentTime,
+        data.duration,
+        data.title ?? null,
+        data.poster ?? null,
+        data.backdrop ?? null,
+        data.year ?? null,
+        data.overview ?? null,
+        data.tmdbId ?? null,
+        data.mediaType ?? null,
+        data.adult ?? null,
+    ]),
+    deleteByMedia: (db, mediaId) => dbRun(db, 'DELETE FROM tv_progress WHERE mediaId = ?', [mediaId]),
+    deleteMany: (db, ids) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `DELETE FROM tv_progress WHERE mediaId IN (${placeholders})`, ids);
+    },
+    deleteEpisode: (db, mediaId, season, episode) => dbRun(db, 'DELETE FROM tv_progress WHERE mediaId = ? AND season = ? AND episode = ?', [
+        mediaId,
+        season,
+        episode,
+    ]),
+    getContinueWatching: (db, limit) => {
+        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
+        return dbAll(db, `SELECT p.mediaId as id,
+              COALESCE(l.tmdbId, p.tmdbId, CAST(SUBSTR(REPLACE(p.mediaId, '-', ':'), INSTR(REPLACE(p.mediaId, '-', ':'), ':') + 1) AS INTEGER)) as tmdbId,
+              COALESCE(l.mediaType, p.mediaType, SUBSTR(REPLACE(p.mediaId, '-', ':'), 1, INSTR(REPLACE(p.mediaId, '-', ':'), ':') - 1)) as mediaType,
+              COALESCE(l.title, p.title) as title, COALESCE(l.poster, p.poster) as poster, COALESCE(l.backdrop, p.backdrop) as backdrop,
+              COALESCE(l.year, p.year) as year, COALESCE(l.overview, p.overview) as overview,
+              l.status as watchlistStatus, COALESCE(l.adult, p.adult) as adult,
+              p.season, p.episode, p.currentTime, p.duration, p.updatedAt as progressAt
+       FROM (
+         SELECT *, ROW_NUMBER() OVER (PARTITION BY mediaId ORDER BY updatedAt DESC) as rn
+         FROM tv_progress
+       ) p
+       LEFT JOIN tv_library l ON p.mediaId = l.id
+       WHERE p.rn = 1
+         AND (l.status IS NULL OR l.status = 'Watching')
+       ORDER BY p.updatedAt DESC
+       ${limitClause}`);
+    },
+};

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

@@ -0,0 +1,52 @@
+import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+export const WatchedEpisodesRepository = {
+    getByShowAndEpisode: (db, showId, episodeNumber) => dbGet(db, 'SELECT currentTime, duration FROM watched_episodes WHERE showId = ? AND episodeNumber = ?', [showId, episodeNumber]),
+    getWatchedEpisodeNumbers: async (db, showId) => {
+        const rows = await dbAll(db, 'SELECT episodeNumber FROM watched_episodes WHERE showId = ?', [showId]);
+        return rows.map((r) => r.episodeNumber);
+    },
+    getByShow: (db, showId) => dbAll(db, 'SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId = ? ORDER BY CAST(episodeNumber AS REAL) ASC', [showId]),
+    getLatestResumeProgress: (db, showId) => dbGet(db, `SELECT showId, episodeNumber, currentTime, duration, watchedAt
+       FROM watched_episodes
+       WHERE showId = ? AND currentTime > 5 AND (duration <= 0 OR currentTime < duration * 0.8)
+       ORDER BY watchedAt DESC
+       LIMIT 1`, [showId]),
+    upsert: (db, data) => dbRun(db, 'INSERT OR REPLACE INTO watched_episodes (showId, episodeNumber, watchedAt, currentTime, duration) VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?)', [data.showId, data.episodeNumber, data.currentTime, data.duration]),
+    insertIfMissing: (db, data) => dbRun(db, 'INSERT OR IGNORE INTO watched_episodes (showId, episodeNumber, watchedAt, currentTime, duration) VALUES (?, ?, COALESCE(?, CURRENT_TIMESTAMP), 0, 0)', [data.showId, data.episodeNumber, data.watchedAt ?? null]),
+    deleteByShow: (db, showId) => dbRun(db, 'DELETE FROM watched_episodes WHERE showId = ?', [showId]),
+    getContinueWatching: (db, limit) => {
+        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
+        const query = `
+      SELECT
+        we.showId as _id,
+        we.showId as id,
+        COALESCE(NULLIF(w.name, ''), sm.name) as name,
+        COALESCE(NULLIF(w.thumbnail, ''), NULLIF(sm.thumbnail, ''), '') as thumbnail,
+        COALESCE(NULLIF(w.nativeName, ''), sm.nativeName) as nativeName,
+        COALESCE(NULLIF(w.englishName, ''), sm.englishName) as englishName,
+        COALESCE(NULLIF(w.type, ''), sm.type) as type,
+        sm.episodeCount,
+        sm.type as smType,
+        sm.isAdult as isAdult,
+        w.status as watchlistStatus,
+        (SELECT COUNT(DISTINCT episodeNumber) FROM watched_episodes WHERE showId = we.showId) as watchedCount,
+        we.episodeNumber, we.currentTime, we.duration, we.watchedAt
+      FROM (
+        SELECT *, ROW_NUMBER() OVER(PARTITION BY showId ORDER BY (currentTime > 0 OR duration > 0) DESC, watchedAt DESC) as rn
+        FROM watched_episodes
+      ) we
+      LEFT 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 IS NULL OR w.status = 'Watching')
+        AND (w.id IS NOT NULL OR sm.id IS NOT NULL)
+      ORDER BY we.watchedAt DESC
+      ${limitClause}
+    `;
+        return dbAll(db, query);
+    },
+    getEpisodesForShows: (db, showIds) => {
+        const placeholders = showIds.map(() => '?').join(',');
+        return dbAll(db, `SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId IN (${placeholders})`, showIds);
+    },
+};