@serifpersia/dango 3.3.8 → 3.4.0

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

@@ -0,0 +1,145 @@
+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 } from '../validation.js';
+function normalizeMediaType(raw) {
+    return String(raw).toLowerCase() === 'movie' ? 'movie' : 'tv';
+}
+const tvLibraryListInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    const status = optStr(obj, 'status');
+    if (status !== undefined)
+        out.status = status;
+    if (obj.page !== undefined && obj.page !== null && obj.page !== '') {
+        const page = Number(obj.page);
+        if (Number.isFinite(page))
+            out.page = page;
+    }
+    if (obj.limit !== undefined && obj.limit !== null && obj.limit !== '') {
+        const limit = Number(obj.limit);
+        if (Number.isFinite(limit))
+            out.limit = limit;
+    }
+    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

@@ -0,0 +1,171 @@
+import { TRPCError } from '@trpc/server';
+import { protectedProcedure, router } from '../index.js';
+import { performTvWriteTransactionAsync } from '../../sync.js';
+import { dbAll } 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 } from '../validation.js';
+const isTvContinueAdult = (row) => row.adult === true || row.adult === 1;
+async function getAdultNonListMediaIds(db) {
+    const rows = await dbAll(db, `SELECT DISTINCT p.mediaId as mediaId
+       FROM tv_progress p
+       LEFT JOIN tv_library l ON l.id = p.mediaId
+       WHERE COALESCE(l.adult, p.adult) = 1
+         AND l.id IS NULL`);
+    return rows.map((r) => r.mediaId);
+}
+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: obj.title ?? null,
+        poster: obj.poster ?? null,
+        backdrop: obj.backdrop ?? null,
+        year: obj.year ?? null,
+        overview: obj.overview ?? null,
+        tmdbId: obj.tmdbId ?? null,
+        mediaType: obj.mediaType ?? null,
+        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 ignoreAdultRow = await SettingsRepository.getByKey(ctx.db, 'tvIgnoreAdultContent');
+        const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
+        const listOnlyRow = await SettingsRepository.getByKey(ctx.db, 'tvCwWatchlistOnly');
+        const listOnly = listOnlyRow
+            ? listOnlyRow.value === 'true' || listOnlyRow.value === '1'
+            : false;
+        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 };
+    }),
+});