@serifpersia/dango 3.6.7 → 3.6.9

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

@@ -1,213 +0,0 @@
-import { TRPCError } from '@trpc/server';
-import { protectedProcedure, router } from '../index.js';
-import { SettingsRepository } from '../../repositories/settings.repository.js';
-import { performWriteTransactionAsync } from '../../sync.js';
-import { AniListTracker } from '../../lib/tracker/anilist-tracker.js';
-import { syncAniList, importFromMalUsername, importFromUsername, } from '../../lib/tracker/sync.service.js';
-import { syncAniListManga, importFromUsernameManga, importMangaFromMalUsername, } from '../../lib/tracker/manga-sync.service.js';
-import { badRequest, defineSchema, failed, reqObj } from '../validation.js';
-const TRACKER_TOKEN_KEY = 'tracker_anilist_token';
-const TRACKER_USER_KEY = 'tracker_anilist_user';
-function unavailable(message) {
-    return new TRPCError({ code: 'SERVICE_UNAVAILABLE', message });
-}
-function optBody(value) {
-    if (value === undefined || value === null)
-        return {};
-    return reqObj(value);
-}
-const trackerTokenInput = () => defineSchema((value) => {
-    const obj = optBody(value);
-    return { token: obj.token, code: obj.code, redirectUri: obj.redirectUri };
-});
-const trackerSyncInput = () => defineSchema((value) => ({
-    provider: optBody(value).provider,
-}));
-const trackerUsernameInput = () => defineSchema((value) => {
-    const obj = optBody(value);
-    return { username: obj.username, erase: obj.erase };
-});
-const trackerMalInput = () => defineSchema((value) => {
-    const obj = optBody(value);
-    return {
-        username: obj.username,
-        erase: obj.erase,
-        useOfflineDb: obj.useOfflineDb,
-        skipFallback: obj.skipFallback,
-    };
-});
-const trackerMangaSyncInput = () => defineSchema((value) => ({
-    direction: optBody(value).direction,
-}));
-function mapImportError(message) {
-    if (message.includes('private') || message.includes('not found')) {
-        return new TRPCError({ code: 'NOT_FOUND', message });
-    }
-    if (message.includes('blocked') || message.includes('HTTP 429')) {
-        return new TRPCError({ code: 'TOO_MANY_REQUESTS', message });
-    }
-    return failed(message);
-}
-export const trackerRouter = router({
-    status: protectedProcedure.query(async ({ ctx }) => {
-        try {
-            const tokenRow = await SettingsRepository.getByKey(ctx.db, TRACKER_TOKEN_KEY);
-            const userRow = await SettingsRepository.getByKey(ctx.db, TRACKER_USER_KEY);
-            let user = null;
-            if (userRow?.value) {
-                try {
-                    user = JSON.parse(userRow.value);
-                }
-                catch {
-                    user = null;
-                }
-            }
-            return { anilist: { connected: !!tokenRow?.value, user } };
-        }
-        catch {
-            throw failed('Failed to read tracker status');
-        }
-    }),
-    anilistAuth: protectedProcedure.input(trackerTokenInput()).mutation(async ({ ctx, input }) => {
-        const accessToken = typeof input.token === 'string' ? input.token.trim() : '';
-        if (!accessToken) {
-            throw badRequest('Access token is required');
-        }
-        try {
-            const tracker = new AniListTracker(accessToken);
-            const viewer = await tracker.getViewer();
-            await performWriteTransactionAsync(ctx.db, async (tx) => {
-                await SettingsRepository.upsert(tx, TRACKER_TOKEN_KEY, accessToken);
-                await SettingsRepository.upsert(tx, TRACKER_USER_KEY, JSON.stringify(viewer));
-            });
-            return { success: true, user: viewer };
-        }
-        catch (err) {
-            throw new TRPCError({
-                code: 'UNAUTHORIZED',
-                message: err instanceof Error ? err.message : 'Authentication failed',
-            });
-        }
-    }),
-    anilistDisconnect: protectedProcedure.mutation(async ({ ctx }) => {
-        try {
-            await performWriteTransactionAsync(ctx.db, async (tx) => {
-                await SettingsRepository.upsert(tx, TRACKER_TOKEN_KEY, '');
-                await SettingsRepository.upsert(tx, TRACKER_USER_KEY, '');
-            });
-            return { success: true };
-        }
-        catch {
-            throw failed('Failed to disconnect');
-        }
-    }),
-    sync: protectedProcedure.input(trackerSyncInput()).mutation(async ({ ctx, input }) => {
-        const { provider = 'anilist' } = input;
-        if (provider !== 'anilist') {
-            throw badRequest(`Provider "${provider}" is not supported yet`);
-        }
-        try {
-            const summary = await syncAniList(ctx.db);
-            return { success: true, summary };
-        }
-        catch (err) {
-            throw failed(err instanceof Error ? err.message : 'Sync failed');
-        }
-    }),
-    anilistImport: protectedProcedure
-        .input(trackerUsernameInput())
-        .mutation(async ({ ctx, input }) => {
-        const { username, erase } = input;
-        if (!username || typeof username !== 'string') {
-            throw badRequest('Username is required');
-        }
-        try {
-            const count = await importFromUsername(ctx.db, username.trim(), erase === true);
-            return { success: true, count };
-        }
-        catch (err) {
-            throw failed(err instanceof Error ? err.message : 'Import failed');
-        }
-    }),
-    malImport: protectedProcedure.input(trackerMalInput()).mutation(async ({ ctx, input }) => {
-        const { username, erase, useOfflineDb, skipFallback } = input;
-        if (!username || typeof username !== 'string') {
-            throw badRequest('MAL username is required');
-        }
-        try {
-            const count = await importFromMalUsername(ctx.db, username.trim(), {
-                erase: erase === true,
-                useOfflineDb: useOfflineDb !== false,
-                skipFallback: skipFallback === true,
-            });
-            return { success: true, count };
-        }
-        catch (err) {
-            throw mapImportError(err instanceof Error ? err.message : 'Import failed');
-        }
-    }),
-    mangaSync: protectedProcedure.input(trackerMangaSyncInput()).mutation(async ({ ctx, input }) => {
-        const { direction } = input;
-        try {
-            const mangaDb = ctx.mangaDb;
-            if (!mangaDb || mangaDb.isClosedCheck()) {
-                throw unavailable('Manga database is not ready');
-            }
-            const syncDirection = direction === 'pull-only' ? 'pull-only' : 'two-way';
-            const result = await syncAniListManga(ctx.db, mangaDb, {
-                direction: syncDirection,
-            });
-            return {
-                success: true,
-                summary: result.summary,
-                details: result.details,
-                direction: syncDirection,
-            };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed(err instanceof Error ? err.message : 'Manga sync failed');
-        }
-    }),
-    mangaImport: protectedProcedure.input(trackerUsernameInput()).mutation(async ({ ctx, input }) => {
-        const { username, erase } = input;
-        if (!username || typeof username !== 'string') {
-            throw badRequest('Username is required');
-        }
-        try {
-            const mangaDb = ctx.mangaDb;
-            if (!mangaDb || mangaDb.isClosedCheck()) {
-                throw unavailable('Manga database is not ready');
-            }
-            const count = await importFromUsernameManga(ctx.db, mangaDb, username.trim(), erase === true);
-            return { success: true, count };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed(err instanceof Error ? err.message : 'Import failed');
-        }
-    }),
-    mangaMalImport: protectedProcedure
-        .input(trackerUsernameInput())
-        .mutation(async ({ ctx, input }) => {
-        const { username, erase } = input;
-        if (!username || typeof username !== 'string') {
-            throw badRequest('Username is required');
-        }
-        try {
-            const mangaDb = ctx.mangaDb;
-            if (!mangaDb || mangaDb.isClosedCheck()) {
-                throw unavailable('Manga database is not ready');
-            }
-            const result = await importMangaFromMalUsername(ctx.db, mangaDb, username.trim(), erase === true);
-            return { success: true, ...result };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw mapImportError(err instanceof Error ? err.message : 'Import failed');
-        }
-    }),
-});

