@serifpersia/dango 3.3.9 → 3.4.0

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

@@ -0,0 +1,80 @@
+import { protectedProcedure, router } from '../index.js';
+import logger from '../../logger.js';
+import { performWriteTransactionAsync } from '../../sync.js';
+import { WatchlistRepository } from '../../repositories/watchlist.repository.js';
+import { WatchedEpisodesRepository } from '../../repositories/watched-episodes.repository.js';
+import { NotificationsRepository } from '../../repositories/notifications.repository.js';
+import { notificationDismissInput } from '../validation.js';
+function clearAllInput() {
+    return {
+        '~standard': {
+            version: 1,
+            vendor: 'dango',
+            types: undefined,
+            validate(value) {
+                try {
+                    if (value === undefined || value === null)
+                        return { value: {} };
+                    if (typeof value !== 'object' || value === null)
+                        throw new Error('Expected an object');
+                    const showId = value.showId;
+                    if (showId === undefined || showId === null)
+                        return { value: {} };
+                    if (typeof showId !== 'string' || showId.length === 0)
+                        throw new Error('showId must be a string');
+                    return { value: { showId } };
+                }
+                catch (err) {
+                    return { issues: [{ message: err instanceof Error ? err.message : 'Invalid input' }] };
+                }
+            },
+        },
+    };
+}
+export const notificationsRouter = router({
+    list: protectedProcedure.query(async ({ ctx }) => {
+        const watchingShows = await WatchlistRepository.getWatchingShows(ctx.db);
+        const notifications = [];
+        for (const show of watchingShows) {
+            try {
+                const [watchedEps, dismissedEps, discoveredEps] = await Promise.all([
+                    WatchedEpisodesRepository.getWatchedEpisodeNumbers(ctx.db, show.id),
+                    NotificationsRepository.getDismissedByShow(ctx.db, show.id),
+                    NotificationsRepository.getDiscoveredByShow(ctx.db, show.id),
+                ]);
+                const watchedSet = new Set(watchedEps.map((e) => e.toString()));
+                const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
+                for (const discovered of discoveredEps) {
+                    if (!watchedSet.has(discovered.episodeNumber) &&
+                        !dismissedSet.has(discovered.episodeNumber)) {
+                        notifications.push({
+                            showId: show.id,
+                            name: show.name,
+                            nativeName: show.nativeName,
+                            englishName: show.englishName,
+                            thumbnail: show.thumbnail,
+                            episodeNumber: discovered.episodeNumber,
+                            id: `${show.id}-${discovered.episodeNumber}`,
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                logger.error({ err: e, showId: show.id }, 'Failed to get notifications for show');
+            }
+        }
+        return notifications.sort((a, b) => parseFloat(b.episodeNumber) - parseFloat(a.episodeNumber));
+    }),
+    dismiss: protectedProcedure.input(notificationDismissInput()).mutation(async ({ ctx, input }) => {
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            await NotificationsRepository.addDismissed(tx, input.showId, input.episodeNumber);
+        });
+        return { success: true };
+    }),
+    clearAll: protectedProcedure.input(clearAllInput()).mutation(async ({ ctx, input }) => {
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            await NotificationsRepository.dismissFromDiscovered(tx, input.showId);
+        });
+        return { success: true };
+    }),
+});

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

@@ -0,0 +1,15 @@
+import { protectedProcedure, router } from '../index.js';
+import { WatchedEpisodesRepository } from '../../repositories/watched-episodes.repository.js';
+import { getMigratedId } from '../../lib/migration.js';
+import { episodeProgressInput, showIdInput } from '../validation.js';
+export const progressRouter = router({
+    getEpisode: protectedProcedure.input(episodeProgressInput()).query(async ({ ctx, input }) => {
+        const showId = await getMigratedId(ctx.db, input.showId);
+        const progress = await WatchedEpisodesRepository.getByShowAndEpisode(ctx.db, showId, input.episodeNumber);
+        return progress || { currentTime: 0, duration: 0 };
+    }),
+    getWatchedEpisodes: protectedProcedure.input(showIdInput()).query(async ({ ctx, input }) => {
+        const showId = await getMigratedId(ctx.db, input.showId);
+        return WatchedEpisodesRepository.getWatchedEpisodeNumbers(ctx.db, showId);
+    }),
+});

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

