@serifpersia/dango 3.3.8 → 3.4.0

package/server/dist/request-logger.js

@@ -1,16 +0,0 @@
-import logger from './logger.js';
-export function requestLogger(req, res, next) {
-    const start = process.hrtime.bigint();
-    const url = req.originalUrl || req.url;
-    res.on('finish', () => {
-        const ms = Math.round((Number(process.hrtime.bigint() - start) / 1_000_000) * 10) / 10;
-        const payload = { method: req.method, url, status: res.statusCode, ms };
-        if (res.statusCode >= 500) {
-            logger.warn(payload, 'request failed');
-        }
-        else if (!url.startsWith('/api/proxy')) {
-            logger.trace(`${req.method} ${url} ${res.statusCode} ${ms}ms`);
-        }
-    });
-    next();
-}

package/server/dist/routes/asmr-library.routes.js

@@ -1,23 +0,0 @@
-import { Router } from 'express';
-import { AsmrLibraryController } from '../controllers/asmr-library.controller.js';
-export function createAsmrLibraryRouter() {
-    const router = Router();
-    const controller = new AsmrLibraryController();
-    router.get('/asmr/library', controller.getLibrary);
-    router.get('/asmr/library/ids', controller.getLibraryIds);
-    router.get('/asmr/library/check/:id', controller.checkLibrary);
-    router.post('/asmr/library/add', controller.addToLibrary);
-    router.post('/asmr/library/remove', controller.removeFromLibrary);
-    router.post('/asmr/library/status', controller.updateStatus);
-    router.post('/asmr/library/batch-status', controller.batchUpdateStatus);
-    router.post('/asmr/library/remove-many', controller.batchRemove);
-    router.post('/asmr/progress/remove-many', controller.batchRemoveProgress);
-    router.get('/asmr/progress/:workId', controller.getProgress);
-    router.get('/asmr/progress/:workId/latest', controller.getLatestProgress);
-    router.post('/asmr/progress', controller.saveProgress);
-    router.post('/asmr/progress/remove', controller.removeProgress);
-    router.get('/asmr/continue-listening', controller.getContinueListening);
-    router.get('/asmr/continue-listening/adult-count', controller.getAdultContinueListeningCount);
-    router.post('/asmr/continue-listening/purge-adult', controller.purgeAdultContinueListening);
-    return router;
-}

package/server/dist/routes/asmr.routes.js

@@ -1,81 +0,0 @@
-import { Router } from 'express';
-import logger from '../logger.js';
-function makeCacheMiddleware(cache, keyFn, ttl) {
-    return (req, res, next) => {
-        const cacheKey = keyFn(req);
-        const cached = cache.get(cacheKey);
-        if (cached)
-            return res.json(cached);
-        const originalJson = res.json.bind(res);
-        res.json = (data) => {
-            if (res.statusCode >= 200 && res.statusCode < 400) {
-                if (ttl !== undefined)
-                    cache.set(cacheKey, data, ttl);
-                else
-                    cache.set(cacheKey, data);
-            }
-            return originalJson(data);
-        };
-        next();
-    };
-}
-export function createAsmrRouter(apiCache, getProvider) {
-    const router = Router();
-    router.get('/asmr/browse', makeCacheMiddleware(apiCache, (req) => `route-asmr-browse-${req.query.q || ''}-${req.query.page || 1}-${req.query.sort || ''}-${req.query.rating || ''}-${req.query.sort === 'random' ? Date.now() : ''}`, 300), async (req, res) => {
-        try {
-            const provider = getProvider();
-            if (!provider)
-                return res.json({ shows: [], hasNext: false });
-            const result = await provider.browse({
-                query: req.query.q,
-                page: parseInt(req.query.page) || 1,
-                sort: req.query.sort,
-                rating: req.query.rating,
-            });
-            res.json(result);
-        }
-        catch (err) {
-            if (err.message === 'AUTH_REQUIRED') {
-                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'jasmr' });
-            }
-            logger.error({ err }, '[Asmr] browse failed');
-            res.json({ shows: [], hasNext: false });
-        }
-    });
-    router.get('/asmr/work/:rj', makeCacheMiddleware(apiCache, (req) => `route-asmr-work-${req.params.rj}`, 1800), async (req, res) => {
-        try {
-            const provider = getProvider();
-            if (!provider) {
-                return res.json({
-                    rjCode: req.params.rj,
-                    description: '',
-                    tracks: [],
-                    images: [],
-                    chapters: [],
-                });
-            }
-            const rjCode = String(req.params.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),
-            ]);
-            res.json({
-                rjCode,
-                description: episodes?.description || '',
-                tracks: streams?.[0]?.links || [],
-                images,
-                chapters,
-            });
-        }
-        catch (err) {
-            if (err.message === 'AUTH_REQUIRED') {
-                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'jasmr' });
-            }
-            logger.error({ err, rj: req.params.rj }, '[Asmr] work fetch failed');
-            res.json({ rjCode: req.params.rj, description: '', tracks: [], images: [], chapters: [] });
-        }
-    });
-    return router;
-}

