@serifpersia/dango 3.6.7 → 3.6.8

package/server/dist/trpc/context.js

@@ -1,7 +1 @@
-import { getTokenFromHeaders, hasAppPassword, validateLanSession } from '../app-auth.js';
-export function buildTrpcContext(deps, authorization, cookie) {
-    return {
-        ...deps,
-        lanAuthed: !hasAppPassword() || validateLanSession(getTokenFromHeaders(authorization, cookie)),
-    };
-}
+import{getTokenFromHeaders as t,hasAppPassword as o,validateLanSession as p}from"../app-auth.js";function n(e,r,a){return{...e,lanAuthed:!o()||p(t(r,a))}}export{n as buildTrpcContext};

package/server/dist/trpc/errors.js

@@ -1,15 +1 @@
-import { TRPCError } from '@trpc/server';
-export function authRequiredError(provider) {
-    return new TRPCError({
-        code: 'FORBIDDEN',
-        message: 'AUTH_REQUIRED',
-        cause: { code: 'AUTH_REQUIRED', provider },
-    });
-}
-export function lanAuthRequiredError() {
-    return new TRPCError({
-        code: 'UNAUTHORIZED',
-        message: 'LAN_AUTH_REQUIRED',
-        cause: { code: 'LAN_AUTH_REQUIRED' },
-    });
-}
+import{TRPCError as r}from"@trpc/server";function E(e){return new r({code:"FORBIDDEN",message:"AUTH_REQUIRED",cause:{code:"AUTH_REQUIRED",provider:e}})}function R(){return new r({code:"UNAUTHORIZED",message:"LAN_AUTH_REQUIRED",cause:{code:"LAN_AUTH_REQUIRED"}})}export{E as authRequiredError,R as lanAuthRequiredError};

package/server/dist/trpc/index.js

@@ -1,18 +1 @@
-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);
+import{initTRPC as o}from"@trpc/server";import{lanAuthRequiredError as n}from"./errors.js";const e=o.context().create({errorFormatter:({shape:r,error:t})=>({...r,data:{...r.data,cause:t.cause??null}})}),d=e.router,c=e.middleware(({ctx:r,next:t})=>{if(!r.lanAuthed)throw n();return t({ctx:r})}),p=e.procedure.use(c);export{p as protectedProcedure,d as router};

package/server/dist/trpc/router.js

@@ -1,49 +1 @@
-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,
-});
+import{router as r}from"./index.js";import{settingsRouter as o}from"./routers/settings.js";import{queueRouter as t}from"./routers/queue.js";import{watchlistRouter as m}from"./routers/watchlist.js";import{progressRouter as i}from"./routers/progress.js";import{notificationsRouter as e}from"./routers/notifications.js";import{continueWatchingRouter as a}from"./routers/continue-watching.js";import{discoveryRouter as s}from"./routers/discovery.js";import{mangaLibraryRouter as u}from"./routers/manga-library.js";import{mangaProgressRouter as p}from"./routers/manga-progress.js";import{asmrLibraryRouter as f}from"./routers/asmr-library.js";import{asmrProgressRouter as R}from"./routers/asmr-progress.js";import{tvLibraryRouter as n}from"./routers/tv-library.js";import{tvProgressRouter as g}from"./routers/tv-progress.js";import{tvRouter as c}from"./routers/tv.js";import{mangaRouter as d}from"./routers/manga.js";import{asmrRouter as y}from"./routers/asmr.js";import{musicRouter as h}from"./routers/music.js";import{radioRouter as v}from"./routers/radio.js";import{trackerRouter as b}from"./routers/tracker.js";import{insightsRouter as L}from"./routers/insights.js";import{authRouter as P}from"./routers/auth.js";import{dataRouter as k}from"./routers/data.js";import{discordRouter as l}from"./routers/discord.js";const V=r({settings:o,queue:t,watchlist:m,progress:i,notifications:e,continueWatching:a,discovery:s,mangaLibrary:u,mangaProgress:p,asmrLibrary:f,asmrProgress:R,tvLibrary:n,tvProgress:g,tv:c,manga:d,asmr:y,music:h,radio:v,tracker:b,insights:L,auth:P,data:k,discord:l});export{V as appRouter};

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