@@ -0,0 +1,95 @@
+import { protectedProcedure, router } from '../index.js';
+import { QueueRepository } from '../../repositories/queue.repository.js';
+import { ShowsMetaRepository } from '../../repositories/shows-meta.repository.js';
+import { performWriteTransactionAsync } from '../../sync.js';
+import { getMigratedId } from '../../lib/migration.js';
+import { queueAddInput, queueBatchInput, queueRemoveInput, queueRemoveManyInput, queueReorderInput, } from '../validation.js';
+function applyMeta(meta) {
+    return meta.showName || meta.showThumbnail || meta.nativeName || meta.englishName || meta.type;
+}
+export const queueRouter = router({
+    list: protectedProcedure.query(async ({ ctx }) => {
+        const rows = await QueueRepository.getAll(ctx.db);
+        return rows.map((row) => ({
+            ...row,
+            _id: row.showId,
+            id: row.id,
+            thumbnail: row.thumbnail || '',
+        }));
+    }),
+    add: protectedProcedure.input(queueAddInput()).mutation(async ({ ctx, input }) => {
+        const showId = await getMigratedId(ctx.db, input.showId);
+        const episodeNumber = input.episodeNumber;
+        const existing = await QueueRepository.getByEpisode(ctx.db, showId, episodeNumber);
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            if (applyMeta(input)) {
+                await ShowsMetaRepository.upsert(tx, {
+                    id: showId,
+                    name: input.showName || '',
+                    thumbnail: input.showThumbnail || '',
+                    nativeName: input.nativeName,
+                    englishName: input.englishName,
+                    type: input.type,
+                });
+            }
+            if (existing) {
+                await QueueRepository.removeEpisode(tx, showId, episodeNumber);
+            }
+            else {
+                await QueueRepository.addToEnd(tx, showId, episodeNumber);
+            }
+        });
+        ctx.db.scheduleSave();
+        return { success: true, queued: !existing };
+    }),
+    addBatch: protectedProcedure.input(queueBatchInput()).mutation(async ({ ctx, input }) => {
+        const showId = await getMigratedId(ctx.db, input.showId);
+        const normalized = [...new Set(input.episodeNumbers)];
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            if (applyMeta(input)) {
+                await ShowsMetaRepository.upsert(tx, {
+                    id: showId,
+                    name: input.showName || '',
+                    thumbnail: input.showThumbnail || '',
+                    nativeName: input.nativeName,
+                    englishName: input.englishName,
+                    type: input.type,
+                });
+            }
+            await QueueRepository.addManyToEnd(tx, normalized.map((episodeNumber) => ({ showId, episodeNumber })));
+        });
+        ctx.db.scheduleSave();
+        return { success: true, added: normalized.length };
+    }),
+    remove: protectedProcedure.input(queueRemoveInput()).mutation(async ({ ctx, input }) => {
+        const showId = await getMigratedId(ctx.db, input.showId);
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            await QueueRepository.removeEpisode(tx, showId, input.episodeNumber);
+        });
+        return { success: true };
+    }),
+    removeMany: protectedProcedure.input(queueRemoveManyInput()).mutation(async ({ ctx, input }) => {
+        const showId = await getMigratedId(ctx.db, input.showId);
+        let removed;
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            removed = ((await QueueRepository.getByShow(tx, showId)) || []).map((ep) => ep.episodeNumber);
+            const toRemove = Array.isArray(input.episodeNumbers) && input.episodeNumbers.length
+                ? [...new Set(input.episodeNumbers)]
+                : removed;
+            await QueueRepository.removeMany(tx, showId, toRemove);
+        });
+        return { success: true, removed: removed.length };
+    }),
+    clear: protectedProcedure.mutation(async ({ ctx }) => {
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            await QueueRepository.clear(tx);
+        });
+        return { success: true };
+    }),
+    reorder: protectedProcedure.input(queueReorderInput()).mutation(async ({ ctx, input }) => {
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            await QueueRepository.reorder(tx, input);
+        });
+        return { success: true };
+    }),
+});

