@serifpersia/dango 3.3.8 → 3.4.0

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

@@ -0,0 +1,133 @@
+import { protectedProcedure, router } from '../index.js';
+import { performAsmrWriteTransactionAsync } from '../../sync.js';
+import { dbAll } from '../../utils/db-utils.js';
+import { SettingsRepository } from '../../repositories/settings.repository.js';
+import { AsmrLibraryRepository, AsmrProgressRepository, } from '../../repositories/asmr.repository.js';
+import { defineSchema, reqObj, reqStr, reqStrArray } from '../validation.js';
+async function getAdultNonListWorkIds(db) {
+    const rows = await dbAll(db, `SELECT DISTINCT p.workId as workId
+       FROM asmr_progress p
+       LEFT JOIN asmr_library l ON l.id = p.workId
+       WHERE COALESCE(l.isAdult, p.isAdult) = 1
+         AND l.id IS NULL`);
+    return rows.map((r) => r.workId);
+}
+const asmrProgressIdsInput = () => defineSchema((value) => ({
+    ids: reqStrArray(reqObj(value), 'ids', true),
+}));
+const asmrProgressWorkInput = () => defineSchema((value) => ({
+    workId: reqStr(reqObj(value), 'workId'),
+}));
+const asmrProgressSaveInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    return {
+        workId: reqStr(obj, 'workId'),
+        trackIndex: obj.trackIndex,
+        trackLabel: obj.trackLabel,
+        currentTime: obj.currentTime,
+        duration: obj.duration,
+        title: obj.title ?? null,
+        thumbnail: obj.thumbnail ?? null,
+        rjCode: obj.rjCode ?? null,
+        isAdult: obj.isAdult ?? null,
+    };
+});
+const asmrProgressRemoveInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    return { workId: reqStr(obj, 'workId'), trackIndex: obj.trackIndex ?? undefined };
+});
+const asmrContinueListeningInput = () => 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 asmrProgressRouter = router({
+    getByWork: protectedProcedure.input(asmrProgressWorkInput()).query(async ({ ctx, input }) => {
+        const rows = await AsmrProgressRepository.getByWork(ctx.asmrDb, input.workId);
+        return { progress: rows };
+    }),
+    latest: protectedProcedure.input(asmrProgressWorkInput()).query(async ({ ctx, input }) => {
+        const row = await AsmrProgressRepository.getLatest(ctx.asmrDb, input.workId);
+        return row || { currentTime: 0, duration: 0 };
+    }),
+    save: protectedProcedure.input(asmrProgressSaveInput()).mutation(async ({ ctx, input }) => {
+        const trackIndexNum = Math.max(Math.round(Number(input.trackIndex)) || 0, 0);
+        const timeNum = Math.max(Number(input.currentTime) || 0, 0);
+        const durationNum = Math.max(Number(input.duration) || 0, 0);
+        await performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
+            await AsmrProgressRepository.upsert(tx, {
+                workId: String(input.workId),
+                trackIndex: trackIndexNum,
+                trackLabel: String(input.trackLabel || ''),
+                currentTime: timeNum,
+                duration: durationNum,
+                title: (input.title ?? null),
+                thumbnail: (input.thumbnail ?? null),
+                rjCode: (input.rjCode ?? null),
+                isAdult: input.isAdult != null ? Number(input.isAdult) : null,
+            });
+            await AsmrLibraryRepository.touchProgress(tx, String(input.workId), {
+                trackIndex: trackIndexNum,
+                trackLabel: String(input.trackLabel || ''),
+                position: timeNum,
+            });
+        });
+        return { success: true };
+    }),
+    remove: protectedProcedure.input(asmrProgressRemoveInput()).mutation(async ({ ctx, input }) => {
+        await performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
+            if (input.trackIndex !== undefined && input.trackIndex !== null) {
+                await AsmrProgressRepository.deleteTrack(tx, String(input.workId), Number(input.trackIndex));
+            }
+            else {
+                await AsmrProgressRepository.deleteByWork(tx, String(input.workId));
+            }
+        });
+        return { success: true };
+    }),
+    removeMany: protectedProcedure.input(asmrProgressIdsInput()).mutation(async ({ ctx, input }) => {
+        const ids = input.ids.map((id) => String(id));
+        await performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
+            await AsmrProgressRepository.deleteMany(tx, ids);
+        });
+        return { success: true, removed: ids.length };
+    }),
+    continueListening: protectedProcedure
+        .input(asmrContinueListeningInput())
+        .query(async ({ ctx, input }) => {
+        const limit = Math.min(Math.max(parseInt(String(input.limit ?? 24)) || 24, 1), 100);
+        const ignoreAdultRow = await SettingsRepository.getByKey(ctx.db, 'asmrIgnoreAdultContent');
+        const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
+        const listOnlyRow = await SettingsRepository.getByKey(ctx.db, 'asmrCwWatchlistOnly');
+        const listOnly = listOnlyRow
+            ? listOnlyRow.value === 'true' || listOnlyRow.value === '1'
+            : false;
+        const rows = (await AsmrProgressRepository.getContinueListening(ctx.asmrDb, limit)).filter((row) => {
+            if (ignoreAdult && row.isAdult === 1)
+                return false;
+            if (listOnly && row.watchlistStatus !== 'Listening')
+                return false;
+            return true;
+        });
+        return { data: rows, total: rows.length };
+    }),
+    adultCount: protectedProcedure.query(async ({ ctx }) => {
+        const ids = await getAdultNonListWorkIds(ctx.asmrDb);
+        return { count: ids.length };
+    }),
+    purgeAdult: protectedProcedure.mutation(async ({ ctx }) => {
+        const ids = await getAdultNonListWorkIds(ctx.asmrDb);
+        if (ids.length > 0) {
+            await performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
+                for (const id of ids)
+                    await AsmrProgressRepository.deleteByWork(tx, id);
+            });
+        }
+        return { success: true, removed: ids.length };
+    }),
+});

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

