@serifpersia/dango 3.3.9 → 3.4.1

package/server/dist/server.js

@@ -1,74 +1,45 @@
 process.setMaxListeners(100);
 import { EventEmitter } from 'events';
 EventEmitter.defaultMaxListeners = 100;
-import express from 'express';
 import path from 'path';
-import cors from 'cors';
-import compression from 'compression';
 import { AppCache } from './utils/cache.utils.js';
 import fs from 'fs';
 import crypto from 'crypto';
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { getConnInfo } from '@hono/node-server/conninfo';
 import logger from './logger.js';
 import { notifyServerExit } from './lib/ipc.js';
-import { crossSiteProtectionMiddleware, isAllowedOrigin } from './utils/security.utils.js';
-import { requestLogger } from './request-logger.js';
 import { githubSyncService } from './github-sync.js';
 import { CONFIG } from './config.js';
 import { initializeDatabase, initializeMangaDatabase, initializeTvDatabase, initializeAsmrDatabase, syncDownOnBoot, syncUp, mangaSyncDownOnBoot, mangaSyncUp, tvSyncDownOnBoot, tvSyncUp, asmrSyncDownOnBoot, asmrSyncUp, initSyncProvider, waitForSync, getActiveProvider, } from './sync.js';
-import { createAuthRouter } from './routes/auth.routes.js';
-import { createLanAuthRouter } from './routes/lan-auth.routes.js';
-import { lanAuthMiddleware } from './app-auth.js';
-import { createWatchlistRouter } from './routes/watchlist.routes.js';
-import { createDataRouter } from './routes/data.routes.js';
-import { createAsmrRouter } from './routes/asmr.routes.js';
-import { createAsmrLibraryRouter } from './routes/asmr-library.routes.js';
-import { createMangaRouter } from './routes/manga.routes.js';
-import { createMangaLibraryRouter } from './routes/manga-library.routes.js';
-import { createRadioRouter } from './routes/radio.routes.js';
-import { createMusicRouter } from './routes/music.routes.js';
-import { createTvRouter } from './routes/tv.routes.js';
-import { createTvLibraryRouter } from './routes/tv-library.routes.js';
-import { createProxyRouter } from './routes/proxy.routes.js';
-import { createProvidersRouter } from './routes/providers.routes.js';
 import { loadRemoteProviders } from './providers/remote-loader.js';
-import { createSettingsRouter } from './routes/settings.routes.js';
-import { createInsightsRouter } from './routes/insights.routes.js';
-import { createTranslateRouter } from './routes/translate.routes.js';
-import { createDiscordGatewayRouter } from './routes/discord-gateway.routes.js';
-import { createTrackerRouter } from './routes/tracker.routes.js';
 import { discordRPCService } from './discord-rpc.js';
 import { discordGatewayService } from './discord-gateway.js';
 import { SettingsRepository } from './repositories/settings.repository.js';
-import { requestContext } from './utils/request-context.js';
+import { createHonoApp } from './app-hono.js';
+import { startWatchlistDiscovery, stopWatchlistDiscovery } from './hono/watchlist.js';
 import { checkAnilistStatus } from './lib/anilist.js';
 import { offlineDb } from './lib/offline-db.js';
 import { initDiscordRolesSync } from './lib/discord-roles-sync.service.js';