package/server/dist/{routes/radio.routes.js → trpc/routers/radio.js}

@@ -1,6 +1,7 @@
-import { Router } from 'express';
-import logger from '../logger.js';
-import { parseJsonBody } from '../utils/http.utils.js';
+import { protectedProcedure, router } from '../index.js';
+import { defineSchema, optStr, reqObj } from '../validation.js';
+import logger from '../../logger.js';
+import { parseJsonBody } from '../../utils/http.utils.js';
 const LISTEN_MOE_STATIONS = [
     {
         id: 'listenmoe-jpop',
@@ -96,43 +97,49 @@ function toStation(s) {
         source: 'radio-browser',
     };
 }
-export function createRadioRouter(apiCache) {
-    const router = Router();
-    router.get('/radio/stations', async (_req, res) => {
+const radioSearchInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    const q = optStr(obj, 'q');
+    if (q !== undefined)
+        out.q = q;
+    return out;
+});
+export const radioRouter = router({
+    stations: protectedProcedure.query(async ({ ctx }) => {
         try {
-            const cached = apiCache.get('route-radio-stations');
+            const cached = ctx.apiCache.get('route-radio-stations');
             if (cached)
-                return res.json({ stations: cached });
+                return { stations: cached };
             const stations = [...LISTEN_MOE_STATIONS, ...FEATURED_STATIONS];
-            apiCache.set('route-radio-stations', stations, 3600);
-            res.json({ stations });
+            ctx.apiCache.set('route-radio-stations', stations, 3600);
+            return { stations };
         }
         catch (err) {
             logger.error({ err }, '[Radio] stations failed');
-            res.json({ stations: LISTEN_MOE_STATIONS });
+            return { stations: LISTEN_MOE_STATIONS };
         }
-    });
-    router.get('/radio/search', async (req, res) => {
+    }),
+    search: protectedProcedure.input(radioSearchInput()).query(async ({ ctx, input }) => {
         try {
-            const q = String(req.query.q || '').trim();
+            const q = String(input.q || '').trim();
             if (!q)
-                return res.json({ stations: [] });
+                return { stations: [] };
             const cacheKey = `route-radio-search-${q.toLowerCase()}`;
-            const cached = apiCache.get(cacheKey);
+            const cached = ctx.apiCache.get(cacheKey);
             if (cached)
-                return res.json({ stations: cached });
+                return { stations: cached };
             const raw = (await rbFetch(`/json/stations/search?name=${encodeURIComponent(q)}&hidebroken=true&order=clickcount&reverse=true&limit=25`));
             const stations = raw
                 .map(toStation)
                 .filter((s) => s !== null)
                 .slice(0, 25);
-            apiCache.set(cacheKey, stations, 300);
-            res.json({ stations });
+            ctx.apiCache.set(cacheKey, stations, 300);
+            return { stations };
         }
         catch (err) {
             logger.error({ err }, '[Radio] search failed');
-            res.json({ stations: [] });
+            return { stations: [] };
         }
-    });
-    return router;
-}
+    }),
+});

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