package/server/dist/routes/auth.routes.js

@@ -1,25 +0,0 @@
-import { Router } from 'express';
-import { AuthController } from '../controllers/auth.controller.js';
-export function createAuthRouter(runSyncSequence) {
-    const router = Router();
-    const controller = new AuthController(runSyncSequence);
-    router.get('/config-status', controller.getConfigStatus);
-    router.get('/google-auth', controller.getGoogleAuthSettings);
-    router.post('/google-auth', controller.updateGoogleAuthSettings);
-    router.get('/github/status', controller.getGitHubAuthStatus);
-    router.post('/github/start', controller.startGitHubDeviceAuth);
-    router.get('/github/poll', controller.pollGitHubDeviceAuth);
-    router.post('/github/logout', controller.logoutGitHub);
-    router.get('/github/auth', controller.getGitHubAuthOverride);
-    router.post('/github/auth', controller.updateGitHubAuthSettings);
-    router.get('/settings/rclone', controller.getRcloneSettings);
-    router.post('/settings/rclone', controller.updateRcloneSettings);
-    router.get('/settings/sync', controller.getSyncSettings);
-    router.post('/settings/sync', controller.updateSyncProvider);
-    router.get('/google', controller.getAuthUrl);
-    router.post('/google/login', controller.loginGoogle);
-    router.get('/google/callback', controller.handleCallback);
-    router.get('/user', controller.getUserProfile);
-    router.post('/logout', controller.logout);
-    return router;
-}

package/server/dist/routes/data.routes.js