@@ -0,0 +1,87 @@
+import { protectedProcedure, router } from '../index.js';
+import { defineSchema, optStr, reqObj, reqStr } from '../validation.js';
+import { authRequiredError } from '../errors.js';
+import logger from '../../logger.js';
+async function cached(ctx, key, ttl, produce) {
+    const hit = ctx.apiCache.get(key);
+    if (hit)
+        return hit;
+    const body = await produce();
+    if (ttl !== undefined)
+        ctx.apiCache.set(key, body, ttl);
+    else
+        ctx.apiCache.set(key, body);
+    return body;
+}
+const asmrBrowseInput = () => defineSchema((value) => {
+    if (value === undefined || value === null)
+        return {};
+    const obj = reqObj(value);
+    const out = {};
+    const q = optStr(obj, 'q');
+    if (q !== undefined)
+        out.q = q;
+    if (obj.page !== undefined)
+        out.page = parseInt(String(obj.page), 10) || 1;
+    const sort = optStr(obj, 'sort');
+    if (sort !== undefined)
+        out.sort = sort;
+    const rating = optStr(obj, 'rating');
+    if (rating !== undefined)
+        out.rating = rating;
+    return out;
+});
+const asmrWorkInput = () => defineSchema((value) => ({ rj: reqStr(reqObj(value), 'rj') }));
+export const asmrRouter = router({
+    browse: protectedProcedure.input(asmrBrowseInput()).query(async ({ ctx, input }) => {
+        const q = input.q || '';
+        const page = input.page || 1;
+        const sort = input.sort || '';
+        const rating = input.rating || '';
+        return cached(ctx, `route-asmr-browse-${q}-${page}-${sort}-${rating}-${sort === 'random' ? Date.now() : ''}`, 300, async () => {
+            try {
+                const provider = ctx.getJasmr();
+                if (!provider)
+                    return { shows: [], hasNext: false };
+                return await provider.browse({ query: q, page, sort, rating });
+            }
+            catch (err) {
+                if (err.message === 'AUTH_REQUIRED')
+                    throw authRequiredError('jasmr');
+                logger.error({ err }, '[Asmr] browse failed');
+                return { shows: [], hasNext: false };
+            }
+        });
+    }),
+    work: protectedProcedure.input(asmrWorkInput()).query(async ({ ctx, input }) => {
+        const rj = input.rj;
+        return cached(ctx, `route-asmr-work-${rj}`, 1800, async () => {
+            try {
+                const provider = ctx.getJasmr();
+                if (!provider) {
+                    return { rjCode: rj, description: '', tracks: [], images: [], chapters: [] };
+                }
+                const rjCode = String(rj).trim().toUpperCase();
+                const episodes = await provider.getEpisodes(rjCode);
+                const [streams, images, chapters] = await Promise.all([
+                    provider.getStreamUrls(rjCode, '1'),
+                    provider.getImages(rjCode),
+                    provider.getChapters(rjCode),
+                ]);
+                return {
+                    rjCode,
+                    description: episodes?.description || '',
+                    tracks: streams?.[0]?.links || [],
+                    images,
+                    chapters,
+                };
+            }
+            catch (err) {
+                if (err.message === 'AUTH_REQUIRED')
+                    throw authRequiredError('jasmr');
+                logger.error({ err, rj }, '[Asmr] work fetch failed');
+                return { rjCode: rj, description: '', tracks: [], images: [], chapters: [] };
+            }
+        });
+    }),
+});

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

