@serifpersia/dango 3.3.9 → 3.4.0

package/server/dist/trpc/routers/manga-progress.js

@@ -0,0 +1,181 @@
+import { protectedProcedure, router } from '../index.js';
+import { defineSchema, optStr, reqObj, reqStr, reqStrArray } from '../validation.js';
+import { performMangaWriteTransactionAsync } from '../../sync.js';
+import { dbAll } from '../../utils/db-utils.js';
+import { SettingsRepository } from '../../repositories/settings.repository.js';
+import { MangaLibraryRepository, MangaProgressRepository, } from '../../repositories/manga.repository.js';
+const MANGA_ADULT_RATINGS = ['erotica', 'pornographic'];
+const isMangaContinueAdult = (row) => !!row.contentRating && MANGA_ADULT_RATINGS.includes(row.contentRating);
+async function 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);
+}
+const mangaIdInput = () => defineSchema((value) => ({
+    mangaId: reqStr(reqObj(value), 'mangaId'),
+}));
+const mangaProgressSaveInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {
+        mangaId: reqStr(obj, 'mangaId'),
+        chapterId: reqStr(obj, 'chapterId'),
+    };
+    if (obj.chapterNumber !== undefined && obj.chapterNumber !== null)
+        out.chapterNumber = String(obj.chapterNumber);
+    if (obj.page !== undefined && obj.page !== null) {
+        const page = Number(obj.page);
+        if (!Number.isNaN(page))
+            out.page = page;
+    }
+    if (obj.pageCount !== undefined && obj.pageCount !== null) {
+        const pageCount = Number(obj.pageCount);
+        if (!Number.isNaN(pageCount))
+            out.pageCount = pageCount;
+    }
+    const title = optStr(obj, 'title');
+    if (title !== undefined)
+        out.title = title;
+    const cover = optStr(obj, 'cover');
+    if (cover !== undefined)
+        out.cover = cover;
+    const provider = optStr(obj, 'provider');
+    if (provider !== undefined)
+        out.provider = provider;
+    const altTitle = optStr(obj, 'altTitle');
+    if (altTitle !== undefined)
+        out.altTitle = altTitle;
+    const contentRating = optStr(obj, 'contentRating');
+    if (contentRating !== undefined)
+        out.contentRating = contentRating;
+    return out;
+});
+const mangaProgressRemoveInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = { mangaId: reqStr(obj, 'mangaId') };
+    const chapterId = optStr(obj, 'chapterId');
+    if (chapterId !== undefined)
+        out.chapterId = chapterId;
+    return out;
+});
+const mangaProgressRemoveManyInput = () => defineSchema((value) => ({
+    ids: reqStrArray(reqObj(value), 'ids', true),
+}));
+const mangaContinueReadingInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    if (obj.limit !== undefined && obj.limit !== null) {
+        const limit = Number(obj.limit);
+        if (!Number.isNaN(limit))
+            out.limit = limit;
+    }
+    return out;
+});
+export const mangaProgressRouter = router({
+    byManga: protectedProcedure.input(mangaIdInput()).query(async ({ ctx, input }) => {
+        try {
+            const rows = await MangaProgressRepository.getByManga(ctx.mangaDb, input.mangaId);
+            return { progress: rows };
+        }
+        catch {
+            return { progress: [] };
+        }
+    }),
+    latest: protectedProcedure.input(mangaIdInput()).query(async ({ ctx, input }) => {
+        try {
+            const row = await MangaProgressRepository.getLatest(ctx.mangaDb, input.mangaId);
+            return row || { page: 0, pageCount: 0 };
+        }
+        catch {
+            return { page: 0, pageCount: 0 };
+        }
+    }),
+    save: protectedProcedure.input(mangaProgressSaveInput()).mutation(async ({ ctx, input }) => {
+        const pageNum = Math.max(Number(input.page) || 0, 0);
+        const pageCountNum = Math.max(Number(input.pageCount) || 0, 0);
+        await performMangaWriteTransactionAsync(ctx.mangaDb, async (tx) => {
+            await MangaProgressRepository.upsert(tx, {
+                mangaId: String(input.mangaId),
+                chapterId: String(input.chapterId),
+                chapterNumber: String(input.chapterNumber || ''),
+                page: pageNum,
+                pageCount: pageCountNum,
+                title: (input.title ?? null),
+                cover: (input.cover ?? null),
+                provider: (input.provider ?? null),
+                altTitle: (input.altTitle ?? null),
+                contentRating: (input.contentRating ?? null),
+            });
+            await MangaLibraryRepository.touchProgress(tx, String(input.mangaId), {
+                chapterId: String(input.chapterId),
+                chapterNumber: String(input.chapterNumber || ''),
+                page: pageNum,
+            });
+        });
+        return { success: true };
+    }),
+    remove: protectedProcedure.input(mangaProgressRemoveInput()).mutation(async ({ ctx, input }) => {
+        await performMangaWriteTransactionAsync(ctx.mangaDb, async (tx) => {
+            if (input.chapterId) {
+                await MangaProgressRepository.deleteChapter(tx, String(input.mangaId), String(input.chapterId));
+            }
+            else {
+                await MangaProgressRepository.deleteByManga(tx, String(input.mangaId));
+            }
+        });
+        return { success: true };
+    }),
+    removeMany: protectedProcedure
+        .input(mangaProgressRemoveManyInput())
+        .mutation(async ({ ctx, input }) => {
+        const ids = input.ids.map((id) => String(id));
+        await performMangaWriteTransactionAsync(ctx.mangaDb, async (tx) => {
+            await MangaProgressRepository.deleteMany(tx, ids);
+        });
+        return { success: true, removed: ids.length };
+    }),
+    continueReading: protectedProcedure
+        .input(mangaContinueReadingInput())
+        .query(async ({ ctx, input }) => {
+        try {
+            const limit = Math.min(Math.max(parseInt(String(input.limit)) || 24, 1), 100);
+            const ignoreAdultRow = await SettingsRepository.getByKey(ctx.db, 'mangaIgnoreAdultContent');
+            const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
+            const listOnlyRow = await SettingsRepository.getByKey(ctx.db, 'mangaCwWatchlistOnly');
+            const listOnly = listOnlyRow
+                ? listOnlyRow.value === 'true' || listOnlyRow.value === '1'
+                : false;
+            const rows = (await MangaProgressRepository.getContinueReading(ctx.mangaDb, limit)).filter((row) => {
+                if (ignoreAdult && isMangaContinueAdult(row))
+                    return false;
+                if (listOnly && row.watchlistStatus !== 'Reading')
+                    return false;
+                return true;
+            });
+            return { data: rows, total: rows.length };
+        }
+        catch {
+            return { data: [], total: 0 };
+        }
+    }),
+    adultCount: protectedProcedure.query(async ({ ctx }) => {
+        try {
+            const ids = await getAdultNonListMangaIds(ctx.mangaDb);
+            return { count: ids.length };
+        }
+        catch {
+            return { count: 0 };
+        }
+    }),
+    purgeAdult: protectedProcedure.mutation(async ({ ctx }) => {
+        const ids = await getAdultNonListMangaIds(ctx.mangaDb);
+        if (ids.length > 0) {
+            await performMangaWriteTransactionAsync(ctx.mangaDb, async (tx) => {
+                await MangaProgressRepository.deleteMany(tx, ids);
+            });
+        }
+        return { success: true, removed: ids.length };
+    }),
+});