@@ -1,47 +0,0 @@
-import { Router } from 'express';
-import { DataController } from '../controllers/data.controller.js';
-function makeCacheMiddleware(cache, keyFn, ttl, validate = (d) => Array.isArray(d) && d.length > 0) {
-    return (req, res, next) => {
-        const cacheKey = keyFn(req);
-        const cached = cache.get(cacheKey);
-        if (cached)
-            return res.json(cached);
-        const originalJson = res.json.bind(res);
-        res.json = (data) => {
-            if (validate(data)) {
-                if (ttl !== undefined) {
-                    cache.set(cacheKey, data, ttl);
-                }
-                else {
-                    cache.set(cacheKey, data);
-                }
-            }
-            return originalJson(data);
-        };
-        next();
-    };
-}
-export function createDataRouter(apiCache, providers, getCatalog) {
-    const router = Router();
-    const controller = new DataController(providers, getCatalog);
-    router.get('/schedule/:date', makeCacheMiddleware(apiCache, (req) => `schedule-${req.params.date}-${req.query.format || 'TV'}`, 1800), controller.getSchedule);
-    router.get('/latest-releases', makeCacheMiddleware(apiCache, (req) => `latest-releases-${req.query.format || 'TV'}-${req.query.page || 1}-${req.query.size || 12}`, 300), controller.getLatestReleases);
-    router.get('/search', makeCacheMiddleware(apiCache, (req) => `search-${JSON.stringify(req.query)}`, 1800), controller.search);
-    router.get('/mature/search', makeCacheMiddleware(apiCache, (req) => `mature-search-${JSON.stringify(req.query)}`, 600, (d) => !!d && typeof d === 'object' && Array.isArray(d.data)), controller.matureSearch);
-    router.get('/mature/resolve', makeCacheMiddleware(apiCache, (req) => `mature-resolve-${req.query.title || ''}`, 3600), controller.resolveMature);
-    router.get('/mature/filters', controller.getMatureFilters);
-    router.post('/mature/allocate', controller.allocateTempShow);
-    router.get('/skip-times/:showId/:episodeNumber', controller.getSkipTimes);
-    router.get('/video', controller.getVideo);
-    router.get('/episodes', makeCacheMiddleware(apiCache, (req) => `episodes-${req.query.showId || ''}`, 3600), controller.getEpisodes);
-    router.get('/seasonal', makeCacheMiddleware(apiCache, (req) => `seasonal-${req.query.format || 'ALL'}-${req.query.page || 1}-${req.query.size || 14}`, 300), controller.getSeasonal);
-    router.get('/show-meta/:id', makeCacheMiddleware(apiCache, (req) => `meta-${req.params.id}`, 3600, (d) => !!d), controller.getShowMeta);
-    router.get('/popular-list', makeCacheMiddleware(apiCache, (req) => `popular-list-${req.query.sort || 'TRENDING_DESC'}-${req.query.page || 1}-${req.query.size || 20}`, 300), controller.getPopularList);
-    router.get('/trending', makeCacheMiddleware(apiCache, () => 'trending', 300), controller.getTrending);
-    router.get('/spotlight', makeCacheMiddleware(apiCache, () => 'spotlight', 300), controller.getSpotlight);
-    router.get('/home', makeCacheMiddleware(apiCache, (req) => `home-${req.query.format || 'TV'}`, 300), controller.getBatchedHome);
-    router.get('/genres-and-tags', controller.getGenresAndTags);
-    router.get('/anilist-status', controller.getAnilistStatus);
-    router.get('/system-notifications', controller.getSystemNotifications);
-    return router;
-}

package/server/dist/routes/discord-gateway.routes.js

@@ -1,51 +0,0 @@
-import { Router } from 'express';
-import logger from '../logger.js';
-import { discordGatewayService } from '../discord-gateway.js';
-import { updateEnvFile } from '../utils/env.utils.js';
-const log = logger.child({ module: 'DiscordGatewayRoutes' });
-function mask(t) {
-    if (!t)
-        return 'none';
-    return t.slice(0, 8) + '...' + t.slice(-4);
-}
-export function createDiscordGatewayRouter() {
-    const router = Router();
-    router.get('/discord/gateway/status', (_req, res) => {
-        const hasToken = discordGatewayService.hasToken();
-        res.json({
-            hasToken,
-            masked: hasToken ? mask(process.env.DISCORD_GATEWAY_TOKEN) : null,
-            enabled: discordGatewayService.serviceEnabled,
-        });
-    });
-    router.post('/discord/gateway/save', async (req, res) => {
-        let token = (req.body.token || '').trim();
-        if (token.startsWith('"') && token.endsWith('"'))
-            token = token.slice(1, -1);
-        if (token.length < 30)
-            return res.status(400).json({ error: 'Token too short' });
-        try {
-            await updateEnvFile({ DISCORD_GATEWAY_TOKEN: token });
-            discordGatewayService.reloadToken();
-            log.info(`Discord Gateway token saved ${mask(token)} (not logged)`);
-            res.json({ ok: true, masked: mask(token) });
-        }
-        catch (e) {
-            log.error({ err: e }, 'Failed to save Discord Gateway token');
-            res.status(500).json({ error: 'Failed to save token' });
-        }
-    });
-    router.post('/discord/gateway/remove', async (_req, res) => {
-        try {
-            await updateEnvFile({ DISCORD_GATEWAY_TOKEN: '' });
-            discordGatewayService.reloadToken();
-            log.info('Discord Gateway token removed');
-            res.json({ ok: true });
-        }
-        catch (e) {
-            log.error({ err: e }, 'Failed to remove Discord Gateway token');
-            res.status(500).json({ error: 'Failed to remove token' });
-        }
-    });
-    return router;
-}