package/server/dist/trpc/routers/tv-library.js

@@ -1,135 +0,0 @@
-import { TRPCError } from '@trpc/server';
-import { protectedProcedure, router } from '../index.js';
-import { performTvWriteTransactionAsync } from '../../sync.js';
-import { buildTvId, TV_STATUSES, TvLibraryRepository, TvProgressRepository, } from '../../repositories/tv.repository.js';
-import { defineSchema, reqObj, reqStr, optStr, reqStrArray, readPageLimit } from '../validation.js';
-function normalizeMediaType(raw) {
-    return String(raw).toLowerCase() === 'movie' ? 'movie' : 'tv';
-}
-const tvLibraryListInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    const out = { ...readPageLimit(obj) };
-    const status = optStr(obj, 'status');
-    if (status !== undefined)
-        out.status = status;
-    return out;
-});
-const tvLibraryIdInput = () => defineSchema((value) => ({
-    id: reqStr(reqObj(value), 'id'),
-}));
-const tvLibraryAddInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return {
-        tmdbId: obj.tmdbId,
-        mediaType: obj.mediaType,
-        id: obj.id,
-        title: obj.title,
-        poster: obj.poster,
-        backdrop: obj.backdrop,
-        year: obj.year,
-        overview: obj.overview,
-        status: obj.status,
-        adult: obj.adult,
-    };
-});
-const tvLibraryRemoveInput = () => defineSchema((value) => {
-    if (typeof value !== 'string' || value.length === 0)
-        throw new Error('id must be a string');
-    return value;
-});
-const tvLibraryStatusInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return { id: reqStr(obj, 'id'), status: reqStr(obj, 'status') };
-});
-const tvLibraryBatchStatusInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return { ids: reqStrArray(obj, 'ids', true), status: reqStr(obj, 'status') };
-});
-const tvLibraryRemoveManyInput = () => defineSchema((value) => {
-    if (!Array.isArray(value) || value.length === 0)
-        throw new Error('ids must be a non-empty array');
-    return value.map((id) => String(id));
-});
-export const tvLibraryRouter = router({
-    list: protectedProcedure.input(tvLibraryListInput()).query(async ({ ctx, input }) => {
-        const page = Math.max(parseInt(String(input.page ?? 1)) || 1, 1);
-        const limit = Math.min(Math.max(parseInt(String(input.limit ?? 24)) || 24, 1), 100);
-        const offset = (page - 1) * limit;
-        const rows = await TvLibraryRepository.getAll(ctx.tvDb, input.status, limit, offset);
-        const total = await TvLibraryRepository.getCount(ctx.tvDb, input.status);
-        return { data: rows, total, page, limit };
-    }),
-    ids: protectedProcedure.query(async ({ ctx }) => {
-        return { ids: await TvLibraryRepository.getIds(ctx.tvDb) };
-    }),
-    check: protectedProcedure.input(tvLibraryIdInput()).query(async ({ ctx, input }) => {
-        const item = await TvLibraryRepository.getById(ctx.tvDb, input.id);
-        return { inLibrary: !!item, status: item?.status ?? null };
-    }),
-    add: protectedProcedure.input(tvLibraryAddInput()).mutation(async ({ ctx, input }) => {
-        const tmdbIdNum = Number(input.tmdbId);
-        if (!tmdbIdNum || (!input.id && !input.mediaType)) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'tmdbId and mediaType are required' });
-        }
-        const mediaType = normalizeMediaType(input.mediaType || (String(input.id).startsWith('movie:') ? 'movie' : 'tv'));
-        const id = input.id && String(input.id).includes(':')
-            ? String(input.id)
-            : buildTvId(mediaType, tmdbIdNum);
-        const cleanStatus = typeof input.status === 'string' && TV_STATUSES.includes(input.status)
-            ? input.status
-            : 'Watching';
-        await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-            await TvLibraryRepository.upsert(tx, {
-                id,
-                tmdbId: tmdbIdNum,
-                mediaType,
-                title: String(input.title || ''),
-                poster: String(input.poster || ''),
-                backdrop: input.backdrop ? String(input.backdrop) : undefined,
-                year: input.year ? String(input.year) : undefined,
-                overview: input.overview ? String(input.overview) : undefined,
-                status: cleanStatus,
-                adult: input.adult === true,
-            });
-        });
-        return { success: true, id };
-    }),
-    remove: protectedProcedure.input(tvLibraryRemoveInput()).mutation(async ({ ctx, input }) => {
-        await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-            await TvLibraryRepository.delete(tx, String(input));
-            await TvProgressRepository.deleteByMedia(tx, String(input));
-        });
-        return { success: true };
-    }),
-    setStatus: protectedProcedure.input(tvLibraryStatusInput()).mutation(async ({ ctx, input }) => {
-        if (!input.id || !TV_STATUSES.includes(input.status)) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'id and a valid status are required' });
-        }
-        await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-            await TvLibraryRepository.updateStatus(tx, String(input.id), String(input.status));
-        });
-        return { success: true };
-    }),
-    batchStatus: protectedProcedure
-        .input(tvLibraryBatchStatusInput())
-        .mutation(async ({ ctx, input }) => {
-        if (!input.status || !TV_STATUSES.includes(input.status)) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'a valid status is required' });
-        }
-        const ids = input.ids.map((id) => String(id));
-        await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-            await TvLibraryRepository.updateStatusMany(tx, ids, String(input.status));
-        });
-        return { success: true, updated: ids.length };
-    }),
-    removeMany: protectedProcedure
-        .input(tvLibraryRemoveManyInput())
-        .mutation(async ({ ctx, input }) => {
-        const ids = input.map((id) => String(id));
-        await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-            await TvLibraryRepository.deleteMany(tx, ids);
-            await TvProgressRepository.deleteMany(tx, ids);
-        });
-        return { success: true, removed: ids.length };
-    }),
-});

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

