@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/trpc/index.js

@@ -1,18 +0,0 @@
-import { initTRPC } from '@trpc/server';
-import { lanAuthRequiredError } from './errors.js';
-const t = initTRPC.context().create({
-    errorFormatter: ({ shape, error }) => ({
-        ...shape,
-        data: {
-            ...shape.data,
-            cause: error.cause ?? null,
-        },
-    }),
-});
-export const router = t.router;
-const lanGuard = t.middleware(({ ctx, next }) => {
-    if (!ctx.lanAuthed)
-        throw lanAuthRequiredError();
-    return next({ ctx });
-});
-export const protectedProcedure = t.procedure.use(lanGuard);

package/server/dist/trpc/router.js

@@ -1,49 +0,0 @@
-import { router } from './index.js';
-import { settingsRouter } from './routers/settings.js';
-import { queueRouter } from './routers/queue.js';
-import { watchlistRouter } from './routers/watchlist.js';
-import { progressRouter } from './routers/progress.js';
-import { notificationsRouter } from './routers/notifications.js';
-import { continueWatchingRouter } from './routers/continue-watching.js';
-import { discoveryRouter } from './routers/discovery.js';
-import { mangaLibraryRouter } from './routers/manga-library.js';
-import { mangaProgressRouter } from './routers/manga-progress.js';
-import { asmrLibraryRouter } from './routers/asmr-library.js';
-import { asmrProgressRouter } from './routers/asmr-progress.js';
-import { tvLibraryRouter } from './routers/tv-library.js';
-import { tvProgressRouter } from './routers/tv-progress.js';
-import { tvRouter } from './routers/tv.js';
-import { mangaRouter } from './routers/manga.js';
-import { asmrRouter } from './routers/asmr.js';
-import { musicRouter } from './routers/music.js';
-import { radioRouter } from './routers/radio.js';
-import { trackerRouter } from './routers/tracker.js';
-import { insightsRouter } from './routers/insights.js';
-import { authRouter } from './routers/auth.js';
-import { dataRouter } from './routers/data.js';
-import { discordRouter } from './routers/discord.js';
-export const appRouter = router({
-    settings: settingsRouter,
-    queue: queueRouter,
-    watchlist: watchlistRouter,
-    progress: progressRouter,
-    notifications: notificationsRouter,
-    continueWatching: continueWatchingRouter,
-    discovery: discoveryRouter,
-    mangaLibrary: mangaLibraryRouter,
-    mangaProgress: mangaProgressRouter,
-    asmrLibrary: asmrLibraryRouter,
-    asmrProgress: asmrProgressRouter,
-    tvLibrary: tvLibraryRouter,
-    tvProgress: tvProgressRouter,
-    tv: tvRouter,
-    manga: mangaRouter,
-    asmr: asmrRouter,
-    music: musicRouter,
-    radio: radioRouter,
-    tracker: trackerRouter,
-    insights: insightsRouter,
-    auth: authRouter,
-    data: dataRouter,
-    discord: discordRouter,
-});

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

