@serifpersia/dango 3.6.7 → 3.6.9

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

@@ -1,169 +0,0 @@
-import { protectedProcedure, router } from '../index.js';
-import { defineSchema, optStr, reqObj, reqStr, reqStrArray } from '../validation.js';
-import { performMangaWriteTransactionAsync } from '../../sync.js';
-import { adultNonListIds } 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);
-const getAdultNonListMangaIds = (db) => adultNonListIds(db, 'manga_progress', 'manga_library', 'mangaId', "COALESCE(l.contentRating, p.contentRating) IN ('erotica', 'pornographic')");
-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 { ignoreAdult, listOnly } = await SettingsRepository.readContinueFlags(ctx.db, 'mangaIgnoreAdultContent', 'mangaCwWatchlistOnly');
-            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

@@ -1,201 +0,0 @@
-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: [] } };
-            }
-        });
-    }),
-});