package/server/dist/routes/insights.routes.js

@@ -1,35 +0,0 @@
-import { Router } from 'express';
-import { InsightsController } from '../controllers/insights.controller.js';
-import { CONFIG } from '../config.js';
-import { getLinkedDiscordUser, setLinkedDiscordUser, syncDiscordRoles, } from '../lib/discord-roles-sync.service.js';
-export function createInsightsRouter() {
-    const router = Router();
-    const controller = new InsightsController();
-    router.get('/insights', controller.getWatchInsights);
-    router.get('/insights/genre-cards', controller.getGenreCards);
-    router.get('/insights/recommendations', controller.getRecommendations);
-    router.get('/insights/discord-sync-stats', controller.getDiscordSyncStats);
-    router.get('/discord-roles-config', (_req, res) => {
-        res.json({ workerUrl: CONFIG.DISCORD_ROLES_WORKER_URL || null });
-    });
-    router.get('/discord-user', async (req, res) => {
-        const user = await getLinkedDiscordUser(req.db);
-        res.json({ user });
-    });
-    router.post('/discord-user', async (req, res) => {
-        const { user } = req.body;
-        if (user !== null &&
-            user !== undefined &&
-            (typeof user !== 'object' || typeof user.id !== 'string' || !user.id)) {
-            res.status(400).json({ error: 'Invalid user payload: expected { id, ... } or null' });
-            return;
-        }
-        await setLinkedDiscordUser(req.db, user || null);
-        res.json({ success: true, user: user || null });
-    });
-    router.post('/discord-sync-now', async (req, res) => {
-        const result = await syncDiscordRoles(req.db, true);
-        res.json(result);
-    });
-    return router;
-}

package/server/dist/routes/lan-auth.routes.js

@@ -1,46 +0,0 @@
-import { Router } from 'express';
-import { hasAppPassword, verifyAppPassword, setAppPassword, createLanSession, revokeLanSession, clearAllLanSessions, isLanAuthenticated, isLoopbackRequest, buildLanCookie, clearLanCookie, getRequestToken, } from '../app-auth.js';
-export function createLanAuthRouter() {
-    const router = Router();
-    router.get('/app-status', (req, res) => {
-        res.json({
-            hasPassword: hasAppPassword(),
-            isAuthenticated: isLanAuthenticated(req),
-        });
-    });
-    router.post('/app-login', (req, res) => {
-        const password = String(req.body?.password || '');
-        if (!hasAppPassword()) {
-            return res.json({ success: true });
-        }
-        if (!password) {
-            return res.status(400).json({ error: 'Password required' });
-        }
-        if (!verifyAppPassword(password)) {
-            return res.status(401).json({ error: 'Invalid password' });
-        }
-        const session = createLanSession();
-        res.setHeader('Set-Cookie', buildLanCookie(session.token, session.expiry));
-        res.json({ success: true });
-    });
-    router.post('/app-logout', (req, res) => {
-        revokeLanSession(getRequestToken(req));
-        res.setHeader('Set-Cookie', clearLanCookie());
-        res.json({ success: true });
-    });
-    router.post('/app-setup', (req, res) => {
-        if (!isLoopbackRequest(req)) {
-            return res.status(403).json({ error: 'Forbidden' });
-        }
-        const password = String(req.body?.password || '');
-        setAppPassword(password)
-            .then(() => {
-            clearAllLanSessions();
-            res.json({ success: true, hasPassword: hasAppPassword() });
-        })
-            .catch((err) => {
-            res.status(500).json({ error: 'Failed to update password' });
-        });
-    });
-    return router;
-}

