@serifpersia/dango 3.3.9 → 3.4.1

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

@@ -1,203 +0,0 @@
-import logger from '../logger.js';
-import { InsightsRepository } from '../repositories/insights.repository.js';
-import { computeDiscordSyncStats, getCachedRecommendations, } from '../lib/discord-roles-sync.service.js';
-export class InsightsController {
-    getWatchInsights = async (req, res) => {
-        const db = req.db;
-        const [core, activityGrid, hourlyDist, seasonality, allWatches, watchedShows, droppedWarning, velocities,] = (await Promise.all([
-            InsightsRepository.getCoreStats(db),
-            InsightsRepository.getActivityGrid(db),
-            InsightsRepository.getHourlyDist(db),
-            InsightsRepository.getSeasonality(db),
-            InsightsRepository.getAllWatches(db),
-            InsightsRepository.getWatchedShowsMeta(db),
-            InsightsRepository.getDroppedShows(db),
-            InsightsRepository.getCompletionVelocities(db),
-        ]));
-        const bingeFactor = activityGrid.length > 0 ? Math.max(...activityGrid.map((a) => a.count)) : 0;
-        const sessions = [];
-        if (allWatches.length > 0) {
-            let currentSessionSeconds = allWatches[0].effectiveSeconds ?? allWatches[0].currentTime;
-            for (let i = 1; i < allWatches.length; i++) {
-                const prev = new Date(allWatches[i - 1].watchedAt).getTime();
-                const curr = new Date(allWatches[i].watchedAt).getTime();
-                const gap = curr - prev;
-                if (Number.isFinite(gap) && gap > 0 && gap < 3600000) {
-                    currentSessionSeconds += allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
-                }
-                else {
-                    sessions.push(currentSessionSeconds);
-                    currentSessionSeconds = allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
-                }
-            }
-            sessions.push(currentSessionSeconds);
-        }
-        const avgSessionMinutes = sessions.length > 0
-            ? Math.round(sessions.reduce((a, b) => a + b, 0) / sessions.length / 60)
-            : 0;
-        const genreCounts = {};
-        let totalPopScore = 0;
-        let popCount = 0;
-        for (const show of watchedShows) {
-            let genres = [];
-            if (show.genres) {
-                try {
-                    if (show.genres.startsWith('[')) {
-                        genres = JSON.parse(show.genres);
-                    }
-                    else {
-                        genres = show.genres.split(',').map((g) => g.trim());
-                    }
-                }
-                catch (e) {
-                    logger.warn({ err: e, showId: show.id }, 'Failed to parse genres for insights');
-                }
-            }
-            for (const g of genres) {
-                genreCounts[g] = (genreCounts[g] || 0) + 1;
-            }
-            if (show.popularityScore) {
-                let score = show.popularityScore;
-                if (score > 10)
-                    score = score / 10;
-                totalPopScore += score;
-                popCount++;
-            }
-        }
-        const topGenre = Object.entries(genreCounts).sort((a, b) => b[1] - a[1])[0]?.[0];
-        const personaMap = {
-            Action: 'Shonen Warrior',
-            Romance: 'Hopeless Romantic',
-            Comedy: 'Chaos Enjoyer',
-            'Slice of Life': 'Vibe Seeker',
-            Horror: 'Fearless Watcher',
-            Fantasy: 'Isekai Traveller',
-            'Sci-Fi': 'Future Scientist',
-            Drama: 'Feels Collector',
-        };
-        const persona = personaMap[topGenre || ''] || 'Anime Enthusiast';
-        const avgCompletionDays = velocities.length > 0
-            ? Math.round(velocities.reduce((a, b) => a + b.daysToFinish, 0) / velocities.length)
-            : 0;
-        res.json({
-            totalHours: Math.round((core?.totalSeconds || 0) / 3600),
-            totalEpisodes: core?.totalEpisodes || 0,
-            totalAnime: core?.totalAnime || 0,
-            completedAnime: core?.completedCount || 0,
-            completionRate: core?.totalWatchlist > 0
-                ? Math.round((core.completedCount / core.totalWatchlist) * 100)
-                : 0,
-            persona,
-            bingeFactor,
-            avgSessionMinutes,
-            avgCompletionDays,
-            popularityScore: popCount > 0 ? Math.round(totalPopScore / popCount) : 0,
-            genreSplit: Object.entries(genreCounts)
-                .map(([name, count]) => ({ name, count }))
-                .sort((a, b) => b.count - a.count)
-                .slice(0, 8) || [],
-            activityGrid: activityGrid || [],
-            hourlyDist: Array.from({ length: 24 }, (_, i) => {
-                const hour = i.toString().padStart(2, '0');
-                return { hour, count: hourlyDist?.find((d) => d.hour === hour)?.count || 0 };
-            }) || [],
-            seasonality: Array.from({ length: 12 }, (_, i) => {
-                const month = (i + 1).toString().padStart(2, '0');
-                return {
-                    month,
-                    seconds: seasonality?.find((s) => s.month === month)?.seconds || 0,
-                };
-            }) || [],
-            droppedShows: (droppedWarning || []).slice(0, 5),
-        });
-    };
-    formatTime(seconds) {
-        const days = Math.floor(seconds / 86400);
-        const hours = Math.floor((seconds % 86400) / 3600);
-        const minutes = Math.floor((seconds % 3600) / 60);
-        if (days > 0) {
-            return `${days} days ${hours > 0 ? `${hours} hours` : ''}`;
-        }
-        if (hours > 0) {
-            return `${hours} hours${minutes > 0 ? ` ${minutes} mins` : ''}`;
-        }
-        return `${minutes} mins`;
-    }
-    getGenreCards = async (req, res) => {
-        const db = req.db;
-        const rows = await InsightsRepository.getWatchedEpisodesWithMeta(db);
-        const genreData = {};
-        for (const row of rows) {
-            let genres = [];
-            if (row.genres) {
-                try {
-                    if (row.genres.startsWith('[')) {
-                        genres = JSON.parse(row.genres);
-                    }
-                    else {
-                        genres = row.genres.split(',').map((g) => g.trim());
-                    }
-                }
-                catch (e) {
-                    logger.warn({ err: e, showId: row.showId }, 'Failed to parse genres for genre cards');
-                }
-            }
-            const timeWatched = (row.effectiveSeconds ?? row.currentTime) || 0;
-            let score = row.popularityScore || 0;
-            if (score > 10)
-                score = score / 10;
-            for (const genre of genres) {
-                if (!genreData[genre]) {
-                    genreData[genre] = { count: 0, totalTime: 0, scores: [], showWatches: {}, showMeta: {} };
-                }
-                genreData[genre].count++;
-                genreData[genre].totalTime += timeWatched;
-                if (score > 0)
-                    genreData[genre].scores.push(score);
-                genreData[genre].showWatches[row.showId] =
-                    (genreData[genre].showWatches[row.showId] || 0) + 1;
-                if (row.name || row.thumbnail) {
-                    genreData[genre].showMeta[row.showId] = {
-                        name: row.name,
-                        nativeName: row.nativeName,
-                        englishName: row.englishName,
-                        thumbnail: row.thumbnail,
-                    };
-                }
-            }
-        }
-        const genreCards = Object.entries(genreData).map(([name, data]) => {
-            const topShows = Object.entries(data.showWatches)
-                .sort((a, b) => b[1] - a[1])
-                .slice(0, 4)
-                .map(([showId]) => ({
-                id: showId,
-                name: data.showMeta[showId]?.name || '',
-                nativeName: data.showMeta[showId]?.nativeName,
-                englishName: data.showMeta[showId]?.englishName,
-                thumbnail: data.showMeta[showId]?.thumbnail || '',
-            }));
-            return {
-                rank: 0,
-                name,
-                count: data.count,
-                meanScore: data.scores.length > 0 ? data.scores.reduce((a, b) => a + b, 0) / data.scores.length : 0,
-                timeWatched: this.formatTime(data.totalTime),
-                topShows,
-            };
-        });
-        genreCards.sort((a, b) => b.count - a.count);
-        genreCards.forEach((card, i) => {
-            card.rank = i + 1;
-        });
-        res.json(genreCards);
-    };
-    getDiscordSyncStats = async (req, res) => {
-        const db = req.db;
-        res.json(await computeDiscordSyncStats(db));
-    };
-    getRecommendations = async (req, res) => {
-        const db = req.db;
-        res.json({ candidates: await getCachedRecommendations(db) });
-    };
-}