-const app = express();
-app.use(requestLogger);
-app.get('/api/health', (_req, res) => {
-    if (isShuttingDown) {
-        return res.status(503).json({ status: 'shutting-down', ready: false });
-    }
-    if (!db) {
-        return res.status(503).json({ status: 'starting', ready: false });
-    }
-    res.json({ status: 'ok', ready: true });
-});
-app.use((req, res, next) => {
-    const store = new Map();
-    if (req.headers['x-animepahe-ua']) {
-        store.set('ua', req.headers['x-animepahe-ua']);
-    }
-    if (req.headers['x-animepahe-cookie']) {
-        store.set('cookie', req.headers['x-animepahe-cookie']);
-    }
-    if (req.headers['x-jasmr-ua']) {
-        store.set('jasmr_ua', req.headers['x-jasmr-ua']);
-    }
-    if (req.headers['x-jasmr-cookie']) {
-        store.set('jasmr_cookie', req.headers['x-jasmr-cookie']);
-    }
-    requestContext.run(store, next);
+const app = createHonoApp(() => ({ shuttingDown: isShuttingDown, dbReady: !!db }), () => ({
+    shuttingDown: isShuttingDown,
+    dbsReady: !!db && !!mangaDb && !!tvDb && !!asmrDb,
+    bootSyncing,
+}), () => ({ db, mangaDb, tvDb, asmrDb }), {
+    initializeDatabase,
+    setDb: (newDb) => {
+        db = newDb;
+    },
+}, {
+    getCatalog: getProviderCatalog,
+    refresh: refreshRemoteProviders,
+}, runSyncSequence, {
+    getApiCache: () => apiCache,
+    getProviders: () => providers,
+    getMangaProvider: (name) => mangaProviders[name],
+    getTvProvider: (name) => tvProviders[name],
+    getJasmr: () => providers['jasmr'],
 });
 const apiCache = new AppCache({ ttlSeconds: 3600, maxKeys: 5000 });
 const providers = {};
@@ -203,95 +174,24 @@ async function runSyncSequence(database, mangaDatabase, preferredProvider) {
         logger.error({ err }, 'ASMR sync up on boot failed');
     }
 }
-app.use((req, res, next) => {
-    if (isShuttingDown) {
-        return res.status(503).send('Server is shutting down...');
-    }
-    if (!db || !mangaDb || !tvDb || !asmrDb) {
-        return res.status(503).send('Database initializing...');
-    }
-    if (bootSyncing && req.method !== 'GET' && req.method !== 'HEAD' && req.method !== 'OPTIONS') {
-        return res.status(503).send('Sync in progress...');
-    }
-    req.db = db;
-    req.mangaDb = mangaDb;
-    req.tvDb = tvDb;
-    req.asmrDb = asmrDb;
-    next();
-});
-app.use(compression({
-    level: 2,
-    threshold: 1024,
-    filter: (req, res) => {
-        if (req.headers['x-no-compression']) {
-            return false;
-        }
-        return compression.filter(req, res);
-    },
-}));
-app.use(cors({
-    origin: (origin, callback) => {
-        callback(null, isAllowedOrigin(origin));
-    },
-    credentials: true,
-}));
-app.use(crossSiteProtectionMiddleware);
-app.use(express.json({ limit: '10mb' }));
-app.use('/api/auth', createLanAuthRouter());
-app.use(lanAuthMiddleware);
-app.use('/api/auth', createAuthRouter((database, mangaDatabase, preferred) => runSyncSequence(database, mangaDatabase, preferred)));
-const { router: watchlistRouter, stopDiscovery } = createWatchlistRouter(() => db);
-app.use('/api', watchlistRouter);
-app.use('/api', createDataRouter(apiCache, providers, getProviderCatalog));
-app.use('/api', createAsmrRouter(apiCache, () => providers['jasmr']));
-app.use('/api', createAsmrLibraryRouter());
-app.use('/api', createMangaRouter(apiCache, (name) => mangaProviders[name]));
-app.use('/api', createMangaLibraryRouter());
-app.use('/api', createRadioRouter(apiCache));
-app.use('/api', createMusicRouter(apiCache));
-app.use('/api', createTvRouter(apiCache, (name) => tvProviders[name]));
-app.use('/api', createTvLibraryRouter());
-app.use('/api', createProxyRouter());
-app.use('/api', createProvidersRouter(getProviderCatalog, refreshRemoteProviders));
-app.use('/api', createInsightsRouter());
-app.use('/api', createTranslateRouter());
-app.use('/api', createDiscordGatewayRouter());
-app.use('/api', createTrackerRouter());
-app.use('/api', createSettingsRouter(() => db, initializeDatabase, (newDb) => {
-    db = newDb;
-}));
+startWatchlistDiscovery(() => db);
 if (!CONFIG.IS_DEV) {
     const frontendPath = path.join(CONFIG.PACKAGE_ROOT, 'client', 'dist');
     logger.info(`Serving frontend from: ${frontendPath}`);
-    app.use(express.static(frontendPath));
-    app.get(/^(?!\/api).+/, (req, res) => {
-        res.sendFile('index.html', { root: frontendPath }, (err) => {
-            if (err) {
-                logger.error({ err }, `Failed to serve index.html from ${frontendPath}`);
-                if (!res.headersSent) {
-                    res.status(500).send('Server Error: Frontend build not found.');
-                }
-            }
-        });
-    });
-}
-app.use((err, req, res, next) => {
-    if (err instanceof SyntaxError &&
-        'body' in err &&
-        req.headers['content-type']?.includes('application/json')) {
-        if (!res.headersSent) {
-            return res.status(400).json({ error: 'Invalid JSON', status: 400 });
+    app.use('/*', serveStatic({ root: frontendPath }));
+    app.get('*', async (c) => {
+        if (c.req.path.startsWith('/api/'))
+            return c.notFound();
+        try {
+            const html = await fs.promises.readFile(path.join(frontendPath, 'index.html'), 'utf8');
+            return c.html(html);
+        }
+        catch (err) {
+            logger.error({ err }, `Failed to serve index.html from ${frontendPath}`);
+            return c.text('Server Error: Frontend build not found.', 500);
         }
-    }
-    logger.error({ err, url: req.url, method: req.method }, 'Unhandled error');
-    if (res.headersSent) {
-        return next(err);
-    }
-    res.status(err.status || 500).json({
-        error: err.message || 'Internal Server Error',
-        status: err.status || 500,
     });
-});
+}
 async function main() {
     const dbName = CONFIG.IS_DEV ? CONFIG.DB_NAME_DEV : CONFIG.DB_NAME_PROD;
     const dbPath = path.join(CONFIG.ROOT, dbName);
@@ -311,7 +211,7 @@ async function main() {
     asmrDb = await initializeAsmrDatabase(asmrDbPath);
     logger.info(`ASMR database initialized at ${asmrDbPath}`);
     await offlineDb.init(db);
-    if (offlineDb.checkWeeklyUpdateDue(db)) {
+    if (await offlineDb.checkWeeklyUpdateDue(db)) {
         logger.info('Weekly offline database update is due on startup, starting background update...');
         offlineDb.executeScheduledUpdate(db).catch((err) => {
             logger.warn({ err: err?.message }, 'Startup scheduled offline database update failed');
@@ -364,7 +264,7 @@ async function main() {
             hasAsmrUnsyncedChanges = true;
         }
     });
-    const expressServer = app.listen(CONFIG.PORT, () => {
+    const server = serve({ fetch: app.fetch, port: CONFIG.PORT }, () => {
         logger.info(`Server running on http://localhost:${CONFIG.PORT}`);
     });
     runSyncSequence(db, mangaDb)
@@ -419,8 +319,8 @@ async function main() {
             }
         }
     }, 300000);
-    const offlineDbInterval = setInterval(() => {
-        if (offlineDb.checkWeeklyUpdateDue(db)) {
+    const offlineDbInterval = setInterval(async () => {
+        if (await offlineDb.checkWeeklyUpdateDue(db)) {
             logger.info('Weekly offline database update triggered by periodic schedule...');
             offlineDb.executeScheduledUpdate(db).catch((err) => {
                 logger.warn({ err: err?.message }, 'Interval scheduled offline database update failed');
@@ -432,7 +332,7 @@ async function main() {
         if (isShuttingDown)
             return;
         isShuttingDown = true;
-        stopDiscovery();
+        stopWatchlistDiscovery();
         clearInterval(syncInterval);
         clearInterval(offlineDbInterval);
         discordRPCService.disconnect();
@@ -441,8 +341,8 @@ async function main() {
         await mangaWatcher.close();
         await tvWatcher.close();
         await asmrWatcher.close();
-        if (expressServer) {
-            await new Promise((resolve) => expressServer.close(() => resolve()));
+        if (server) {
+            await new Promise((resolve) => server.close(() => resolve()));
         }
         if (hasUnsyncedChanges) {
             logger.info('Sync on shutdown: uploading final database changes...');
@@ -502,25 +402,33 @@ async function main() {
     process.on('SIGTERM', () => shutdown('SIGTERM'));
     process.on('SIGHUP', () => shutdown('SIGHUP'));
     process.once('SIGUSR2', () => shutdown('SIGUSR2'));
-    app.post('/api/internal/shutdown', (req, res) => {
-        const isLoopback = req.ip === '::1' || req.ip === '127.0.0.1' || req.ip === '::ffff:127.0.0.1';
+    app.post('/api/internal/shutdown', (c) => {
+        let remoteAddress;
+        try {
+            remoteAddress = getConnInfo(c).remote.address ?? '';
+        }
+        catch {
+            remoteAddress = '';
+        }
+        const isLoopback = remoteAddress === '::1' ||
+            remoteAddress === '127.0.0.1' ||
+            remoteAddress === '::ffff:127.0.0.1';
         if (!isLoopback) {
-            res.status(403).json({ error: 'Forbidden' });
-            return;
+            return c.json({ error: 'Forbidden' }, 403);
         }
         const expectedToken = process.env.INTERNAL_SHUTDOWN_TOKEN;
-        const providedToken = req.headers['x-internal-token'];
+        const providedToken = c.req.header('x-internal-token');
         if (expectedToken) {
             const expBuf = Buffer.from(expectedToken);
             const provBuf = Buffer.from(typeof providedToken === 'string' ? providedToken : '');
             if (expBuf.length !== provBuf.length || !crypto.timingSafeEqual(expBuf, provBuf)) {
                 logger.warn('Unauthorized internal shutdown attempt rejected: invalid token');
-                res.status(403).json({ error: 'Forbidden' });
-                return;
+                return c.json({ error: 'Forbidden' }, 403);
             }
         }
-        res.status(200).json({ message: 'Shutting down' });
+        const response = c.json({ message: 'Shutting down' });
         setTimeout(() => shutdown(), 500);
+        return response;
     });
 }
 main().catch((err) => {

package/server/dist/sync.js

@@ -7,6 +7,7 @@ import { rcloneService } from './rclone.js';
 import { githubSyncService } from './github-sync.js';
 import { CONFIG } from './config.js';
 import { DatabaseWrapper } from './db.js';
+import { runTx } from './db/drizzle.js';
 import { dbGet } from './utils/db-utils.js';
 import { TempShowIdsRepository } from './repositories/temp-show-ids.repository.js';
 import { malCachePruneExpired } from './repositories/mal-cache.repository.js';
@@ -15,8 +16,6 @@ import { ANIME_SYNC_TABLES, exportTables, importTables, MANGA_SYNC_TABLES, TV_SY
 const log = logger.child({ module: 'Sync' });
 export const SYNC_TABLES = ANIME_SYNC_TABLES;
 export { MANGA_SYNC_TABLES, TV_SYNC_TABLES, ASMR_SYNC_TABLES };
-// anime_id_map (offline MAL<->AniList metadata) is intentionally local-only:
-// it is rebuilt weekly from the upstream JSON dump and never synced.
 async function exportSyncPayload(db) {
     return exportTables(db, SYNC_TABLES);
 }
@@ -568,6 +567,15 @@ export async function performWriteTransaction(db, runnable) {
     const newVersion = row?.value ?? 1;
     await setLocalManifestVersion(newVersion);
 }
+export async function performWriteTransactionAsync(db, runnable) {
+    await runTx(db, async (tx) => {
+        await runnable(tx);
+        tx.run("UPDATE sync_metadata SET value = value + 1 WHERE key = 'db_version'");
+    });
+    const row = dbGet(db, "SELECT value FROM sync_metadata WHERE key = 'db_version'");
+    const newVersion = row?.value ?? 1;
+    await setLocalManifestVersion(newVersion);
+}
 export async function performMangaWriteTransaction(db, runnable) {
     db.serialize(() => {
         runnable(db);
@@ -577,6 +585,15 @@ export async function performMangaWriteTransaction(db, runnable) {
     const newVersion = row?.value ?? 1;
     await setLocalMangaManifestVersion(newVersion);
 }
+export async function performMangaWriteTransactionAsync(db, runnable) {
+    await runTx(db, async (tx) => {
+        await runnable(tx);
+        tx.run("UPDATE sync_metadata SET value = value + 1 WHERE key = 'db_version'");
+    });
+    const row = dbGet(db, "SELECT value FROM sync_metadata WHERE key = 'db_version'");
+    const newVersion = row?.value ?? 1;
+    await setLocalMangaManifestVersion(newVersion);
+}
 export async function performTvWriteTransaction(db, runnable) {
     db.serialize(() => {
         runnable(db);
@@ -586,6 +603,15 @@ export async function performTvWriteTransaction(db, runnable) {
     const newVersion = row?.value ?? 1;
     await setLocalTvManifestVersion(newVersion);
 }
+export async function performTvWriteTransactionAsync(db, runnable) {
+    await runTx(db, async (tx) => {
+        await runnable(tx);
+        tx.run("UPDATE sync_metadata SET value = value + 1 WHERE key = 'db_version'");
+    });
+    const row = dbGet(db, "SELECT value FROM sync_metadata WHERE key = 'db_version'");
+    const newVersion = row?.value ?? 1;
+    await setLocalTvManifestVersion(newVersion);
+}
 export async function performAsmrWriteTransaction(db, runnable) {
     db.serialize(() => {
         runnable(db);
@@ -595,6 +621,15 @@ export async function performAsmrWriteTransaction(db, runnable) {
     const newVersion = row?.value ?? 1;
     await setLocalAsmrManifestVersion(newVersion);
 }
+export async function performAsmrWriteTransactionAsync(db, runnable) {
+    await runTx(db, async (tx) => {
+        await runnable(tx);
+        tx.run("UPDATE sync_metadata SET value = value + 1 WHERE key = 'db_version'");
+    });
+    const row = dbGet(db, "SELECT value FROM sync_metadata WHERE key = 'db_version'");
+    const newVersion = row?.value ?? 1;
+    await setLocalAsmrManifestVersion(newVersion);
+}
 export async function mangaSyncDownOnBoot(db, remoteFolderName) {
     let localVersion = await getLocalMangaManifestVersion();
     if (localVersion === 0 && db) {
@@ -1023,13 +1058,15 @@ export async function initializeTvDatabase(dbPath) {
          UPDATE tv_progress SET completed = 1
          WHERE mediaId = NEW.mediaId AND season = NEW.season AND episode = NEW.episode;
        END`);
+        db.run(`DROP TRIGGER IF EXISTS trg_tv_progress_completed_update`);
         db.run(`CREATE TRIGGER IF NOT EXISTS trg_tv_progress_completed_update
        AFTER UPDATE OF currentTime, duration ON tv_progress
-       WHEN OLD.completed = 1 OR (NEW.duration > 0 AND NEW.currentTime >= NEW.duration * 0.8)
+       WHEN NEW.duration > 0 AND NEW.currentTime >= NEW.duration * 0.8
        BEGIN
          UPDATE tv_progress SET completed = 1
          WHERE mediaId = NEW.mediaId AND season = NEW.season AND episode = NEW.episode;
        END`);
+        db.run(`UPDATE tv_progress SET completed = 0 WHERE completed = 1 AND NOT (duration > 0 AND currentTime >= duration * 0.8)`);
         db.run(`UPDATE OR IGNORE tv_progress SET mediaId = REPLACE(mediaId, '-', ':') WHERE mediaId LIKE 'tv-%' OR mediaId LIKE 'movie-%'`);
         db.run(`DELETE FROM tv_progress WHERE mediaId LIKE 'tv-%' OR mediaId LIKE 'movie-%'`);
         return db;
@@ -1099,7 +1136,7 @@ export async function initializeDatabase(dbPath) {
         db.run(`CREATE TABLE IF NOT EXISTS temp_show_ids (id TEXT PRIMARY KEY, provider TEXT NOT NULL, nativeId TEXT NOT NULL, title TEXT NOT NULL, thumbnail TEXT, createdAt INTEGER NOT NULL)`);
         db.run(`CREATE UNIQUE INDEX IF NOT EXISTS idx_temp_show_ids_provider_native ON temp_show_ids(provider, nativeId)`);
         try {
-            const purged = TempShowIdsRepository.purge(db);
+            const purged = await TempShowIdsRepository.purge(db);
             if (purged > 0)
                 logger.info({ purged }, 'Purged stale temp show ids on boot');
         }

package/server/dist/trpc/context.js

@@ -0,0 +1,7 @@
+import { getTokenFromHeaders, hasAppPassword, validateLanSession } from '../app-auth.js';
+export function buildTrpcContext(deps, authorization, cookie) {
+    return {
+        ...deps,
+        lanAuthed: !hasAppPassword() || validateLanSession(getTokenFromHeaders(authorization, cookie)),
+    };
+}

package/server/dist/trpc/errors.js

@@ -0,0 +1,21 @@
+import { TRPCError } from '@trpc/server';
+export function isAuthErrorCause(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const code = value.code;
+    return code === 'AUTH_REQUIRED' || code === 'LAN_AUTH_REQUIRED';
+}
+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' },
+    });
+}

package/server/dist/trpc/index.js

@@ -0,0 +1,19 @@
+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;
+export const publicProcedure = t.procedure;
+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

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

@@ -0,0 +1,122 @@
+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 } from '../validation.js';
+const asmrLibraryListInput = () => 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 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 };
+    }),
+});