package/server/dist/routes/manga-library.routes.js

@@ -1,25 +0,0 @@
-import { Router } from 'express';
-import { MangaLibraryController } from '../controllers/manga-library.controller.js';
-export function createMangaLibraryRouter() {
-    const router = Router();
-    const controller = new MangaLibraryController();
-    router.get('/manga/library', controller.getLibrary);
-    router.get('/manga/library/ids', controller.getLibraryIds);
-    router.get('/manga/library/check/:id', controller.checkLibrary);
-    router.get('/manga/library/entry/:id', controller.getEntry);
-    router.post('/manga/library/add', controller.addToLibrary);
-    router.post('/manga/library/remove', controller.removeFromLibrary);
-    router.post('/manga/library/status', controller.updateStatus);
-    router.post('/manga/library/link', controller.linkAnilist);
-    router.post('/manga/library/batch-status', controller.batchUpdateStatus);
-    router.post('/manga/library/remove-many', controller.batchRemove);
-    router.post('/manga/progress/remove-many', controller.batchRemoveProgress);
-    router.get('/manga/progress/:mangaId', controller.getProgress);
-    router.get('/manga/progress/:mangaId/latest', controller.getLatestProgress);
-    router.post('/manga/progress', controller.saveProgress);
-    router.post('/manga/progress/remove', controller.removeProgress);
-    router.get('/manga/continue-reading', controller.getContinueReading);
-    router.get('/manga/continue-reading/adult-count', controller.getAdultContinueReadingCount);
-    router.post('/manga/continue-reading/purge-adult', controller.purgeAdultContinueReading);
-    return router;
-}

package/server/dist/routes/manga.routes.js