@@ -0,0 +1,105 @@
+import { TRPCError } from '@trpc/server';
+import { protectedProcedure, router } from '../index.js';
+import { SettingsRepository } from '../../repositories/settings.repository.js';
+import { performWriteTransactionAsync } from '../../sync.js';
+import { discordRPCService } from '../../discord-rpc.js';
+import logger from '../../logger.js';
+import { offlineDb } from '../../lib/offline-db.js';
+import { translateTexts } from '../../lib/translate.js';
+import { getMachineId } from '../../utils/machine-id.js';
+import { getMalImportStatus, requestMalImportCancel } from '../../lib/mal-import.js';
+import { defineSchema, reqObj } from '../validation.js';
+import { keyInput, setSettingInput } from '../validation.js';
+export const SETTING_DEFAULTS = {
+    discordRPCEnabled: 'true',
+    discordRPCHideMature: 'true',
+    ignoreAdultContent: 'true',
+    mangaIgnoreAdultContent: 'true',
+    tvIgnoreAdultContent: 'true',
+    asmrIgnoreAdultContent: 'true',
+};
+const autoUpdateInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    if (typeof obj.enabled !== 'boolean')
+        throw new Error('enabled must be a boolean');
+    return { enabled: obj.enabled };
+});
+const translateInput = () => defineSchema((value) => {
+    if (value === undefined || value === null)
+        return {};
+    const obj = reqObj(value);
+    return { texts: obj.texts, source: obj.source, target: obj.target };
+});
+export const settingsRouter = router({
+    getByKey: protectedProcedure.input(keyInput()).query(async ({ ctx, input }) => {
+        const row = await SettingsRepository.getByKey(ctx.db, input.key);
+        const value = row ? row.value : (SETTING_DEFAULTS[input.key] ?? null);
+        return { value };
+    }),
+    set: protectedProcedure.input(setSettingInput()).mutation(async ({ ctx, input }) => {
+        const key = input.key;
+        const value = String(input.value ?? '');
+        const shouldDelete = value === '' && key === 'tracker_anilist_client_id';
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            if (shouldDelete)
+                await SettingsRepository.deleteByKey(tx, key);
+            else
+                await SettingsRepository.upsert(tx, key, value);
+        });
+        if (key === 'discordRPCEnabled') {
+            discordRPCService.setEnabled(input.value === 'true' || input.value === true);
+        }
+        if (key === 'discordRPCHideMature') {
+            discordRPCService.setHideMature(input.value === 'true' || input.value === true);
+        }
+        return { success: true };
+    }),
+    offlineDbInfo: protectedProcedure.query(async ({ ctx }) => {
+        return await offlineDb.getOfflineDbInfo(ctx.db);
+    }),
+    setOfflineDbAutoUpdate: protectedProcedure
+        .input(autoUpdateInput())
+        .mutation(async ({ ctx, input }) => {
+        await SettingsRepository.upsert(ctx.db, 'offlineDbAutoUpdateEnabled', String(input.enabled));
+        return { success: true, enabled: input.enabled };
+    }),
+    triggerOfflineDbUpdate: protectedProcedure.mutation(async ({ ctx }) => {
+        const info = await offlineDb.getOfflineDbInfo(ctx.db);
+        if (info.isRefreshing) {
+            throw new TRPCError({
+                code: 'CONFLICT',
+                message: 'Offline database refresh already in progress',
+            });
+        }
+        offlineDb.refreshDatabase(ctx.db).catch((err) => {
+            logger.warn({ err: err?.message }, 'Manual offline database update failed');
+        });
+        return { message: 'Offline database refresh started' };
+    }),
+    installationId: protectedProcedure.query(() => {
+        try {
+            return { id: getMachineId() };
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to get machine ID');
+            throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Failed to get machine ID' });
+        }
+    }),
+    translate: protectedProcedure.input(translateInput()).mutation(async ({ input }) => {
+        const texts = input.texts;
+        const source = input.source ?? 'ja';
+        const target = input.target ?? 'en';
+        if (!Array.isArray(texts) || texts.length === 0) {
+            return { translations: {} };
+        }
+        return {
+            translations: await translateTexts(texts, String(source), String(target)),
+        };
+    }),
+    malImportStatus: protectedProcedure.query(() => {
+        return getMalImportStatus();
+    }),
+    malImportCancel: protectedProcedure.mutation(() => {
+        return requestMalImportCancel();
+    }),
+});

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

@@ -0,0 +1,219 @@
+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 { defineSchema, reqObj } from '../validation.js';
+const TRACKER_TOKEN_KEY = 'tracker_anilist_token';
+const TRACKER_USER_KEY = 'tracker_anilist_user';
+function badRequest(message) {
+    return new TRPCError({ code: 'BAD_REQUEST', message });
+}
+function failed(message) {
+    return new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message });
+}
+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');
+        }
+    }),
+});