@@ -1,112 +1 @@
-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 };
-    }),
-});
+import{TRPCError as b}from"@trpc/server";import{protectedProcedure as e,router as L}from"../index.js";import{performAsmrWriteTransactionAsync as o}from"../../sync.js";import{buildAsmrId as p,ASMR_STATUSES as A,AsmrLibraryRepository as i,AsmrProgressRepository as g}from"../../repositories/asmr.repository.js";import{defineSchema as n,reqObj as u,reqStr as m,optStr as d,reqStrArray as l,readPageLimit as w}from"../validation.js";const h=()=>n(r=>{const t=u(r),s={...w(t)},a=d(t,"status");return a!==void 0&&(s.status=a),s}),I=()=>n(r=>({id:m(u(r),"id")})),f=()=>n(r=>{const t=u(r);return{rjCode:d(t,"rjCode"),id:d(t,"id"),title:d(t,"title"),thumbnail:d(t,"thumbnail"),status:d(t,"status"),isAdult:t.isAdult}}),D=()=>n(r=>{const t=u(r);return{id:m(t,"id"),status:m(t,"status")}}),j=()=>n(r=>{const t=u(r);return{ids:l(t,"ids",!0),status:m(t,"status")}}),q=()=>n(r=>({ids:l(u(r),"ids",!0)})),T=L({list:e.input(h()).query(async({ctx:r,input:t})=>{const s=Math.max(parseInt(String(t.page??1))||1,1),a=Math.min(Math.max(parseInt(String(t.limit??24))||24,1),100),c=(s-1)*a,y=await i.getAll(r.asmrDb,t.status,a,c),S=await i.getCount(r.asmrDb,t.status);return{data:y,total:S,page:s,limit:a}}),ids:e.query(async({ctx:r})=>({ids:await i.getIds(r.asmrDb)})),check:e.input(I()).query(async({ctx:r,input:t})=>{const s=await i.getById(r.asmrDb,t.id);return{inLibrary:!!s,status:s?.status??null}}),add:e.input(f()).mutation(async({ctx:r,input:t})=>{const s=String(t.rjCode||t.id||"").trim();if(!s)throw new b({code:"BAD_REQUEST",message:"rjCode is required"});const a=t.id&&t.id.trim()?p(t.id):p(s),c=typeof t.status=="string"&&A.includes(t.status)?t.status:"Listening";return await o(r.asmrDb,async y=>{await i.upsert(y,{id:a,rjCode:p(s),title:String(t.title||""),thumbnail:String(t.thumbnail||""),status:c,isAdult:t.isAdult===!0||t.isAdult===1})}),{success:!0,id:a}}),remove:e.input(I()).mutation(async({ctx:r,input:t})=>(await o(r.asmrDb,async s=>{await i.delete(s,String(t.id)),await g.deleteByWork(s,String(t.id))}),{success:!0})),setStatus:e.input(D()).mutation(async({ctx:r,input:t})=>{if(!t.id||!A.includes(t.status))throw new b({code:"BAD_REQUEST",message:"id and a valid status are required"});return await o(r.asmrDb,async s=>{await i.updateStatus(s,String(t.id),String(t.status))}),{success:!0}}),batchStatus:e.input(j()).mutation(async({ctx:r,input:t})=>{if(!t.status||!A.includes(t.status))throw new b({code:"BAD_REQUEST",message:"a valid status is required"});const s=t.ids.map(a=>String(a));return await o(r.asmrDb,async a=>{await i.updateStatusMany(a,s,String(t.status))}),{success:!0,updated:s.length}}),removeMany:e.input(q()).mutation(async({ctx:r,input:t})=>{const s=t.ids.map(a=>String(a));return await o(r.asmrDb,async a=>{await i.deleteMany(a,s),await g.deleteMany(a,s)}),{success:!0,removed:s.length}})});export{T as asmrLibraryRouter};

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