@@ -0,0 +1,247 @@
+import path from 'path';
+import logger from '../../logger.js';
+import { googleDriveService } from '../../google.js';
+import { githubSyncService } from '../../github-sync.js';
+import { initSyncProvider, getActiveProvider, syncDownOnBoot, syncUp, mangaSyncDownOnBoot, mangaSyncUp, tvSyncDownOnBoot, tvSyncUp, asmrSyncDownOnBoot, asmrSyncUp, initializeDatabase, } from '../../sync.js';
+import { CONFIG } from '../../config.js';
+import { rcloneService } from '../../rclone.js';
+import { updateEnvFile } from '../../utils/env.utils.js';
+import { protectedProcedure, router } from '../index.js';
+import { defineSchema, reqObj } from '../validation.js';
+async function runSyncFromCtx(ctx, database, preferredProvider) {
+    const dbName = CONFIG.IS_DEV ? CONFIG.DB_NAME_DEV : CONFIG.DB_NAME_PROD;
+    const dbPath = path.join(CONFIG.ROOT, dbName);
+    const remoteFolder = CONFIG.IS_DEV ? CONFIG.REMOTE_FOLDER_DEV : CONFIG.REMOTE_FOLDER_PROD;
+    await initSyncProvider(preferredProvider);
+    if (getActiveProvider() === 'github' && githubSyncService.isAuthenticated()) {
+        try {
+            await githubSyncService.migrateFromAniWebSync();
+        }
+        catch (err) {
+            logger.error({ err }, 'GitHub sync migration from ani-web failed');
+        }
+    }
+    const didDownload = await syncDownOnBoot(database, dbPath, remoteFolder, () => {
+        return new Promise((resolve) => {
+            if (database && !database.isClosedCheck()) {
+                database.checkpoint();
+                database.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+    let currentDb = database;
+    if (didDownload) {
+        currentDb = await initializeDatabase(dbPath);
+        logger.info('Database re-initialized after sync.');
+    }
+    try {
+        await syncUp(currentDb, dbPath, remoteFolder);
+    }
+    catch (err) {
+        logger.error({ err }, 'Sync up on boot failed');
+    }
+    try {
+        await mangaSyncDownOnBoot(ctx.mangaDb, remoteFolder);
+    }
+    catch (err) {
+        logger.error({ err }, 'Manga sync down on boot failed');
+    }
+    try {
+        await mangaSyncUp(ctx.mangaDb, remoteFolder);
+    }
+    catch (err) {
+        logger.error({ err }, 'Manga sync up on boot failed');
+    }
+    try {
+        await tvSyncDownOnBoot(ctx.tvDb, remoteFolder);
+    }
+    catch (err) {
+        logger.error({ err }, 'TV sync down on boot failed');
+    }
+    try {
+        await tvSyncUp(ctx.tvDb, remoteFolder);
+    }
+    catch (err) {
+        logger.error({ err }, 'TV sync up on boot failed');
+    }
+    try {
+        await asmrSyncDownOnBoot(ctx.asmrDb, remoteFolder);
+    }
+    catch (err) {
+        logger.error({ err }, 'ASMR sync down on boot failed');
+    }
+    try {
+        await asmrSyncUp(ctx.asmrDb, remoteFolder);
+    }
+    catch (err) {
+        logger.error({ err }, 'ASMR sync up on boot failed');
+    }
+}
+const googleAuthSaveInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    return { clientId: obj.clientId, clientSecret: obj.clientSecret, workerUrl: obj.workerUrl };
+});
+const githubAuthSaveInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    if (typeof obj.clientId !== 'string')
+        throw new Error('clientId required');
+    return { clientId: obj.clientId };
+});
+const syncProviderInput = () => defineSchema((value) => ({
+    provider: reqObj(value).provider,
+}));
+const rcloneSaveInput = () => defineSchema((value) => ({
+    remote: reqObj(value).remote,
+}));
+export const authRouter = router({
+    configStatus: protectedProcedure.query(async () => {
+        const useWorker = !!CONFIG.GOOGLE_AUTH_WORKER_URL;
+        const hasLegacyConfig = !!process.env.GOOGLE_CLIENT_ID && !!process.env.GOOGLE_CLIENT_SECRET;
+        return { hasConfig: useWorker || hasLegacyConfig, useWorker };
+    }),
+    googleAuth: protectedProcedure.query(async () => {
+        return {
+            useWorker: !!CONFIG.GOOGLE_AUTH_WORKER_URL,
+            hasCustomWorkerUrl: !!process.env.GOOGLE_AUTH_WORKER_URL,
+            hasCustomClientId: !!process.env.GOOGLE_CLIENT_ID,
+            hasClientSecret: !!process.env.GOOGLE_CLIENT_SECRET,
+        };
+    }),
+    saveGoogleAuth: protectedProcedure.input(googleAuthSaveInput()).mutation(async ({ input }) => {
+        const { clientId, clientSecret, workerUrl } = input;
+        const updates = {};
+        if (typeof clientId === 'string') {
+            updates.GOOGLE_CLIENT_ID = clientId;
+        }
+        if (typeof clientSecret === 'string') {
+            updates.GOOGLE_CLIENT_SECRET = clientSecret;
+        }
+        if (typeof workerUrl === 'string') {
+            updates.GOOGLE_AUTH_WORKER_URL = workerUrl;
+        }
+        await updateEnvFile(updates);
+        if (typeof workerUrl === 'string') {
+            ;
+            CONFIG.GOOGLE_AUTH_WORKER_URL = workerUrl;
+        }
+        if (typeof clientId === 'string') {
+            ;
+            CONFIG.GOOGLE_CLIENT_ID = clientId || undefined;
+        }
+        if (typeof clientSecret === 'string') {
+            ;
+            CONFIG.GOOGLE_CLIENT_SECRET =
+                clientSecret || undefined;
+        }
+        await initSyncProvider();
+        return { success: true };
+    }),
+    githubAuth: protectedProcedure.query(async () => {
+        return { hasCustomClientId: !!process.env.GITHUB_CLIENT_ID };
+    }),
+    saveGithubAuth: protectedProcedure.input(githubAuthSaveInput()).mutation(async ({ input }) => {
+        await updateEnvFile({ GITHUB_CLIENT_ID: input.clientId });
+        return { success: true };
+    }),
+    rcloneSettings: protectedProcedure.query(async () => {
+        const remotes = await rcloneService.listRemotes();
+        return {
+            remote: CONFIG.RCLONE_REMOTE || '',
+            availableRemotes: remotes,
+            activeRemote: rcloneService.isActive() ? rcloneService.getRemoteName() : null,
+        };
+    }),
+    syncSettings: protectedProcedure.query(async () => {
+        return {
+            activeProvider: process.env.SYNC_PROVIDER || 'default',
+            actualActiveProvider: getActiveProvider(),
+            authenticatedProviders: {
+                github: githubSyncService.isAuthenticated(),
+                google: googleDriveService.isAuthenticated(),
+                rclone: rcloneService.isActive(),
+            },
+        };
+    }),
+    saveSyncProvider: protectedProcedure.input(syncProviderInput()).mutation(async ({ input }) => {
+        const { provider } = input;
+        const value = provider === 'default' ? '' : provider;
+        await updateEnvFile({ SYNC_PROVIDER: value });
+        await initSyncProvider();
+        return { success: true, activeProvider: process.env.SYNC_PROVIDER || 'default' };
+    }),
+    githubStatus: protectedProcedure.query(async () => {
+        try {
+            const user = await githubSyncService.getUserProfile();
+            return {
+                authenticated: !!user,
+                user,
+                device: githubSyncService.getDeviceState(),
+                hasCustomClientId: !!process.env.GITHUB_CLIENT_ID,
+            };
+        }
+        catch (error) {
+            logger.error({ err: error }, 'Failed to fetch GitHub auth status');
+            return {
+                authenticated: false,
+                user: null,
+                device: githubSyncService.getDeviceState(),
+                hasCustomClientId: !!process.env.GITHUB_CLIENT_ID,
+            };
+        }
+    }),
+    githubStart: protectedProcedure.mutation(async ({ ctx }) => {
+        const state = await githubSyncService.startDeviceAuth(ctx.db, (db, provider) => runSyncFromCtx(ctx, db, provider));
+        return state;
+    }),
+    githubPoll: protectedProcedure.query(async () => {
+        return githubSyncService.getDeviceState();
+    }),
+    githubLogout: protectedProcedure.mutation(async () => {
+        await githubSyncService.logout();
+        await updateEnvFile({ SYNC_PROVIDER: '' });
+        await initSyncProvider();
+        return { success: true };
+    }),
+    saveRclone: protectedProcedure.input(rcloneSaveInput()).mutation(async ({ ctx, input }) => {
+        const { remote } = input;
+        await updateEnvFile({
+            RCLONE_REMOTE: remote,
+            SYNC_PROVIDER: 'rclone',
+        });
+        await runSyncFromCtx(ctx, ctx.db, 'rclone');
+        return { success: true };
+    }),
+    googleAuthUrl: protectedProcedure.query(async () => {
+        const url = await googleDriveService.getAuthUrl();
+        return { url };
+    }),
+    googleLogin: protectedProcedure.mutation(async ({ ctx }) => {
+        if (googleDriveService.isAuthenticated()) {
+            const user = await googleDriveService.getUserProfile();
+            if (user) {
+                await updateEnvFile({ SYNC_PROVIDER: 'google' });
+                await runSyncFromCtx(ctx, ctx.db, 'google');
+                return { url: null, authenticated: true };
+            }
+            else {
+                logger.warn('Google tokens found but invalid. Clearing and requesting new auth.');
+                await googleDriveService.logout();
+            }
+        }
+        const url = await googleDriveService.getAuthUrl();
+        return { url, authenticated: false };
+    }),
+    user: protectedProcedure.query(async () => {
+        const user = await googleDriveService.getUserProfile();
+        return user;
+    }),
+    logout: protectedProcedure.mutation(async () => {
+        await googleDriveService.logout();
+        await updateEnvFile({ SYNC_PROVIDER: '' });
+        await initSyncProvider();
+        return { success: true };
+    }),
+});

package/server/dist/trpc/routers/continue-watching.js

@@ -0,0 +1,83 @@
+import { protectedProcedure, router } from '../index.js';
+import { performWriteTransactionAsync } from '../../sync.js';
+import { WatchedEpisodesRepository } from '../../repositories/watched-episodes.repository.js';
+import { NotificationsRepository } from '../../repositories/notifications.repository.js';
+import { getMigratedId } from '../../lib/migration.js';
+import { getAdultNonWatchlistShowIds } from '../../hono/watchlist.js';
+import { dbAll } from '../../utils/db-utils.js';
+import { idsInput, showIdInput } from '../validation.js';
+export const continueWatchingRouter = router({
+    remove: protectedProcedure.input(showIdInput()).mutation(async ({ ctx, input }) => {
+        const showId = await getMigratedId(ctx.db, input.showId);
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            await WatchedEpisodesRepository.deleteByShow(tx, showId);
+            await NotificationsRepository.deleteByShow(tx, showId);
+        });
+        return { success: true };
+    }),
+    removeMany: protectedProcedure.input(idsInput()).mutation(async ({ ctx, input }) => {
+        const ids = await Promise.all(input.ids.map((id) => getMigratedId(ctx.db, id)));
+        await performWriteTransactionAsync(ctx.db, async (tx) => {
+            for (const id of ids) {
+                await WatchedEpisodesRepository.deleteByShow(tx, id);
+                await NotificationsRepository.deleteByShow(tx, id);
+            }
+        });
+        ctx.db.scheduleSave();
+        return { success: true, removed: ids.length };
+    }),
+    adultCount: protectedProcedure.query(async ({ ctx }) => {
+        const ids = await getAdultNonWatchlistShowIds(ctx.db);
+        return { count: ids.length };
+    }),
+    purgeAdult: protectedProcedure.mutation(async ({ ctx }) => {
+        const ids = await getAdultNonWatchlistShowIds(ctx.db);
+        if (ids.length > 0) {
+            await performWriteTransactionAsync(ctx.db, async (tx) => {
+                for (const id of ids) {
+                    await WatchedEpisodesRepository.deleteByShow(tx, id);
+                    await NotificationsRepository.deleteByShow(tx, id);
+                }
+            });
+            ctx.db.scheduleSave();
+        }
+        return { success: true, removed: ids.length };
+    }),
+    thisWeek: protectedProcedure.query(async ({ ctx }) => {
+        const rows = await dbAll(ctx.db, `SELECT
+        w.id, w.name, w.thumbnail, w.nativeName, w.englishName, w.type,
+        dn.episodeNumber, dn.discoveredAt
+      FROM discovered_notifications dn
+      JOIN watchlist w ON dn.showId = w.id
+      WHERE w.status = 'Watching'
+        AND EXISTS (
+          SELECT 1 FROM discovered_notifications dn_recent
+          WHERE dn_recent.showId = dn.showId
+            AND dn_recent.discoveredAt >= datetime('now', '-7 days')
+        )
+        AND CAST(dn.episodeNumber AS INTEGER) = (
+          SELECT MIN(CAST(dn2.episodeNumber AS INTEGER))
+          FROM discovered_notifications dn2
+          WHERE dn2.showId = dn.showId
+            AND NOT EXISTS (
+              SELECT 1 FROM watched_episodes we2
+              WHERE we2.showId = dn2.showId AND we2.episodeNumber = dn2.episodeNumber
+            )
+        )
+        AND NOT EXISTS (
+          SELECT 1 FROM watched_episodes we
+          WHERE we.showId = dn.showId AND we.episodeNumber = dn.episodeNumber
+        )
+      ORDER BY CAST(dn.episodeNumber AS INTEGER) ASC`);
+        return rows.map((row) => ({
+            _id: row.id,
+            id: row.id,
+            name: row.name,
+            thumbnail: row.thumbnail || '',
+            nativeName: row.nativeName,
+            englishName: row.englishName,
+            type: row.type,
+            episodeNumber: parseInt(row.episodeNumber) || row.episodeNumber,
+        }));
+    }),
+});