package/server/dist/trpc/routers/manga.js

@@ -0,0 +1,201 @@
+import { TRPCError } from '@trpc/server';
+import { protectedProcedure, router } from '../index.js';
+import { parseJsonBody } from '../../utils/http.utils.js';
+import { defineSchema, optStr, reqObj } from '../validation.js';
+import logger from '../../logger.js';
+const SAFE = ['safe'];
+function parseRatings(query) {
+    const mature = query['mature'] === '1';
+    const raw = String(query['rating'] || 'safe')
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter((s) => ['safe', 'suggestive', 'erotica', 'pornographic'].includes(s));
+    if (!mature)
+        return SAFE;
+    const exact = [...new Set(raw)];
+    return exact.length > 0 ? exact : SAFE;
+}
+function pick(ctx, name) {
+    return ctx.getMangaProvider(name.toLowerCase());
+}
+async function cached(ctx, key, ttl, produce) {
+    const hit = ctx.apiCache.get(key);
+    if (hit)
+        return hit;
+    const result = await produce();
+    if ((result.status ?? 200) >= 200 && (result.status ?? 200) < 400) {
+        if (ttl !== undefined)
+            ctx.apiCache.set(key, result.body, ttl);
+        else
+            ctx.apiCache.set(key, result.body);
+    }
+    if (result.status !== undefined && result.status !== 200) {
+        throw new TRPCError({
+            code: result.status === 400
+                ? 'BAD_REQUEST'
+                : result.status === 404
+                    ? 'NOT_FOUND'
+                    : 'INTERNAL_SERVER_ERROR',
+            message: result.body?.error || 'Request failed',
+        });
+    }
+    return result.body;
+}
+const mangaSearchInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    for (const k of ['provider', 'q', 'sort', 'status', 'type', 'rating', 'mature']) {
+        const v = optStr(obj, k);
+        if (v !== undefined)
+            out[k] = v;
+    }
+    if (obj.page !== undefined)
+        out.page = parseInt(String(obj.page), 10) || 1;
+    if (obj.limit !== undefined)
+        out.limit = Math.min(parseInt(String(obj.limit), 10) || 24, 50);
+    return out;
+});
+const mangaInfoInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    for (const k of ['provider', 'id', 'rating', 'mature']) {
+        const v = optStr(obj, k);
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+});
+const mangaPagesInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    const provider = optStr(obj, 'provider');
+    if (provider !== undefined)
+        out.provider = provider;
+    const id = optStr(obj, 'id');
+    if (id !== undefined)
+        out.id = id;
+    return out;
+});
+export const mangaRouter = router({
+    trending: protectedProcedure.query(async ({ ctx }) => {
+        const cacheKey = 'route-manga-trending';
+        const cached = ctx.apiCache.get(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const url = 'https://api.mangadex.org/manga?limit=6&order%5BfollowedCount%5D=desc&includes%5B%5D=cover_art&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive';
+            const upstream = await fetch(url, {
+                headers: { 'User-Agent': 'dango/3.1.9' },
+            });
+            if (!upstream.ok)
+                return [];
+            const data = await parseJsonBody(upstream);
+            const results = (data.data || []).map((m) => {
+                const title = m.attributes?.title?.en || Object.values(m.attributes?.title || {})[0] || '';
+                const desc = m.attributes?.description?.en || '';
+                const tags = (m.attributes?.tags || [])
+                    .map((t) => t.attributes?.name?.en)
+                    .filter(Boolean);
+                const coverArt = m.relationships?.find((r) => r.type === 'cover_art');
+                const fileName = coverArt?.attributes?.fileName;
+                const cover = fileName
+                    ? `https://uploads.mangadex.org/covers/${m.id}/${fileName}.512.jpg`
+                    : '';
+                return {
+                    id: m.id,
+                    title,
+                    description: desc,
+                    tags,
+                    year: m.attributes?.year || null,
+                    status: m.attributes?.status || null,
+                    cover,
+                };
+            });
+            ctx.apiCache.set(cacheKey, results, 600);
+            return results;
+        }
+        catch {
+            return [];
+        }
+    }),
+    search: protectedProcedure.input(mangaSearchInput()).query(async ({ ctx, input }) => {
+        const provider = input.provider || '';
+        const q = input.q || '';
+        const page = input.page || 1;
+        return cached(ctx, `route-manga-search-${provider}-${q}-${page}-${input.sort || ''}-${input.status || ''}-${input.type || ''}-${input.rating || ''}-${input.mature || ''}`, 300, async () => {
+            try {
+                const ratings = parseRatings({ rating: input.rating, mature: input.mature });
+                const rawType = input.type || '';
+                const type = rawType === 'doujinshi' && input.mature !== '1' ? '' : rawType;
+                const result = await pick(ctx, provider)?.search({
+                    query: q,
+                    page,
+                    limit: input.limit || 24,
+                    sort: input.sort || 'popular',
+                    status: input.status || '',
+                    type,
+                    ratings,
+                });
+                return { body: result ?? { items: [], hasNext: false } };
+            }
+            catch (err) {
+                logger.error({ err }, '[Manga] search failed');
+                return { body: { items: [], hasNext: false } };
+            }
+        });
+    }),
+    info: protectedProcedure.input(mangaInfoInput()).query(async ({ ctx, input }) => {
+        const provider = String(input.provider || '');
+        const id = String(input.id || '');
+        const rating = String(input.rating || '');
+        const mature = String(input.mature || '');
+        return cached(ctx, `route-manga-info-${provider}-${id}-${rating}-${mature}`, 600, async () => {
+            try {
+                if (!id)
+                    return { status: 400, body: { error: 'Missing id' } };
+                const detail = await pick(ctx, provider)?.getDetail(id, parseRatings({ rating, mature }));
+                if (!detail)
+                    return { status: 404, body: { error: 'Not found' } };
+                return { body: detail };
+            }
+            catch (err) {
+                logger.error({ err }, '[Manga] info failed');
+                return { status: 500, body: { error: 'Failed to load manga' } };
+            }
+        });
+    }),
+    chapters: protectedProcedure.input(mangaInfoInput()).query(async ({ ctx, input }) => {
+        const provider = String(input.provider || '');
+        const id = String(input.id || '');
+        const rating = String(input.rating || '');
+        const mature = String(input.mature || '');
+        return cached(ctx, `route-manga-chapters-${provider}-${id}-${rating}-${mature}`, 600, async () => {
+            try {
+                if (!id)
+                    return { status: 400, body: { error: 'Missing id' } };
+                const chapters = (await pick(ctx, provider)?.getChapters(id, parseRatings({ rating, mature }))) ?? [];
+                return { body: { chapters } };
+            }
+            catch (err) {
+                logger.error({ err }, '[Manga] chapters failed');
+                return { body: { chapters: [] } };
+            }
+        });
+    }),
+    pages: protectedProcedure.input(mangaPagesInput()).query(async ({ ctx, input }) => {
+        const provider = String(input.provider || '');
+        const id = String(input.id || '');
+        return cached(ctx, `route-manga-pages-${provider}-${id}`, 300, async () => {
+            try {
+                if (!id)
+                    return { status: 400, body: { error: 'Missing id' } };
+                const pages = (await pick(ctx, provider)?.getPages(id)) ?? [];
+                return { body: { pages } };
+            }
+            catch (err) {
+                logger.error({ err }, '[Manga] pages failed');
+                return { body: { pages: [] } };
+            }
+        });
+    }),
+});