@@ -1,121 +1 @@
-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 };
-    }),
-});
+import{protectedProcedure as s,router as p}from"../index.js";import{performAsmrWriteTransactionAsync as m}from"../../sync.js";import{adultNonListIds as w}from"../../utils/db-utils.js";import{SettingsRepository as b}from"../../repositories/settings.repository.js";import{AsmrLibraryRepository as y,AsmrProgressRepository as o}from"../../repositories/asmr.repository.js";import{defineSchema as i,reqObj as u,reqStr as l,reqStrArray as A,strOrNull as c}from"../validation.js";const I=t=>w(t,"asmr_progress","asmr_library","workId","COALESCE(l.isAdult, p.isAdult) = 1"),f=()=>i(t=>({ids:A(u(t),"ids",!0)})),k=()=>i(t=>({workId:l(u(t),"workId")})),h=()=>i(t=>{const r=u(t);return{workId:l(r,"workId"),trackIndex:r.trackIndex,trackLabel:r.trackLabel,currentTime:r.currentTime,duration:r.duration,title:c(r,"title"),thumbnail:c(r,"thumbnail"),rjCode:c(r,"rjCode"),isAdult:r.isAdult??null}}),L=()=>i(t=>{const r=u(t);return{workId:l(r,"workId"),trackIndex:r.trackIndex??void 0}}),P=()=>i(t=>{const r=u(t),e={};if(r.limit!==void 0&&r.limit!==null&&r.limit!==""){const n=Number(r.limit);Number.isFinite(n)&&(e.limit=n)}return e}),D=p({getByWork:s.input(k()).query(async({ctx:t,input:r})=>({progress:await o.getByWork(t.asmrDb,r.workId)})),latest:s.input(k()).query(async({ctx:t,input:r})=>await o.getLatest(t.asmrDb,r.workId)||{currentTime:0,duration:0}),save:s.input(h()).mutation(async({ctx:t,input:r})=>{const e=Math.max(Math.round(Number(r.trackIndex))||0,0),n=Math.max(Number(r.currentTime)||0,0),d=Math.max(Number(r.duration)||0,0);return await m(t.asmrDb,async a=>{await o.upsert(a,{workId:String(r.workId),trackIndex:e,trackLabel:String(r.trackLabel||""),currentTime:n,duration:d,title:r.title??null,thumbnail:r.thumbnail??null,rjCode:r.rjCode??null,isAdult:r.isAdult!=null?Number(r.isAdult):null}),await y.touchProgress(a,String(r.workId),{trackIndex:e,trackLabel:String(r.trackLabel||""),position:n})}),{success:!0}}),remove:s.input(L()).mutation(async({ctx:t,input:r})=>(await m(t.asmrDb,async e=>{r.trackIndex!==void 0&&r.trackIndex!==null?await o.deleteTrack(e,String(r.workId),Number(r.trackIndex)):await o.deleteByWork(e,String(r.workId))}),{success:!0})),removeMany:s.input(f()).mutation(async({ctx:t,input:r})=>{const e=r.ids.map(n=>String(n));return await m(t.asmrDb,async n=>{await o.deleteMany(n,e)}),{success:!0,removed:e.length}}),continueListening:s.input(P()).query(async({ctx:t,input:r})=>{const e=Math.min(Math.max(parseInt(String(r.limit??24))||24,1),100),{ignoreAdult:n,listOnly:d}=await b.readContinueFlags(t.db,"asmrIgnoreAdultContent","asmrCwWatchlistOnly"),a=(await o.getContinueListening(t.asmrDb,e)).filter(g=>!(n&&g.isAdult===1||d&&g.watchlistStatus!=="Listening"));return{data:a,total:a.length}}),adultCount:s.query(async({ctx:t})=>({count:(await I(t.asmrDb)).length})),purgeAdult:s.mutation(async({ctx:t})=>{const r=await I(t.asmrDb);return r.length>0&&await m(t.asmrDb,async e=>{for(const n of r)await o.deleteByWork(e,n)}),{success:!0,removed:r.length}})});export{D as asmrProgressRouter};

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