@@ -1,112 +0,0 @@
-import { TRPCError } from '@trpc/server';
-import { protectedProcedure, router } from '../index.js';
-import { performAsmrWriteTransactionAsync } from '../../sync.js';
-import { buildAsmrId, ASMR_STATUSES, AsmrLibraryRepository, AsmrProgressRepository, } from '../../repositories/asmr.repository.js';
-import { defineSchema, reqObj, reqStr, optStr, reqStrArray, readPageLimit } from '../validation.js';
-const asmrLibraryListInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    const out = { ...readPageLimit(obj) };
-    const status = optStr(obj, 'status');
-    if (status !== undefined)
-        out.status = status;
-    return out;
-});
-const asmrLibraryIdInput = () => defineSchema((value) => ({
-    id: reqStr(reqObj(value), 'id'),
-}));
-const asmrLibraryAddInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return {
-        rjCode: optStr(obj, 'rjCode'),
-        id: optStr(obj, 'id'),
-        title: optStr(obj, 'title'),
-        thumbnail: optStr(obj, 'thumbnail'),
-        status: optStr(obj, 'status'),
-        isAdult: obj.isAdult,
-    };
-});
-const asmrLibraryStatusInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return { id: reqStr(obj, 'id'), status: reqStr(obj, 'status') };
-});
-const asmrLibraryBatchStatusInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return { ids: reqStrArray(obj, 'ids', true), status: reqStr(obj, 'status') };
-});
-const asmrLibraryIdsInput = () => defineSchema((value) => ({
-    ids: reqStrArray(reqObj(value), 'ids', true),
-}));
-export const asmrLibraryRouter = router({
-    list: protectedProcedure.input(asmrLibraryListInput()).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 AsmrLibraryRepository.getAll(ctx.asmrDb, input.status, limit, offset);
-        const total = await AsmrLibraryRepository.getCount(ctx.asmrDb, input.status);
-        return { data: rows, total, page, limit };
-    }),
-    ids: protectedProcedure.query(async ({ ctx }) => {
-        return { ids: await AsmrLibraryRepository.getIds(ctx.asmrDb) };
-    }),
-    check: protectedProcedure.input(asmrLibraryIdInput()).query(async ({ ctx, input }) => {
-        const item = await AsmrLibraryRepository.getById(ctx.asmrDb, input.id);
-        return { inLibrary: !!item, status: item?.status ?? null };
-    }),
-    add: protectedProcedure.input(asmrLibraryAddInput()).mutation(async ({ ctx, input }) => {
-        const rawCode = String(input.rjCode || input.id || '').trim();
-        if (!rawCode) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'rjCode is required' });
-        }
-        const id = input.id && input.id.trim() ? buildAsmrId(input.id) : buildAsmrId(rawCode);
-        const cleanStatus = typeof input.status === 'string' && ASMR_STATUSES.includes(input.status)
-            ? input.status
-            : 'Listening';
-        await performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
-            await AsmrLibraryRepository.upsert(tx, {
-                id,
-                rjCode: buildAsmrId(rawCode),
-                title: String(input.title || ''),
-                thumbnail: String(input.thumbnail || ''),
-                status: cleanStatus,
-                isAdult: input.isAdult === true || input.isAdult === 1,
-            });
-        });
-        return { success: true, id };
-    }),
-    remove: protectedProcedure.input(asmrLibraryIdInput()).mutation(async ({ ctx, input }) => {
-        await performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
-            await AsmrLibraryRepository.delete(tx, String(input.id));
-            await AsmrProgressRepository.deleteByWork(tx, String(input.id));
-        });
-        return { success: true };
-    }),
-    setStatus: protectedProcedure.input(asmrLibraryStatusInput()).mutation(async ({ ctx, input }) => {
-        if (!input.id || !ASMR_STATUSES.includes(input.status)) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'id and a valid status are required' });
-        }
-        await performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
-            await AsmrLibraryRepository.updateStatus(tx, String(input.id), String(input.status));
-        });
-        return { success: true };
-    }),
-    batchStatus: protectedProcedure
-        .input(asmrLibraryBatchStatusInput())
-        .mutation(async ({ ctx, input }) => {
-        if (!input.status || !ASMR_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 performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
-            await AsmrLibraryRepository.updateStatusMany(tx, ids, String(input.status));
-        });
-        return { success: true, updated: ids.length };
-    }),
-    removeMany: protectedProcedure.input(asmrLibraryIdsInput()).mutation(async ({ ctx, input }) => {
-        const ids = input.ids.map((id) => String(id));
-        await performAsmrWriteTransactionAsync(ctx.asmrDb, async (tx) => {
-            await AsmrLibraryRepository.deleteMany(tx, ids);
-            await AsmrProgressRepository.deleteMany(tx, ids);
-        });
-        return { success: true, removed: ids.length };
-    }),
-});

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

@@ -1,121 +0,0 @@
-import { protectedProcedure, router } from '../index.js';
-import { performAsmrWriteTransactionAsync } from '../../sync.js';
-import { adultNonListIds } 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, strOrNull } from '../validation.js';
-const getAdultNonListWorkIds = (db) => adultNonListIds(db, 'asmr_progress', 'asmr_library', 'workId', 'COALESCE(l.isAdult, p.isAdult) = 1');
-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: strOrNull(obj, 'title'),
-        thumbnail: strOrNull(obj, 'thumbnail'),
-        rjCode: strOrNull(obj, 'rjCode'),
-        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 { ignoreAdult, listOnly } = await SettingsRepository.readContinueFlags(ctx.db, 'asmrIgnoreAdultContent', 'asmrCwWatchlistOnly');
-        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

@@ -1,87 +0,0 @@
-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

@@ -1,194 +0,0 @@
-import logger from '../../logger.js';
-import { TRPCError } from '@trpc/server';
-import { googleDriveService } from '../../google.js';
-import { githubSyncService } from '../../github-sync.js';
-import { initSyncProvider, getActiveProvider, runFullSyncSequence } 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 remoteFolder = CONFIG.IS_DEV ? CONFIG.REMOTE_FOLDER_DEV : CONFIG.REMOTE_FOLDER_PROD;
-    await runFullSyncSequence({ db: database, mangaDb: ctx.mangaDb, tvDb: ctx.tvDb, asmrDb: ctx.asmrDb }, { remoteFolder, preferredProvider });
-}
-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,
-}));
-const serverPortInput = () => defineSchema((value) => ({
-    port: reqObj(value).port,
-}));
-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 };
-    }),
-    setServerPort: protectedProcedure.input(serverPortInput()).mutation(async ({ input }) => {
-        const port = Number(input.port);
-        if (!Number.isInteger(port) || port < 1 || port > 65535) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: 'Port must be an integer between 1 and 65535',
-            });
-        }
-        await updateEnvFile({ PORT: String(port) });
-        logger.info({ port }, 'Server port saved. Restart required to apply.');
-        return { success: true, port };
-    }),
-    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

@@ -1,81 +0,0 @@
-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);
-            }
-        });
-        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);
-                }
-            });
-        }
-        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,
-        }));
-    }),
-});