@@ -1,141 +0,0 @@
-import { Router } from 'express';
-import logger from '../logger.js';
-import { parseJsonBody } from '../utils/http.utils.js';
-function makeCacheMiddleware(cache, keyFn, ttl) {
-    return (req, res, next) => {
-        const cacheKey = keyFn(req);
-        const cached = cache.get(cacheKey);
-        if (cached)
-            return res.json(cached);
-        const originalJson = res.json.bind(res);
-        res.json = (data) => {
-            if (res.statusCode >= 200 && res.statusCode < 400) {
-                if (ttl !== undefined)
-                    cache.set(cacheKey, data, ttl);
-                else
-                    cache.set(cacheKey, data);
-            }
-            return originalJson(data);
-        };
-        next();
-    };
-}
-const SAFE = ['safe'];
-function parseRatings(req) {
-    const mature = req.query.mature === '1';
-    const raw = String(req.query.rating || 'safe')
-        .split(',')
-        .map((s) => s.trim().toLowerCase())
-        .filter((s) => ['safe', 'suggestive', 'erotica', 'pornographic'].includes(s));
-    if (!mature)
-        return SAFE;
-    const exact = [...new Set(raw)];
-    return exact.length > 0 ? exact : SAFE;
-}
-export function createMangaRouter(apiCache, getProvider) {
-    const router = Router();
-    const pick = (name) => getProvider(name.toLowerCase());
-    router.get('/manga/search', makeCacheMiddleware(apiCache, (req) => `route-manga-search-${req.query.provider || ''}-${req.query.q || ''}-${req.query.page || 1}-${req.query.sort || ''}-${req.query.status || ''}-${req.query.type || ''}-${req.query.rating || ''}-${req.query.mature || ''}`, 300), async (req, res) => {
-        try {
-            const provider = req.query.provider;
-            const ratings = parseRatings(req);
-            const rawType = req.query.type || '';
-            const type = rawType === 'doujinshi' && req.query.mature !== '1' ? '' : rawType;
-            const options = {
-                query: req.query.q || '',
-                page: parseInt(req.query.page) || 1,
-                limit: Math.min(parseInt(req.query.limit) || 24, 50),
-                sort: req.query.sort || 'popular',
-                status: req.query.status || '',
-                type,
-                ratings,
-            };
-            const result = await pick(provider)?.search(options);
-            res.json(result ?? { items: [], hasNext: false });
-        }
-        catch (err) {
-            logger.error({ err }, '[Manga] search failed');
-            res.json({ items: [], hasNext: false });
-        }
-    });
-    router.get('/manga/info', makeCacheMiddleware(apiCache, (req) => `route-manga-info-${req.query.provider || ''}-${req.query.id || ''}-${req.query.rating || ''}-${req.query.mature || ''}`, 600), async (req, res) => {
-        try {
-            const provider = req.query.provider;
-            const id = String(req.query.id || '');
-            if (!id)
-                return res.status(400).json({ error: 'Missing id' });
-            const detail = await pick(provider)?.getDetail(id, parseRatings(req));
-            if (!detail)
-                return res.status(404).json({ error: 'Not found' });
-            res.json(detail);
-        }
-        catch (err) {
-            logger.error({ err }, '[Manga] info failed');
-            res.status(500).json({ error: 'Failed to load manga' });
-        }
-    });
-    router.get('/manga/chapters', makeCacheMiddleware(apiCache, (req) => `route-manga-chapters-${req.query.provider || ''}-${req.query.id || ''}-${req.query.rating || ''}-${req.query.mature || ''}`, 600), async (req, res) => {
-        try {
-            const provider = req.query.provider;
-            const id = String(req.query.id || '');
-            if (!id)
-                return res.status(400).json({ error: 'Missing id' });
-            const chapters = (await pick(provider)?.getChapters(id, parseRatings(req))) ?? [];
-            res.json({ chapters });
-        }
-        catch (err) {
-            logger.error({ err }, '[Manga] chapters failed');
-            res.json({ chapters: [] });
-        }
-    });
-    router.get('/manga/pages', makeCacheMiddleware(apiCache, (req) => `route-manga-pages-${req.query.provider || ''}-${req.query.id || ''}`, 300), async (req, res) => {
-        try {
-            const provider = req.query.provider;
-            const id = String(req.query.id || '');
-            if (!id)
-                return res.status(400).json({ error: 'Missing id' });
-            const pages = (await pick(provider)?.getPages(id)) ?? [];
-            res.json({ pages });
-        }
-        catch (err) {
-            logger.error({ err }, '[Manga] pages failed');
-            res.json({ pages: [] });
-        }
-    });
-    router.get('/manga/trending', makeCacheMiddleware(apiCache, () => 'route-manga-trending', 600), async (_req, res) => {
-        try {
-            const url = 'https://api.mangadex.org/manga?limit=6&order%5BfollowedCount%5D=desc&includes%5B%5D=cover_art&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive';
-            const upstream = await fetch(url, {
-                headers: { 'User-Agent': 'dango/3.1.9' },
-            });
-            if (!upstream.ok)
-                return res.json([]);
-            const data = (await parseJsonBody(upstream));
-            const results = (data.data || []).map((m) => {
-                const title = m.attributes?.title?.en || Object.values(m.attributes?.title || {})[0] || '';
-                const desc = m.attributes?.description?.en || '';
-                const tags = (m.attributes?.tags || []).map((t) => t.attributes?.name?.en).filter(Boolean);
-                const coverArt = m.relationships?.find((r) => r.type === 'cover_art');
-                const fileName = coverArt?.attributes?.fileName;
-                const cover = fileName
-                    ? `https://uploads.mangadex.org/covers/${m.id}/${fileName}.512.jpg`
-                    : '';
-                return {
-                    id: m.id,
-                    title,
-                    description: desc,
-                    tags,
-                    year: m.attributes?.year || null,
-                    status: m.attributes?.status || null,
-                    cover,
-                };
-            });
-            res.json(results);
-        }
-        catch (err) {
-            logger.error({ err }, '[Manga] trending failed');
-            res.json([]);
-        }
-    });
-    return router;
-}