@@ -1,87 +1 @@
-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: [] };
-            }
-        });
-    }),
-});
+import{protectedProcedure as c,router as h}from"../index.js";import{defineSchema as p,optStr as i,reqObj as m,reqStr as j}from"../validation.js";import{authRequiredError as u}from"../errors.js";import d from"../../logger.js";async function g(s,e,r,t){const o=s.apiCache.get(e);if(o)return o;const n=await t();return r!==void 0?s.apiCache.set(e,n,r):s.apiCache.set(e,n),n}const I=()=>p(s=>{if(s==null)return{};const e=m(s),r={},t=i(e,"q");t!==void 0&&(r.q=t),e.page!==void 0&&(r.page=parseInt(String(e.page),10)||1);const o=i(e,"sort");o!==void 0&&(r.sort=o);const n=i(e,"rating");return n!==void 0&&(r.rating=n),r}),q=()=>p(s=>({rj:j(m(s),"rj")})),k=h({browse:c.input(I()).query(async({ctx:s,input:e})=>{const r=e.q||"",t=e.page||1,o=e.sort||"",n=e.rating||"";return g(s,`route-asmr-browse-${r}-${t}-${o}-${n}-${o==="random"?Date.now():""}`,300,async()=>{try{const a=s.getJasmr();return a?await a.browse({query:r,page:t,sort:o,rating:n}):{shows:[],hasNext:!1}}catch(a){if(a.message==="AUTH_REQUIRED")throw u("jasmr");return d.error({err:a},"[Asmr] browse failed"),{shows:[],hasNext:!1}}})}),work:c.input(q()).query(async({ctx:s,input:e})=>{const r=e.rj;return g(s,`route-asmr-work-${r}`,1800,async()=>{try{const t=s.getJasmr();if(!t)return{rjCode:r,description:"",tracks:[],images:[],chapters:[]};const o=String(r).trim().toUpperCase(),n=await t.getEpisodes(o),[a,f,w]=await Promise.all([t.getStreamUrls(o,"1"),t.getImages(o),t.getChapters(o)]);return{rjCode:o,description:n?.description||"",tracks:a?.[0]?.links||[],images:f,chapters:w}}catch(t){if(t.message==="AUTH_REQUIRED")throw u("jasmr");return d.error({err:t,rj:r},"[Asmr] work fetch failed"),{rjCode:r,description:"",tracks:[],images:[],chapters:[]}}})})});export{k as asmrRouter};

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