@@ -1,159 +0,0 @@
-import { TRPCError } from '@trpc/server';
-import { protectedProcedure, router } from '../index.js';
-import { performTvWriteTransactionAsync } from '../../sync.js';
-import { adultNonListIds } from '../../utils/db-utils.js';
-import { SettingsRepository } from '../../repositories/settings.repository.js';
-import { normalizeTvMediaId, TvLibraryRepository, TvProgressRepository, } from '../../repositories/tv.repository.js';
-import { defineSchema, reqObj, reqStr, strOrNull } from '../validation.js';
-const isTvContinueAdult = (row) => row.adult === true || row.adult === 1;
-const getAdultNonListMediaIds = (db) => adultNonListIds(db, 'tv_progress', 'tv_library', 'mediaId', 'COALESCE(l.adult, p.adult) = 1');
-const tvProgressMediaInput = () => defineSchema((value) => ({
-    mediaId: reqStr(reqObj(value), 'mediaId'),
-}));
-const tvProgressLatestInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return { mediaId: reqStr(obj, 'mediaId'), season: obj.season, episode: obj.episode };
-});
-const tvProgressSaveInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return {
-        mediaId: reqStr(obj, 'mediaId'),
-        season: obj.season,
-        episode: obj.episode,
-        currentTime: obj.currentTime,
-        duration: obj.duration,
-        completed: obj.completed,
-        title: strOrNull(obj, 'title'),
-        poster: strOrNull(obj, 'poster'),
-        backdrop: strOrNull(obj, 'backdrop'),
-        year: strOrNull(obj, 'year'),
-        overview: strOrNull(obj, 'overview'),
-        tmdbId: obj.tmdbId ?? null,
-        mediaType: strOrNull(obj, 'mediaType'),
-        adult: obj.adult ?? null,
-    };
-});
-const tvProgressRemoveInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return { mediaId: reqStr(obj, 'mediaId'), season: obj.season, episode: obj.episode };
-});
-const tvProgressRemoveManyInput = () => defineSchema((value) => {
-    if (!Array.isArray(value) || value.length === 0)
-        throw new Error('ids must be a non-empty array');
-    return value.map((id) => String(id));
-});
-const tvContinueWatchingInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    const out = {};
-    if (obj.limit !== undefined && obj.limit !== null && obj.limit !== '') {
-        const limit = Number(obj.limit);
-        if (Number.isFinite(limit))
-            out.limit = limit;
-    }
-    return out;
-});
-export const tvProgressRouter = router({
-    getByMedia: protectedProcedure.input(tvProgressMediaInput()).query(async ({ ctx, input }) => {
-        const rows = await TvProgressRepository.getByMedia(ctx.tvDb, normalizeTvMediaId(input.mediaId));
-        return { progress: rows };
-    }),
-    latest: protectedProcedure.input(tvProgressLatestInput()).query(async ({ ctx, input }) => {
-        const mediaId = normalizeTvMediaId(input.mediaId);
-        const season = parseInt(String(input.season), 10);
-        const episode = parseInt(String(input.episode), 10);
-        if (Number.isFinite(season) && Number.isFinite(episode)) {
-            const row = await TvProgressRepository.getEpisode(ctx.tvDb, mediaId, season, episode);
-            return row || { currentTime: 0, duration: 0, completed: 0 };
-        }
-        const row = await TvProgressRepository.getLatest(ctx.tvDb, mediaId);
-        return row || { currentTime: 0, duration: 0, completed: 0 };
-    }),
-    save: protectedProcedure.input(tvProgressSaveInput()).mutation(async ({ ctx, input }) => {
-        const mediaId = normalizeTvMediaId(input.mediaId);
-        if (!mediaId) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'mediaId is required' });
-        }
-        const seasonNum = Math.max(Number(input.season) || 1, 1);
-        const episodeNum = Math.max(Number(input.episode) || 1, 1);
-        const timeNum = Math.max(Number(input.currentTime) || 0, 0);
-        const durationNum = Math.max(Number(input.duration) || 0, 0);
-        const clampedTime = durationNum > 0 ? Math.min(timeNum, durationNum) : timeNum;
-        const storedTime = durationNum > 0 && clampedTime >= durationNum * 0.8 ? durationNum : clampedTime;
-        const completedNow = Number(input.completed) === 1 || (durationNum > 0 && storedTime >= durationNum * 0.8) ? 1 : 0;
-        await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-            await TvProgressRepository.upsert(tx, {
-                mediaId: String(mediaId),
-                season: Math.round(seasonNum),
-                episode: Math.round(episodeNum),
-                currentTime: storedTime,
-                duration: durationNum,
-                completed: completedNow,
-                title: input.title ?? null,
-                poster: input.poster ?? null,
-                backdrop: input.backdrop ?? null,
-                year: input.year ?? null,
-                overview: input.overview ?? null,
-                tmdbId: input.tmdbId != null ? Number(input.tmdbId) : null,
-                mediaType: input.mediaType ?? null,
-                adult: input.adult != null ? Number(input.adult) : null,
-            });
-            await TvLibraryRepository.touchProgress(tx, String(mediaId), {
-                season: Math.round(seasonNum),
-                episode: Math.round(episodeNum),
-            });
-        });
-        return { success: true };
-    }),
-    remove: protectedProcedure.input(tvProgressRemoveInput()).mutation(async ({ ctx, input }) => {
-        const mediaId = normalizeTvMediaId(input.mediaId);
-        if (!mediaId) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'mediaId is required' });
-        }
-        await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-            if (input.season !== undefined && input.episode !== undefined) {
-                await TvProgressRepository.deleteEpisode(tx, String(mediaId), Number(input.season), Number(input.episode));
-            }
-            else {
-                await TvProgressRepository.deleteByMedia(tx, String(mediaId));
-            }
-        });
-        return { success: true };
-    }),
-    removeMany: protectedProcedure
-        .input(tvProgressRemoveManyInput())
-        .mutation(async ({ ctx, input }) => {
-        const ids = input.map((id) => normalizeTvMediaId(id));
-        await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-            await TvProgressRepository.deleteMany(tx, ids);
-        });
-        return { success: true, removed: ids.length };
-    }),
-    continueWatching: protectedProcedure
-        .input(tvContinueWatchingInput())
-        .query(async ({ ctx, input }) => {
-        const limit = Math.min(Math.max(parseInt(String(input.limit ?? 24)) || 24, 1), 100);
-        const { ignoreAdult, listOnly } = await SettingsRepository.readContinueFlags(ctx.db, 'tvIgnoreAdultContent', 'tvCwWatchlistOnly');
-        const rows = (await TvProgressRepository.getContinueWatching(ctx.tvDb, limit)).filter((row) => {
-            if (ignoreAdult && isTvContinueAdult(row))
-                return false;
-            if (listOnly && row.watchlistStatus !== 'Watching')
-                return false;
-            return true;
-        });
-        return { data: rows, total: rows.length };
-    }),
-    adultCount: protectedProcedure.query(async ({ ctx }) => {
-        const ids = await getAdultNonListMediaIds(ctx.tvDb);
-        return { count: ids.length };
-    }),
-    purgeAdult: protectedProcedure.mutation(async ({ ctx }) => {
-        const ids = await getAdultNonListMediaIds(ctx.tvDb);
-        if (ids.length > 0) {
-            await performTvWriteTransactionAsync(ctx.tvDb, async (tx) => {
-                for (const id of ids)
-                    await TvProgressRepository.deleteByMedia(tx, id);
-            });
-        }
-        return { success: true, removed: ids.length };
-    }),
-});