package/server/dist/routes/music.routes.js

@@ -1,20 +0,0 @@
-import { Router } from 'express';
-import { MusicController } from '../controllers/music.controller.js';
-export function createMusicRouter(apiCache) {
-    const router = Router();
-    const controller = new MusicController(apiCache);
-    router.get('/music/auth/status', controller.getAuthStatus);
-    router.post('/music/auth/start', controller.startAuth);
-    router.post('/music/auth/signout', controller.signOut);
-    router.get('/music/search', controller.search);
-    router.get('/music/stream', controller.stream);
-    router.get('/music/audio', controller.audio);
-    router.get('/music/track', controller.track);
-    router.get('/music/library', controller.library);
-    router.get('/music/playlist', controller.playlist);
-    router.get('/music/home', controller.home);
-    router.get('/music/upnext', controller.upnext);
-    router.get('/music/likes', controller.likedIds);
-    router.post('/music/like', controller.rate);
-    return router;
-}

package/server/dist/routes/providers.routes.js

@@ -1,17 +0,0 @@
-import { Router } from 'express';
-export function createProvidersRouter(getCatalog, refresh) {
-    const router = Router();
-    router.get('/providers', (_req, res) => {
-        res.set('Cache-Control', 'public, max-age=300').json(getCatalog());
-    });
-    router.post('/providers/refresh', async (_req, res) => {
-        try {
-            const catalog = await refresh();
-            res.json(catalog);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || 'refresh failed' });
-        }
-    });
-    return router;
-}

package/server/dist/routes/proxy.routes.js

@@ -1,12 +0,0 @@
-import { Router } from 'express';
-import { ProxyController } from '../controllers/proxy.controller.js';
-export function createProxyRouter() {
-    const router = Router();
-    const controller = new ProxyController();
-    router.get('/proxy', controller.handleProxy);
-    router.get('/embed-proxy', controller.handleEmbedProxy);
-    router.get('/subtitle-proxy', controller.handleSubtitleProxy);
-    router.get('/image-proxy', controller.handleImageProxy);
-    router.get('/resolve', controller.handleResolve);
-    return router;
-}

package/server/dist/routes/settings.routes.js

@@ -1,24 +0,0 @@
-import { Router } from 'express';
-import { SettingsController } from '../controllers/settings.controller.js';
-import multer from 'multer';
-export function createSettingsRouter(getDb, initializeDatabase, setDb) {
-    const router = Router();
-    const controller = new SettingsController();
-    router.get('/settings', controller.getSettings);
-    router.post('/settings', controller.updateSettings);
-    router.get('/backup-db', controller.backupDatabase);
-    router.post('/database/clear', controller.clearDatabase);
-    router.get('/installation-id', controller.getInstallationId);
-    router.get('/settings/offline-db', controller.getOfflineDbInfo);
-    router.post('/settings/offline-db/update', controller.updateOfflineDb);
-    router.post('/settings/offline-db/auto-update', controller.setAutoUpdateOfflineDb);
-    const restoreStorage = multer({
-        storage: multer.memoryStorage(),
-        limits: { fileSize: 256 * 1024 * 1024 },
-    });
-    router.post('/restore-db', restoreStorage.single('dbfile'), (req, res) => controller.restoreDatabase(req, res, getDb(), initializeDatabase, setDb));
-    router.post('/import/mal-xml', multer().single('xmlfile'), controller.importMalXml);
-    router.get('/import/mal-xml/status', controller.getImportStatus);
-    router.post('/import/mal-xml/cancel', controller.cancelImport);
-    return router;
-}