@@ -1,194 +1 @@
-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 };
-    }),
-});
+import p from"../../logger.js";import{TRPCError as _}from"@trpc/server";import{googleDriveService as s}from"../../google.js";import{githubSyncService as u}from"../../github-sync.js";import{initSyncProvider as E,getActiveProvider as v,runFullSyncSequence as I}from"../../sync.js";import{CONFIG as o}from"../../config.js";import{rcloneService as d}from"../../rclone.js";import{updateEnvFile as a}from"../../utils/env.utils.js";import{protectedProcedure as r,router as O}from"../index.js";import{defineSchema as c,reqObj as l}from"../validation.js";async function m(e,t,n){const i=o.IS_DEV?o.REMOTE_FOLDER_DEV:o.REMOTE_FOLDER_PROD;await I({db:t,mangaDb:e.mangaDb,tvDb:e.tvDb,asmrDb:e.asmrDb},{remoteFolder:i,preferredProvider:n})}const R=()=>c(e=>{const t=l(e);return{clientId:t.clientId,clientSecret:t.clientSecret,workerUrl:t.workerUrl}}),y=()=>c(e=>{const t=l(e);if(typeof t.clientId!="string")throw new Error("clientId required");return{clientId:t.clientId}}),w=()=>c(e=>({provider:l(e).provider})),f=()=>c(e=>({remote:l(e).remote})),C=()=>c(e=>({port:l(e).port})),A=O({configStatus:r.query(async()=>{const e=!!o.GOOGLE_AUTH_WORKER_URL,t=!!process.env.GOOGLE_CLIENT_ID&&!!process.env.GOOGLE_CLIENT_SECRET;return{hasConfig:e||t,useWorker:e}}),googleAuth:r.query(async()=>({useWorker:!!o.GOOGLE_AUTH_WORKER_URL,hasCustomWorkerUrl:!!process.env.GOOGLE_AUTH_WORKER_URL,hasCustomClientId:!!process.env.GOOGLE_CLIENT_ID,hasClientSecret:!!process.env.GOOGLE_CLIENT_SECRET})),saveGoogleAuth:r.input(R()).mutation(async({input:e})=>{const{clientId:t,clientSecret:n,workerUrl:i}=e,g={};return typeof t=="string"&&(g.GOOGLE_CLIENT_ID=t),typeof n=="string"&&(g.GOOGLE_CLIENT_SECRET=n),typeof i=="string"&&(g.GOOGLE_AUTH_WORKER_URL=i),await a(g),typeof i=="string"&&(o.GOOGLE_AUTH_WORKER_URL=i),typeof t=="string"&&(o.GOOGLE_CLIENT_ID=t||void 0),typeof n=="string"&&(o.GOOGLE_CLIENT_SECRET=n||void 0),await E(),{success:!0}}),githubAuth:r.query(async()=>({hasCustomClientId:!!process.env.GITHUB_CLIENT_ID})),saveGithubAuth:r.input(y()).mutation(async({input:e})=>(await a({GITHUB_CLIENT_ID:e.clientId}),{success:!0})),rcloneSettings:r.query(async()=>{const e=await d.listRemotes();return{remote:o.RCLONE_REMOTE||"",availableRemotes:e,activeRemote:d.isActive()?d.getRemoteName():null}}),syncSettings:r.query(async()=>({activeProvider:process.env.SYNC_PROVIDER||"default",actualActiveProvider:v(),authenticatedProviders:{github:u.isAuthenticated(),google:s.isAuthenticated(),rclone:d.isActive()}})),saveSyncProvider:r.input(w()).mutation(async({input:e})=>{const{provider:t}=e;return await a({SYNC_PROVIDER:t==="default"?"":t}),await E(),{success:!0,activeProvider:process.env.SYNC_PROVIDER||"default"}}),githubStatus:r.query(async()=>{try{const e=await u.getUserProfile();return{authenticated:!!e,user:e,device:u.getDeviceState(),hasCustomClientId:!!process.env.GITHUB_CLIENT_ID}}catch(e){return p.error({err:e},"Failed to fetch GitHub auth status"),{authenticated:!1,user:null,device:u.getDeviceState(),hasCustomClientId:!!process.env.GITHUB_CLIENT_ID}}}),githubStart:r.mutation(async({ctx:e})=>await u.startDeviceAuth(e.db,(n,i)=>m(e,n,i))),githubPoll:r.query(async()=>u.getDeviceState()),githubLogout:r.mutation(async()=>(await u.logout(),await a({SYNC_PROVIDER:""}),await E(),{success:!0})),saveRclone:r.input(f()).mutation(async({ctx:e,input:t})=>{const{remote:n}=t;return await a({RCLONE_REMOTE:n,SYNC_PROVIDER:"rclone"}),await m(e,e.db,"rclone"),{success:!0}}),setServerPort:r.input(C()).mutation(async({input:e})=>{const t=Number(e.port);if(!Number.isInteger(t)||t<1||t>65535)throw new _({code:"BAD_REQUEST",message:"Port must be an integer between 1 and 65535"});return await a({PORT:String(t)}),p.info({port:t},"Server port saved. Restart required to apply."),{success:!0,port:t}}),googleAuthUrl:r.query(async()=>({url:await s.getAuthUrl()})),googleLogin:r.mutation(async({ctx:e})=>{if(s.isAuthenticated()){if(await s.getUserProfile())return await a({SYNC_PROVIDER:"google"}),await m(e,e.db,"google"),{url:null,authenticated:!0};p.warn("Google tokens found but invalid. Clearing and requesting new auth."),await s.logout()}return{url:await s.getAuthUrl(),authenticated:!1}}),user:r.query(async()=>await s.getUserProfile()),logout:r.mutation(async()=>(await s.logout(),await a({SYNC_PROVIDER:""}),await E(),{success:!0}))});export{A as authRouter};