@serifpersia/dango 3.0.3

package/server/dist/controllers/data.controller.js

@@ -0,0 +1,785 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataController = void 0;
+const title_matching_1 = require("../providers/title-matching");
+const anilist_1 = require("../lib/anilist");
+const mal_1 = require("../lib/mal");
+const mal_cache_repository_1 = require("../repositories/mal-cache.repository");
+const migration_1 = require("../lib/migration");
+const temp_ids_1 = require("../lib/temp-ids");
+const temp_show_ids_repository_1 = require("../repositories/temp-show-ids.repository");
+const shows_meta_repository_1 = require("../repositories/shows-meta.repository");
+const watchlist_repository_1 = require("../repositories/watchlist.repository");
+const db_utils_1 = require("../utils/db-utils");
+const logger_1 = __importDefault(require("../logger"));
+class DataController {
+    providers;
+    constructor(providers) {
+        this.providers = providers;
+    }
+    setDataCache(res, maxAgeSeconds, body) {
+        const isEmpty = Array.isArray(body)
+            ? body.length === 0
+            : body == null || (typeof body === 'object' && Object.keys(body).length === 0);
+        res.set('Cache-Control', isEmpty ? 'no-store' : `public, max-age=${maxAgeSeconds}`);
+    }
+    getProvider(req) {
+        const providerName = req.query.provider?.toLowerCase();
+        if (!providerName)
+            return null;
+        return this.providers[providerName] || null;
+    }
+    async resolveMatureStreamingId(title, wanted) {
+        const names = [wanted, 'wh', 'op'].filter((p) => !!p && p !== 'mal' && !!this.providers[p]);
+        const seen = new Set();
+        for (const name of names) {
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            try {
+                const resolved = await this.providers[name].resolveShowId?.(title);
+                if (resolved)
+                    return { provider: this.providers[name], nativeId: resolved };
+            }
+            catch {
+                // ignore
+            }
+        }
+        return null;
+    }
+    getTrending = async (_req, res) => {
+        try {
+            const data = await (0, anilist_1.getTrending)(1, 20, 'TRENDING_DESC', 'RELEASING');
+            this.setDataCache(res, 300, data);
+            res.json(data);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'Trending fetch failed');
+            res.set('Cache-Control', 'no-store').json([]);
+        }
+    };
+    getSpotlight = async (_req, res) => {
+        try {
+            const data = await (0, anilist_1.getSpotlightBanners)(1, 20);
+            this.setDataCache(res, 300, data);
+            res.json(data);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'Spotlight fetch failed');
+            res.set('Cache-Control', 'no-store').json([]);
+        }
+    };
+    getPopularList = async (req, res) => {
+        const sort = req.query.sort === 'POPULARITY_DESC' ? 'POPULARITY_DESC' : 'TRENDING_DESC';
+        const page = parseInt(req.query.page) || 1;
+        const size = parseInt(req.query.size) || 20;
+        try {
+            const data = await (0, anilist_1.getTrending)(page, size, sort);
+            this.setDataCache(res, 300, data);
+            res.json(data);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'Popular list fetch failed');
+            res.set('Cache-Control', 'no-store').json([]);
+        }
+    };
+    getSchedule = async (req, res) => {
+        try {
+            const date = new Date(req.params.date + 'T00:00:00.000Z');
+            const format = req.query.format || undefined;
+            const adult = format === 'ADULT';
+            const data = await (0, anilist_1.getSchedule)(date, adult ? undefined : format, adult);
+            this.setDataCache(res, 300, data);
+            res.json(data);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e, date: req.params.date }, 'Schedule fetch failed');
+            res.set('Cache-Control', 'no-store').json([]);
+        }
+    };
+    getSkipTimes = async (req, res) => {
+        try {
+            const showId = req.params.showId;
+            const episodeNumber = req.params.episodeNumber;
+            if (/^\d+$/.test(showId)) {
+                const skipRes = await fetch(`https://api.aniskip.com/v1/skip-times/${showId}/${episodeNumber}?types=op&types=ed`);
+                if (skipRes.ok) {
+                    const data = await skipRes.json();
+                    return res.json(data);
+                }
+            }
+            res.json({ found: false, results: [] });
+        }
+        catch {
+            res.json({ found: false, results: [] });
+        }
+    };
+    getVideo = async (req, res) => {
+        try {
+            let showId = req.query.showId;
+            const videoMalId = (0, anilist_1.parseMalId)(showId);
+            if (videoMalId) {
+                try {
+                    const malMeta = await (0, anilist_1.getShowMetaByMalId)(videoMalId);
+                    if (malMeta?.anilistId && malMeta.anilistId > 0)
+                        showId = String(malMeta.anilistId);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if ((0, temp_ids_1.isTempShowId)(showId)) {
+                try {
+                    const row = temp_show_ids_repository_1.TempShowIdsRepository.getById(req.db, showId);
+                    if (!row || !(0, temp_ids_1.isTempMatureProvider)(row.provider))
+                        return res.json([]);
+                    const wanted = String(req.query.provider || '').toLowerCase();
+                    const own = this.providers[row.provider];
+                    if (own && (!wanted || wanted === row.provider)) {
+                        const urls = await own.getStreamUrls(row.nativeId, req.query.episodeNumber, req.query.mode);
+                        return res.json(urls || []);
+                    }
+                    const hit = await this.resolveMatureStreamingId(row.title, wanted);
+                    if (hit) {
+                        const urls = await hit.provider.getStreamUrls(hit.nativeId, req.query.episodeNumber, req.query.mode);
+                        return res.json(urls || []);
+                    }
+                }
+                catch (e) {
+                    logger_1.default.error({ err: e, showId }, 'Temp show video fetch failed');
+                }
+                return res.json([]);
+            }
+            const providerName = req.query.provider;
+            const providerKey = providerName?.toLowerCase();
+            const stillMal = (0, anilist_1.parseMalId)(showId) !== null;
+            const needsResolution = providerKey !== 'megaplay' && (/^\d+$/.test(showId) || stillMal);
+            if (providerKey && needsResolution) {
+                const meta = (await shows_meta_repository_1.ShowsMetaRepository.getById(req.db, showId));
+                let targetTitle = meta?.englishName || meta?.name;
+                let anilistShow = null;
+                if (!targetTitle) {
+                    try {
+                        anilistShow = await (0, anilist_1.getShowMetaById)(showId);
+                        targetTitle = anilistShow?.englishName || anilistShow?.name;
+                        if (anilistShow && targetTitle) {
+                            await shows_meta_repository_1.ShowsMetaRepository.upsert(req.db, {
+                                id: showId,
+                                name: anilistShow.name,
+                                thumbnail: anilistShow.thumbnail,
+                                nativeName: anilistShow.nativeName,
+                                englishName: anilistShow.englishName,
+                                genres: anilistShow.genres
+                                    ? JSON.stringify(anilistShow.genres.map((genre) => genre.name))
+                                    : undefined,
+                                status: anilistShow.status,
+                                episodeCount: anilistShow.episodeCount != null ? Number(anilistShow.episodeCount) : undefined,
+                                type: anilistShow.type,
+                                anilistId: anilistShow.anilistId,
+                            });
+                        }
+                    }
+                    catch (err) {
+                        logger_1.default.warn({ err, provider: providerKey, showId }, '[Video] AniList metadata lookup failed while resolving numeric showId');
+                    }
+                }
+                if (targetTitle) {
+                    let romaji = anilistShow?.names?.romaji;
+                    let nativeName = anilistShow?.names?.native;
+                    let synonyms = anilistShow?.names?.synonyms;
+                    if (!romaji || !nativeName) {
+                        try {
+                            const show = await (0, anilist_1.getShowMetaById)(showId);
+                            romaji = romaji || show?.names?.romaji;
+                            nativeName = nativeName || show?.names?.native;
+                            synonyms = synonyms || show?.names?.synonyms;
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    const titleTargets = [
+                        targetTitle,
+                        romaji,
+                        nativeName,
+                        ...(synonyms ?? []).slice(0, 2),
+                    ].filter((t) => !!t && t.trim().length > 0);
+                    const distinctTargets = [...new Set(titleTargets.map((t) => t.trim()))].filter((t, i, a) => a.findIndex((x) => x.toLowerCase() === t.toLowerCase()) === i);
+                    let resolved = null;
+                    for (const variant of distinctTargets) {
+                        try {
+                            resolved =
+                                (await this.providers[providerKey]?.resolveShowId?.(variant, romaji, req.query.mode)) ?? null;
+                        }
+                        catch {
+                            resolved = null;
+                        }
+                        if (resolved)
+                            break;
+                    }
+                    if (resolved) {
+                        showId = resolved;
+                    }
+                    else {
+                        logger_1.default.warn({ provider: providerKey, showId, title: targetTitle, romaji }, '[Video] resolveShowId failed, attempting fallback provider search');
+                        try {
+                            const fallbackResults = await this.providers[providerKey]?.search?.({
+                                query: targetTitle,
+                            });
+                            const fallbackMatch = (0, title_matching_1.pickBestMatch)((fallbackResults || []).map((r) => ({
+                                title: r.name || r.englishName || '',
+                                id: r.id || r._id || '',
+                            })), distinctTargets);
+                            if (fallbackMatch) {
+                                showId = fallbackMatch.item.id;
+                            }
+                            else {
+                                logger_1.default.warn({ provider: providerKey, showId, title: targetTitle }, '[Video] fallback provider search returned no results');
+                                return res.json([]);
+                            }
+                        }
+                        catch (fallbackErr) {
+                            if (fallbackErr.message === 'AUTH_REQUIRED') {
+                                throw fallbackErr;
+                            }
+                            logger_1.default.error({ err: fallbackErr, provider: providerKey, showId, title: targetTitle }, '[Video] fallback provider search failed');
+                            return res.json([]);
+                        }
+                    }
+                }
+                else {
+                    logger_1.default.warn({ provider: providerKey, showId }, '[Video] numeric showId passed to provider but local meta missing title');
+                    return res.json([]);
+                }
+            }
+            const provider = this.getProvider(req);
+            if (!provider)
+                return res.json([]);
+            const urls = await provider.getStreamUrls(showId, req.query.episodeNumber, req.query.mode);
+            res.json(urls || []);
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            logger_1.default.error({ err: e, provider: req.query.provider }, 'Provider video fetch failed');
+            res.json([]);
+        }
+    };
+    getEpisodes = async (req, res) => {
+        const showIdRaw = req.query.showId;
+        if (!showIdRaw) {
+            return res.json({ episodes: [] });
+        }
+        let showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        const epsMalId = (0, anilist_1.parseMalId)(showId);
+        if (epsMalId) {
+            try {
+                const malMeta = await (0, anilist_1.getShowMetaByMalId)(epsMalId);
+                if (malMeta?.anilistId && malMeta.anilistId > 0)
+                    showId = String(malMeta.anilistId);
+            }
+            catch {
+                // ignore
+            }
+        }
+        if ((0, temp_ids_1.isTempShowId)(showId)) {
+            try {
+                const row = temp_show_ids_repository_1.TempShowIdsRepository.getById(req.db, showId);
+                if (!row || !(0, temp_ids_1.isTempMatureProvider)(row.provider))
+                    return res.json({ episodes: [] });
+                const wanted = String(req.query.provider || '').toLowerCase();
+                const own = this.providers[row.provider];
+                if (own && (!wanted || wanted === row.provider)) {
+                    const data = await own.getEpisodes(row.nativeId, req.query.mode);
+                    if (data?.episodes?.length)
+                        return res.json(data);
+                    return res.json({ episodes: [] });
+                }
+                const hit = await this.resolveMatureStreamingId(row.title, wanted);
+                if (hit) {
+                    const data = await hit.provider.getEpisodes(hit.nativeId, req.query.mode);
+                    if (data?.episodes?.length)
+                        return res.json(data);
+                }
+            }
+            catch {
+                // ignore
+            }
+            return res.json({ episodes: [] });
+        }
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(showId)) {
+            try {
+                if (this.providers['animepahe']) {
+                    const data = await this.providers['animepahe'].getEpisodes(showId, req.query.mode);
+                    return res.json(data || { episodes: [] });
+                }
+            }
+            catch {
+                return res.json({ episodes: [] });
+            }
+        }
+        const isNumeric = /^(mal-\d+|-?\d+)$/i.test(showId);
+        if (isNumeric) {
+            let episodes = [];
+            try {
+                episodes = await (0, anilist_1.getAnilistEpisodes)(showId);
+            }
+            catch (e) {
+                logger_1.default.error({ err: e, showId }, 'Episodes fetch failed');
+            }
+            if (episodes.length === 0) {
+                const absId = Math.abs(parseInt(showId, 10));
+                if (!Number.isFinite(absId)) {
+                    res.set('Cache-Control', 'public, max-age=3600').json({ episodes });
+                    return;
+                }
+                try {
+                    const d = await (0, mal_1.malAnimeDetail)((0, mal_cache_repository_1.malCacheStore)(), absId);
+                    const total = d.detail?.episodes;
+                    if (total && total > 0 && total <= 500) {
+                        episodes = Array.from({ length: total }, (_, i) => (i + 1).toString());
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+            res.set('Cache-Control', 'public, max-age=3600').json({ episodes });
+            return;
+        }
+        const providerName = req.query.provider?.toLowerCase();
+        const provider = providerName ? this.providers[providerName] : undefined;
+        if (provider) {
+            try {
+                const data = await provider.getEpisodes(showId, req.query.mode);
+                if (data?.episodes?.length) {
+                    return res.json(data);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        res.json({ episodes: [] });
+    };
+    search = async (req, res) => {
+        try {
+            const query = req.query.query || '';
+            const page = parseInt(req.query.page) || 1;
+            const perPage = parseInt(req.query.limit) || 14;
+            const sort = req.query.sortBy || undefined;
+            const result = await (0, anilist_1.searchAnilist)({
+                query,
+                page,
+                perPage,
+                format: req.query.type,
+                status: req.query.status,
+                season: req.query.season,
+                seasonYear: req.query.year ? parseInt(req.query.year) : undefined,
+                countryOfOrigin: req.query.country,
+                genre: req.query.genres,
+                genre_not_in: req.query.excludeGenres
+                    ? req.query.excludeGenres.split(',')
+                    : undefined,
+                tag_not_in: req.query.excludeTags
+                    ? req.query.excludeTags.split(',')
+                    : undefined,
+                averageScore_greater: req.query.minScore
+                    ? parseInt(req.query.minScore)
+                    : undefined,
+                episodes_greater: req.query.minEpisodes
+                    ? parseInt(req.query.minEpisodes)
+                    : undefined,
+                isAdult: req.query.adult === 'true' ? true : req.query.adult === 'false' ? false : undefined,
+                sort,
+            });
+            return res.json(result);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'search failed');
+            res.json([]);
+        }
+    };
+    matureSearch = async (req, res) => {
+        try {
+            const provider = (req.query.provider || 'anilist').toLowerCase();
+            const query = req.query.query || '';
+            const page = parseInt(req.query.page) || 1;
+            const limit = parseInt(req.query.limit) || 14;
+            if (provider === 'anilist') {
+                const result = await (0, anilist_1.searchAnilist)({
+                    query,
+                    page,
+                    perPage: limit,
+                    format: req.query.type,
+                    status: req.query.status,
+                    season: req.query.season,
+                    seasonYear: req.query.year ? parseInt(req.query.year) : undefined,
+                    countryOfOrigin: req.query.country,
+                    genre: req.query.genres,
+                    genre_not_in: req.query.excludeGenres
+                        ? req.query.excludeGenres.split(',')
+                        : undefined,
+                    isAdult: true,
+                    sort: req.query.sortBy || undefined,
+                });
+                return res.json({ data: result, hasMore: result.length >= limit });
+            }
+            if (provider === 'wh') {
+                const p = this.providers['wh'];
+                const result = await p.browse({
+                    query,
+                    page,
+                    genre: req.query.genre || undefined,
+                });
+                return res.json({ data: result.shows, hasMore: result.hasMore });
+            }
+            if (provider === 'op') {
+                const p = this.providers['op'];
+                const result = await p.browse({
+                    query,
+                    page,
+                    limit,
+                    order: req.query.order || undefined,
+                    genres: req.query.genres || undefined,
+                    blacklist: req.query.blacklist || undefined,
+                    studio: req.query.studio || undefined,
+                });
+                return res.json({ data: result.shows, hasMore: result.hasMore, total: result.total });
+            }
+            if (provider === 'ht') {
+                const p = this.providers['ht'];
+                const result = await p.browse({
+                    query,
+                    limit: 40,
+                    genre: req.query.genre || undefined,
+                    page,
+                });
+                return res.json({ data: result.shows, hasMore: result.hasMore });
+            }
+            if (provider === 'hn') {
+                const p = this.providers['hn'];
+                if (!p?.browse) {
+                    const shows = await this.providers['hn'].search({ query });
+                    return res.json({
+                        data: shows.map((s) => ({ ...s, isAdult: true })),
+                        hasMore: false,
+                    });
+                }
+                const result = await p.browse({
+                    query,
+                    page,
+                    pageSize: limit,
+                    sort: req.query.sortBy || undefined,
+                    genre: req.query.genre || undefined,
+                });
+                return res.json({ data: result.shows, hasMore: result.hasMore, genres: result.genres });
+            }
+            if (provider === 'mal') {
+                const malPage = page;
+                const malLimit = 50;
+                let result = [];
+                try {
+                    result = await (0, mal_1.malSearchMedia)((0, mal_cache_repository_1.malCacheStore)(), {
+                        query,
+                        page: malPage,
+                        perPage: malLimit,
+                        format: req.query.type,
+                        status: req.query.status,
+                        genre: undefined,
+                        genre_not_in: req.query.excludeGenres
+                            ? req.query.excludeGenres.split(',')
+                            : undefined,
+                        isAdult: true,
+                        sort: req.query.sortBy || undefined,
+                        averageScore_greater: req.query.minScore
+                            ? parseInt(req.query.minScore)
+                            : undefined,
+                        episodes_greater: req.query.minEpisodes
+                            ? parseInt(req.query.minEpisodes)
+                            : undefined,
+                    });
+                }
+                catch (e) {
+                    logger_1.default.error({ err: e }, 'mal mature search failed');
+                }
+                const shows = result.map((m) => {
+                    const show = (0, anilist_1.fromAnilistMedia)(m);
+                    return { ...show, isAdult: true };
+                });
+                const sliced = shows.slice(0, limit);
+                return res.json({ data: sliced, hasMore: shows.length >= limit });
+            }
+            return res.status(400).json({ error: 'Unknown mature provider' });
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'mature search failed');
+            res.json({ data: [], hasMore: false });
+        }
+    };
+    resolveMature = async (req, res) => {
+        try {
+            const title = (req.query.title || '').trim();
+            if (!title)
+                return res.status(400).json({ error: 'title is required' });
+            const anilistResult = await (0, anilist_1.searchAnilistByTitle)(title);
+            if (anilistResult) {
+                const id = anilistResult.id;
+                return res.json({ id: typeof id === 'number' && id < 0 ? `mal-${Math.abs(id)}` : id });
+            }
+            const malResult = await (0, mal_1.malSearchTitle)((0, mal_cache_repository_1.malCacheStore)(), title);
+            if (malResult)
+                return res.json({ id: malResult, provider: 'mal' });
+            return res.status(404).json({ error: 'No match found' });
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'mature resolve failed');
+            res.status(500).json({ error: 'Resolve failed' });
+        }
+    };
+    getMatureFilters = async (_req, res) => {
+        try {
+            const { WH_GENRES } = await Promise.resolve().then(() => __importStar(require('../providers/wh.provider')));
+            const { OP_TAGS, OP_ORDERS } = await Promise.resolve().then(() => __importStar(require('../providers/op.provider')));
+            const { HT_GENRES } = await Promise.resolve().then(() => __importStar(require('../providers/ht.provider')));
+            return res.json({
+                whGenres: WH_GENRES,
+                opTags: OP_TAGS,
+                opOrders: OP_ORDERS,
+                htGenres: HT_GENRES,
+            });
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'mature filters failed');
+            res.status(500).json({ error: 'Failed to load filters' });
+        }
+    };
+    getSeasonal = async (req, res) => {
+        const page = parseInt(req.query.page) || 1;
+        const size = parseInt(req.query.size) || 14;
+        const format = req.query.format;
+        try {
+            const data = await (0, anilist_1.getSeasonal)(page, size, format);
+            this.setDataCache(res, 300, data);
+            res.json(data);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'Seasonal fetch failed');
+            res.set('Cache-Control', 'no-store').json([]);
+        }
+    };
+    getLatestReleases = async (req, res) => {
+        const format = req.query.format || 'TV';
+        const page = parseInt(req.query.page) || 1;
+        const size = parseInt(req.query.size) || 12;
+        try {
+            const data = await (0, anilist_1.getLatestReleases)(format, page, size);
+            this.setDataCache(res, 300, data);
+            res.json(data);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'Latest releases fetch failed');
+            res.set('Cache-Control', 'no-store').json([]);
+        }
+    };
+    getShowMeta = async (req, res) => {
+        const showIdRaw = req.params.id;
+        const id = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        if ((0, temp_ids_1.isTempShowId)(id)) {
+            const row = temp_show_ids_repository_1.TempShowIdsRepository.getById(req.db, id);
+            if (!row || !(0, temp_ids_1.isTempMatureProvider)(row.provider)) {
+                res.json({});
+                return;
+            }
+            res.set('Cache-Control', 'public, max-age=300').json({
+                _id: row.id,
+                id: row.id,
+                name: row.title,
+                englishName: row.title,
+                thumbnail: row.thumbnail || '',
+                type: 'TV',
+                isAdult: true,
+                status: 'UNKNOWN',
+                provider: row.provider,
+                nativeId: row.nativeId,
+            });
+            return;
+        }
+        const isNumeric = /^(mal-\d+|-?\d+)$/i.test(id);
+        if (isNumeric) {
+            let meta = null;
+            try {
+                meta = await (0, anilist_1.getShowMetaById)(id);
+            }
+            catch (e) {
+                logger_1.default.warn({ err: e, id }, 'AniList show-meta fetch failed, trying local cache');
+                const localMeta = (await shows_meta_repository_1.ShowsMetaRepository.getById(req.db, id));
+                if (localMeta) {
+                    if (typeof localMeta.genres === 'string') {
+                        try {
+                            localMeta.genres = JSON.parse(localMeta.genres);
+                        }
+                        catch {
+                            localMeta.genres = [];
+                        }
+                    }
+                    res.set('Cache-Control', 'public, max-age=3600').json(localMeta);
+                    return;
+                }
+            }
+            if (meta) {
+                const poster = meta.thumbnail?.trim() ? meta.thumbnail : undefined;
+                const hasPoster = !!poster;
+                try {
+                    shows_meta_repository_1.ShowsMetaRepository.upsert(req.db, {
+                        id,
+                        name: meta.name,
+                        thumbnail: poster,
+                        nativeName: meta.nativeName,
+                        englishName: meta.englishName,
+                        genres: meta.genres
+                            ? JSON.stringify(meta.genres.map((g) => (typeof g === 'string' ? g : g?.name)).filter(Boolean))
+                            : undefined,
+                        status: meta.status,
+                        episodeCount: meta.episodeCount != null ? Number(meta.episodeCount) : undefined,
+                        type: meta.type,
+                        anilistId: meta.anilistId,
+                    });
+                }
+                catch {
+                    // ignore
+                }
+                if (hasPoster && poster) {
+                    const existingWatchlist = (await watchlist_repository_1.WatchlistRepository.getById(req.db, id));
+                    if (existingWatchlist && existingWatchlist.thumbnail !== poster) {
+                        try {
+                            await watchlist_repository_1.WatchlistRepository.updateThumbnail(req.db, id, poster);
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    req.db.scheduleSave();
+                }
+            }
+            if (/^(mal-\d+|-\d+)$/i.test(id) && meta?.anilistId && meta.anilistId > 0) {
+                try {
+                    (0, db_utils_1.dbRun)(req.db, 'INSERT OR REPLACE INTO legacy_id_mapping (legacyId, numericId) VALUES (?, ?)', [id, String(meta.anilistId)]);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            this.setDataCache(res, 3600, meta || {});
+            res.json(meta || {});
+            return;
+        }
+        res.json({});
+    };
+    allocateTempShow = async (req, res) => {
+        try {
+            const provider = String(req.body?.provider || '').toLowerCase();
+            const nativeId = String(req.body?.nativeId || '').trim();
+            const title = String(req.body?.title || '').trim();
+            const thumbnail = String(req.body?.thumbnail || '');
+            if (!provider || !this.providers[provider] || !(0, temp_ids_1.isTempMatureProvider)(provider)) {
+                return res.status(400).json({ error: 'Unknown provider' });
+            }
+            if (!nativeId || !title) {
+                return res.status(400).json({ error: 'nativeId and title are required' });
+            }
+            const row = temp_show_ids_repository_1.TempShowIdsRepository.allocate(req.db, {
+                provider,
+                nativeId,
+                title,
+                thumbnail,
+            });
+            return res.json({ id: row.id });
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'temp show allocate failed');
+            res.status(500).json({ error: 'Allocate failed' });
+        }
+    };
+    getAnilistStatus = async (_req, res) => {
+        const available = !(0, anilist_1.anilistUnavailable)();
+        if (!available) {
+            (0, anilist_1.checkAnilistStatus)().catch(() => { });
+        }
+        res.json({ available, wasDownAtBoot: (0, anilist_1.wasAnilistDownAtBoot)() });
+    };
+    getGenresAndTags = async (_req, res) => {
+        try {
+            res.json(await (0, anilist_1.getGenreTagLists)());
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'genres-and-tags failed');
+            res.status(500).json({ error: 'Failed to load genres' });
+        }
+    };
+    getSystemNotifications = async (_req, res) => {
+        const notifications = [];
+        if ((0, anilist_1.wasAnilistDownAtBoot)() && (0, anilist_1.anilistUnavailable)()) {
+            const fb = 'MAL + Kitsu';
+            notifications.push({
+                id: 'system-anilist-down',
+                type: 'system',
+                title: 'AniList API',
+                message: `AniList metadata API is currently down. dango is experiencing degraded performance. ${fb} is being used as a fallback in the meantime. Some features may be limited until service is restored.`,
+                icon: 'warning',
+                createdAt: Date.now(),
+            });
+        }
+        res.json(notifications);
+    };
+    getBatchedHome = async (req, res) => {
+        try {
+            const format = req.query.format || undefined;
+            const data = await (0, anilist_1.getBatchedHomeData)(format);
+            const isEmpty = data.trending.length === 0 && data.seasonal.length === 0 && data.spotlight.length === 0;
+            res.set('Cache-Control', isEmpty ? 'no-store' : 'public, max-age=300').json(data);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'Batched home fetch failed');
+            res.set('Cache-Control', 'no-store').json({ trending: [], seasonal: [], spotlight: [] });
+        }
+    };
+}
+exports.DataController = DataController;