package/server/dist/controllers/manga-library.controller.js

@@ -1,350 +0,0 @@
-import logger from '../logger.js';
-import { performMangaWriteTransaction } from '../sync.js';
-import { dbAll } from '../utils/db-utils.js';
-import { SettingsRepository } from '../repositories/settings.repository.js';
-import { buildMangaId, MANGA_STATUSES, MangaLibraryRepository, MangaProgressRepository, } from '../repositories/manga.repository.js';
-const MANGA_ADULT_RATINGS = ['erotica', 'pornographic'];
-const isMangaContinueAdult = (row) => !!row.contentRating && MANGA_ADULT_RATINGS.includes(row.contentRating);
-function mangaDb(req) {
-    const db = req.mangaDb;
-    if (!db || db.isClosedCheck())
-        throw new Error('Manga database is not ready');
-    return db;
-}
-function normalizeId(provider, mangaId, idRaw) {
-    if (idRaw && idRaw.includes(':'))
-        return idRaw;
-    return buildMangaId(provider, mangaId || idRaw || '');
-}
-export class MangaLibraryController {
-    getLibrary = async (req, res) => {
-        try {
-            const { status, page: pageStr, limit: limitStr } = req.query;
-            const page = Math.max(parseInt(pageStr) || 1, 1);
-            const limit = Math.min(Math.max(parseInt(limitStr) || 24, 1), 100);
-            const offset = (page - 1) * limit;
-            const db = mangaDb(req);
-            const rows = MangaLibraryRepository.getAll(db, status, limit, offset);
-            const total = MangaLibraryRepository.getCount(db, status);
-            res.json({ data: rows, total, page, limit });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to get manga library');
-            res.status(500).json({ error: 'Failed to load manga library' });
-        }
-    };
-    checkLibrary = async (req, res) => {
-        try {
-            const item = MangaLibraryRepository.getById(mangaDb(req), req.params.id);
-            res.json({ inLibrary: !!item, status: item?.status ?? null });
-        }
-        catch {
-            res.json({ inLibrary: false, status: null });
-        }
-    };
-    getEntry = async (req, res) => {
-        try {
-            const item = MangaLibraryRepository.getById(mangaDb(req), req.params.id);
-            if (!item)
-                return res.status(404).json({ error: 'Not in library' });
-            res.json({ item });
-        }
-        catch {
-            res.status(500).json({ error: 'Failed to load entry' });
-        }
-    };
-    linkAnilist = async (req, res) => {
-        const { id, anilistId } = req.body ?? {};
-        const targetId = typeof id === 'string' ? id : '';
-        const mediaId = Number(anilistId);
-        if (!targetId || !Number.isInteger(mediaId) || mediaId <= 0) {
-            return res.status(400).json({ error: 'id and a numeric anilistId are required' });
-        }
-        try {
-            const db = mangaDb(req);
-            const row = MangaLibraryRepository.getById(db, targetId);
-            if (!row)
-                return res.status(404).json({ error: 'Library entry not found' });
-            if (String(row.provider).toLowerCase() === 'anilist') {
-                return res
-                    .status(400)
-                    .json({ error: 'Link a provider bookmark to the AniList entry, not the reverse' });
-            }
-            let progressMigrated = false;
-            await performMangaWriteTransaction(db, (tx) => {
-                MangaLibraryRepository.setAnilistId(tx, targetId, mediaId, 'manual');
-                const orphanId = `anilist:${mediaId}`;
-                if (orphanId !== targetId) {
-                    const orphan = MangaLibraryRepository.getById(tx, orphanId);
-                    const target = MangaLibraryRepository.getById(tx, targetId);
-                    const targetProgress = MangaProgressRepository.getByManga(tx, targetId);
-                    if (orphan?.lastChapterNumber &&
-                        !target?.lastChapterNumber &&
-                        targetProgress.length === 0) {
-                        MangaLibraryRepository.setProgressPointer(tx, targetId, orphan.lastChapterNumber);
-                        MangaProgressRepository.moveSyntheticChapters(tx, orphanId, targetId);
-                        progressMigrated = true;
-                    }
-                    MangaLibraryRepository.delete(tx, orphanId);
-                    MangaProgressRepository.deleteByManga(tx, orphanId);
-                }
-            });
-            res.json({ success: true, id: targetId, progressMigrated });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to link manga to AniList');
-            res.status(500).json({ error: 'Failed to link entry' });
-        }
-    };
-    getLibraryIds = async (req, res) => {
-        try {
-            res.json({ ids: MangaLibraryRepository.getIds(mangaDb(req)) });
-        }
-        catch {
-            res.json({ ids: [] });
-        }
-    };
-    addToLibrary = async (req, res) => {
-        const { provider, mangaId, id: idRaw, title, cover, status, author, altTitle, contentRating, } = req.body ?? {};
-        if (!provider || (!mangaId && !idRaw)) {
-            return res.status(400).json({ error: 'provider and mangaId are required' });
-        }
-        const id = normalizeId(String(provider), String(mangaId || ''), idRaw ? String(idRaw) : undefined);
-        const cleanStatus = typeof status === 'string' && MANGA_STATUSES.includes(status)
-            ? status
-            : 'Reading';
-        try {
-            await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                MangaLibraryRepository.upsert(tx, {
-                    id,
-                    provider: String(provider).toLowerCase(),
-                    mangaId: String(mangaId || idRaw || ''),
-                    title: String(title || ''),
-                    cover: String(cover || ''),
-                    status: cleanStatus,
-                    author: author ? String(author) : undefined,
-                    altTitle: altTitle ? String(altTitle) : undefined,
-                    contentRating: contentRating ? String(contentRating) : undefined,
-                });
-            });
-            res.json({ success: true, id });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to add manga to library');
-            res.status(500).json({ error: 'Failed to bookmark manga' });
-        }
-    };
-    removeFromLibrary = async (req, res) => {
-        const { id } = req.body ?? {};
-        if (!id)
-            return res.status(400).json({ error: 'id is required' });
-        try {
-            await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                MangaLibraryRepository.delete(tx, String(id));
-                MangaProgressRepository.deleteByManga(tx, String(id));
-            });
-            res.json({ success: true });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to remove manga from library');
-            res.status(500).json({ error: 'Failed to remove bookmark' });
-        }
-    };
-    updateStatus = async (req, res) => {
-        const { id, status } = req.body ?? {};
-        if (!id || !MANGA_STATUSES.includes(status)) {
-            return res.status(400).json({ error: 'id and a valid status are required' });
-        }
-        try {
-            await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                MangaLibraryRepository.updateStatus(tx, String(id), String(status));
-            });
-            res.json({ success: true });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to update manga status');
-            res.status(500).json({ error: 'Failed to update status' });
-        }
-    };
-    getProgress = async (req, res) => {
-        try {
-            const rows = MangaProgressRepository.getByManga(mangaDb(req), req.params.mangaId);
-            res.json({ progress: rows });
-        }
-        catch {
-            res.json({ progress: [] });
-        }
-    };
-    getLatestProgress = async (req, res) => {
-        try {
-            const row = MangaProgressRepository.getLatest(mangaDb(req), req.params.mangaId);
-            res.json(row || { page: 0, pageCount: 0 });
-        }
-        catch {
-            res.json({ page: 0, pageCount: 0 });
-        }
-    };
-    saveProgress = async (req, res) => {
-        const { mangaId, chapterId, chapterNumber, page, pageCount, title, cover, provider, altTitle, contentRating, } = req.body ?? {};
-        if (!mangaId || !chapterId) {
-            return res.status(400).json({ error: 'mangaId and chapterId are required' });
-        }
-        const pageNum = Math.max(Number(page) || 0, 0);
-        const pageCountNum = Math.max(Number(pageCount) || 0, 0);
-        try {
-            await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                MangaProgressRepository.upsert(tx, {
-                    mangaId: String(mangaId),
-                    chapterId: String(chapterId),
-                    chapterNumber: String(chapterNumber || ''),
-                    page: pageNum,
-                    pageCount: pageCountNum,
-                    title: title ?? null,
-                    cover: cover ?? null,
-                    provider: provider ?? null,
-                    altTitle: altTitle ?? null,
-                    contentRating: contentRating ?? null,
-                });
-                MangaLibraryRepository.touchProgress(tx, String(mangaId), {
-                    chapterId: String(chapterId),
-                    chapterNumber: String(chapterNumber || ''),
-                    page: pageNum,
-                });
-            });
-            res.json({ success: true });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to save manga progress');
-            res.status(500).json({ error: 'Failed to save progress' });
-        }
-    };
-    getContinueReading = async (req, res) => {
-        try {
-            const limit = Math.min(Math.max(parseInt(req.query.limit) || 24, 1), 100);
-            const ignoreAdultRow = await SettingsRepository.getByKey(req.db, 'mangaIgnoreAdultContent');
-            const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
-            const listOnlyRow = await SettingsRepository.getByKey(req.db, 'mangaCwWatchlistOnly');
-            const listOnly = listOnlyRow
-                ? listOnlyRow.value === 'true' || listOnlyRow.value === '1'
-                : false;
-            const rows = MangaProgressRepository.getContinueReading(mangaDb(req), limit).filter((row) => {
-                if (ignoreAdult && isMangaContinueAdult(row))
-                    return false;
-                if (listOnly && row.watchlistStatus !== 'Reading')
-                    return false;
-                return true;
-            });
-            res.json({ data: rows, total: rows.length });
-        }
-        catch {
-            res.json({ data: [], total: 0 });
-        }
-    };
-    async getAdultNonListMangaIds(db) {
-        const rows = await dbAll(db, `SELECT DISTINCT p.mangaId as mangaId
-       FROM manga_progress p
-       LEFT JOIN manga_library l ON l.id = p.mangaId
-       WHERE COALESCE(l.contentRating, p.contentRating) IN ('erotica', 'pornographic')
-         AND l.id IS NULL`);
-        return rows.map((r) => r.mangaId);
-    }
-    getAdultContinueReadingCount = async (req, res) => {
-        try {
-            const ids = await this.getAdultNonListMangaIds(mangaDb(req));
-            res.json({ count: ids.length });
-        }
-        catch {
-            res.json({ count: 0 });
-        }
-    };
-    purgeAdultContinueReading = async (req, res) => {
-        try {
-            const ids = await this.getAdultNonListMangaIds(mangaDb(req));
-            if (ids.length > 0) {
-                await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                    MangaProgressRepository.deleteMany(tx, ids);
-                });
-            }
-            res.json({ success: true, removed: ids.length });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to purge adult manga progress');
-            res.status(500).json({ error: 'Failed to purge adult entries' });
-        }
-    };
-    removeProgress = async (req, res) => {
-        const { mangaId, chapterId } = req.body ?? {};
-        if (!mangaId)
-            return res.status(400).json({ error: 'mangaId is required' });
-        try {
-            await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                if (chapterId) {
-                    MangaProgressRepository.deleteChapter(tx, String(mangaId), String(chapterId));
-                }
-                else {
-                    MangaProgressRepository.deleteByManga(tx, String(mangaId));
-                }
-            });
-            res.json({ success: true });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to remove manga progress');
-            res.status(500).json({ error: 'Failed to reset progress' });
-        }
-    };
-    batchUpdateStatus = 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 || !MANGA_STATUSES.includes(status)) {
-            return res.status(400).json({ error: 'a valid status is required' });
-        }
-        const ids = idsRaw.map((id) => String(id));
-        try {
-            await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                MangaLibraryRepository.updateStatusMany(tx, ids, String(status));
-            });
-            res.json({ success: true, updated: ids.length });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to batch update manga status');
-            res.status(500).json({ error: 'Failed to update statuses' });
-        }
-    };
-    batchRemove = 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 = idsRaw.map((id) => String(id));
-        try {
-            await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                MangaLibraryRepository.deleteMany(tx, ids);
-                MangaProgressRepository.deleteMany(tx, ids);
-            });
-            res.json({ success: true, removed: ids.length });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to batch remove manga');
-            res.status(500).json({ error: 'Failed to remove bookmarks' });
-        }
-    };
-    batchRemoveProgress = 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 = idsRaw.map((id) => String(id));
-        try {
-            await performMangaWriteTransaction(mangaDb(req), (tx) => {
-                MangaProgressRepository.deleteMany(tx, ids);
-            });
-            res.json({ success: true, removed: ids.length });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to batch remove manga progress');
-            res.status(500).json({ error: 'Failed to reset progress' });
-        }
-    };
-}