@serifpersia/dango 3.0.3

package/server/dist/lib/tracker/sync.service.js

@@ -0,0 +1,312 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncAniList = syncAniList;
+exports.importFromUsername = importFromUsername;
+const anilist_tracker_1 = require("./anilist-tracker");
+const watchlist_repository_1 = require("../../repositories/watchlist.repository");
+const watched_episodes_repository_1 = require("../../repositories/watched-episodes.repository");
+const shows_meta_repository_1 = require("../../repositories/shows-meta.repository");
+const settings_repository_1 = require("../../repositories/settings.repository");
+const notifications_repository_1 = require("../../repositories/notifications.repository");
+const sync_1 = require("../../sync");
+const db_utils_1 = require("../../utils/db-utils");
+const logger_1 = __importDefault(require("../../logger"));
+const TOKEN_KEY = 'tracker_anilist_token';
+const USER_KEY = 'tracker_anilist_user';
+const SYNC_STATE_KEY = 'tracker_anilist_sync_state';
+async function readSyncState(db) {
+    const row = await settings_repository_1.SettingsRepository.getByKey(db, SYNC_STATE_KEY);
+    if (!row?.value)
+        return {};
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return {};
+    }
+}
+async function getWatchedCount(db, showId) {
+    const row = await (0, db_utils_1.dbGet)(db, 'SELECT COUNT(DISTINCT episodeNumber) as total FROM watched_episodes WHERE showId = ?', [showId]);
+    return row?.total ?? 0;
+}
+function resolveStatus(localStatus, remoteStatus, remoteUpdated, localLastSync) {
+    if (remoteUpdated > localLastSync && remoteStatus !== localStatus) {
+        return { status: remoteStatus, pull: true };
+    }
+    if (remoteStatus !== localStatus) {
+        return { status: localStatus, pull: false };
+    }
+    return { status: localStatus, pull: false };
+}
+async function syncAniList(db) {
+    const tokenRow = await settings_repository_1.SettingsRepository.getByKey(db, TOKEN_KEY);
+    const token = tokenRow?.value;
+    if (!token)
+        throw new Error('AniList is not connected. Please log in first.');
+    const tracker = new anilist_tracker_1.AniListTracker(token);
+    const viewer = await tracker.getViewer();
+    const remoteEntries = await tracker.fetchUserAnimeList(viewer.id);
+    const localItems = await watchlist_repository_1.WatchlistRepository.getAll(db);
+    const syncState = await readSyncState(db);
+    const remoteByMediaId = new Map();
+    for (const entry of remoteEntries)
+        remoteByMediaId.set(entry.mediaId, entry);
+    const localByMediaId = new Map();
+    for (const item of localItems) {
+        const meta = (await shows_meta_repository_1.ShowsMetaRepository.getById(db, item.id));
+        const anilistId = meta?.anilistId;
+        if (anilistId == null || !Number.isFinite(anilistId) || String(anilistId) !== String(item.id)) {
+            continue;
+        }
+        if (!localByMediaId.has(anilistId)) {
+            localByMediaId.set(anilistId, item);
+        }
+    }
+    const allMediaIds = new Set([
+        ...localByMediaId.keys(),
+        ...remoteByMediaId.keys(),
+        ...Object.keys(syncState)
+            .map((k) => Number.parseInt(k, 10))
+            .filter((n) => Number.isFinite(n)),
+    ]);
+    const summary = { pushed: 0, pulled: 0, merged: 0, unchanged: 0, errors: [] };
+    const watchlistUpserts = [];
+    const metaUpserts = [];
+    const watchedInserts = [];
+    const stateUpdates = {};
+    const watchlistDeletes = [];
+    const pushUpdates = [];
+    const remoteDeleteEntryIds = [];
+    const now = Math.floor(Date.now() / 1000);
+    for (const mediaId of allMediaIds) {
+        const local = localByMediaId.get(mediaId);
+        const remote = remoteByMediaId.get(mediaId);
+        const showId = String(mediaId);
+        try {
+            if (local && !remote) {
+                if (syncState[showId]) {
+                    watchlistDeletes.push(showId);
+                    stateUpdates[showId] = undefined;
+                    summary.pulled++;
+                    continue;
+                }
+                const watchedCount = await getWatchedCount(db, showId);
+                pushUpdates.push({
+                    mediaId,
+                    status: DANGO_STATUS_OR_FALLBACK(local.status),
+                    progress: watchedCount,
+                });
+                stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: now };
+                summary.pushed++;
+                continue;
+            }
+            if (!local && remote) {
+                if (syncState[showId]) {
+                    if (remote.entryId) {
+                        remoteDeleteEntryIds.push({ showId, entryId: remote.entryId });
+                        stateUpdates[showId] = undefined;
+                        summary.pushed++;
+                        continue;
+                    }
+                    stateUpdates[showId] = undefined;
+                    summary.pushed++;
+                    continue;
+                }
+                logger_1.default.debug({ mediaId, remoteStatus: remote.status }, '[AniList Sync] Remote only -> pulling to local');
+                const title = remote.title.english || remote.title.romaji || `Anime #${mediaId}`;
+                watchlistUpserts.push({
+                    id: showId,
+                    name: title,
+                    thumbnail: remote.coverImage ?? '',
+                    status: remote.status,
+                    nativeName: remote.title.native ?? '',
+                    englishName: remote.title.english ?? '',
+                    type: 'TV',
+                });
+                metaUpserts.push({
+                    id: showId,
+                    name: title,
+                    thumbnail: remote.coverImage,
+                    nativeName: remote.title.native,
+                    englishName: remote.title.english,
+                    episodeCount: remote.totalEpisodes,
+                    anilistId: mediaId,
+                });
+                if (remote.progress > 0) {
+                    watchedInserts.push({ showId, from: 1, to: remote.progress });
+                }
+                stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: remote.updatedAt };
+                summary.pulled++;
+                continue;
+            }
+            if (!local && !remote && syncState[showId]) {
+                stateUpdates[showId] = undefined;
+                continue;
+            }
+            if (local && remote) {
+                const watchedCount = await getWatchedCount(db, showId);
+                const localLastSync = syncState[showId]?.lastSyncedAt ?? 0;
+                const remoteUpdated = remote.updatedAt || 0;
+                const targetProgress = Math.max(watchedCount, remote.progress);
+                const shouldPushProgress = watchedCount > remote.progress;
+                const shouldPullProgress = remote.progress > watchedCount;
+                const { status: targetStatus, pull: pullStatus } = resolveStatus(local.status, remote.status, remoteUpdated, localLastSync);
+                const statusDiffers = remote.status !== local.status;
+                if (shouldPushProgress || (!pullStatus && statusDiffers)) {
+                    pushUpdates.push({
+                        mediaId,
+                        status: targetStatus,
+                        progress: targetProgress,
+                    });
+                    if (targetStatus !== local.status) {
+                        watchlistUpserts.push({
+                            id: showId,
+                            name: local.name,
+                            thumbnail: local.thumbnail ?? '',
+                            status: targetStatus,
+                            nativeName: local.nativeName ?? '',
+                            englishName: local.englishName ?? '',
+                            type: local.type ?? '',
+                        });
+                    }
+                    if (shouldPullProgress) {
+                        watchedInserts.push({ showId, from: watchedCount + 1, to: targetProgress });
+                    }
+                    stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: now };
+                    summary.merged++;
+                }
+                else if (pullStatus || shouldPullProgress) {
+                    if (targetStatus !== local.status) {
+                        watchlistUpserts.push({
+                            id: showId,
+                            name: local.name,
+                            thumbnail: local.thumbnail ?? '',
+                            status: targetStatus,
+                            nativeName: local.nativeName ?? '',
+                            englishName: local.englishName ?? '',
+                            type: local.type ?? '',
+                        });
+                    }
+                    if (shouldPullProgress) {
+                        watchedInserts.push({ showId, from: watchedCount + 1, to: targetProgress });
+                    }
+                    stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: remoteUpdated };
+                    summary.merged++;
+                }
+                else {
+                    summary.unchanged++;
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger_1.default.warn({ err, mediaId }, '[AniList Sync] Entry failed');
+            summary.errors.push(`${local?.name ?? `Media ${mediaId}`}: ${message}`);
+        }
+    }
+    if (pushUpdates.length > 0) {
+        const batchSize = 10;
+        for (let i = 0; i < pushUpdates.length; i += batchSize) {
+            const batch = pushUpdates.slice(i, i + batchSize);
+            await tracker.batchUpdateMediaEntries(batch);
+        }
+    }
+    if (remoteDeleteEntryIds.length > 0) {
+        const deleteBatch = remoteDeleteEntryIds.map((r) => r.entryId);
+        const batchSize = 10;
+        for (let i = 0; i < deleteBatch.length; i += batchSize) {
+            const batch = deleteBatch.slice(i, i + batchSize);
+            await tracker.batchDeleteMediaEntries(batch);
+        }
+    }
+    if (watchlistUpserts.length > 0 ||
+        metaUpserts.length > 0 ||
+        watchedInserts.length > 0 ||
+        watchlistDeletes.length > 0 ||
+        Object.keys(stateUpdates).length > 0) {
+        await (0, sync_1.performWriteTransaction)(db, (tx) => {
+            for (const item of watchlistUpserts) {
+                watchlist_repository_1.WatchlistRepository.upsert(tx, item);
+            }
+            for (const meta of metaUpserts) {
+                shows_meta_repository_1.ShowsMetaRepository.upsert(tx, meta);
+            }
+            for (const w of watchedInserts) {
+                for (let ep = w.from; ep <= w.to; ep++) {
+                    watched_episodes_repository_1.WatchedEpisodesRepository.upsert(tx, {
+                        showId: w.showId,
+                        episodeNumber: String(ep),
+                        currentTime: 0,
+                        duration: 0,
+                    });
+                }
+            }
+            for (const id of watchlistDeletes) {
+                watchlist_repository_1.WatchlistRepository.delete(tx, id);
+                watched_episodes_repository_1.WatchedEpisodesRepository.deleteByShow(tx, id);
+                notifications_repository_1.NotificationsRepository.deleteByShow(tx, id);
+            }
+            const mergedState = { ...syncState };
+            for (const [k, v] of Object.entries(stateUpdates)) {
+                if (v === undefined)
+                    delete mergedState[k];
+                else
+                    mergedState[k] = v;
+            }
+            settings_repository_1.SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(mergedState));
+        });
+    }
+    return summary;
+}
+function DANGO_STATUS_OR_FALLBACK(status) {
+    const known = ['Watching', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
+    return known.includes(status) ? status : undefined;
+}
+async function importFromUsername(db, username) {
+    const tracker = new anilist_tracker_1.AniListTracker();
+    const entries = await tracker.fetchUserAnimeList(username);
+    if (entries.length === 0)
+        return 0;
+    const now = Math.floor(Date.now() / 1000);
+    const syncState = await readSyncState(db);
+    await (0, sync_1.performWriteTransaction)(db, (tx) => {
+        for (const remote of entries) {
+            const showId = String(remote.mediaId);
+            const title = remote.title.english || remote.title.romaji || `Anime #${remote.mediaId}`;
+            watchlist_repository_1.WatchlistRepository.upsert(tx, {
+                id: showId,
+                name: title,
+                thumbnail: remote.coverImage ?? '',
+                status: remote.status,
+                nativeName: remote.title.native ?? '',
+                englishName: remote.title.english ?? '',
+                type: 'TV',
+            });
+            shows_meta_repository_1.ShowsMetaRepository.upsert(tx, {
+                id: showId,
+                name: title,
+                thumbnail: remote.coverImage,
+                nativeName: remote.title.native,
+                englishName: remote.title.english,
+                episodeCount: remote.totalEpisodes,
+                anilistId: remote.mediaId,
+            });
+            if (remote.progress > 0) {
+                for (let ep = 1; ep <= remote.progress; ep++) {
+                    watched_episodes_repository_1.WatchedEpisodesRepository.upsert(tx, {
+                        showId,
+                        episodeNumber: String(ep),
+                        currentTime: 0,
+                        duration: 0,
+                    });
+                }
+            }
+            syncState[showId] = { lastSyncedAt: now, remoteUpdatedAt: remote.updatedAt };
+        }
+        settings_repository_1.SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(syncState));
+    });
+    return entries.length;
+}

package/server/dist/logger.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pino_1 = __importDefault(require("pino"));
+const isDevelopment = process.argv.includes('--dev') || process.env.NODE_ENV === 'development';
+const logger = (0, pino_1.default)({
+    level: isDevelopment ? 'debug' : 'info',
+    transport: {
+        target: 'pino-pretty',
+        options: {
+            colorize: true,
+            translateTime: 'SYS:standard',
+            ignore: 'pid,hostname',
+        },
+    },
+});
+exports.default = logger;

package/server/dist/providers/123anime.provider.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._123AnimeProvider = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const title_matching_1 = require("./title-matching");
+const base_provider_1 = require("./base-provider");
+const BASE_URL = 'https://shirayuki-scrapper-api.onrender.com';
+class _123AnimeProvider extends base_provider_1.BaseProvider {
+    name = '123Anime';
+    normalizeSlugForSearch(title) {
+        return title
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .replace(/['"]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    /**
+     * Picks the best-matching show from a list of search results by comparing
+     * how closely each result's title / id matches the query.
+     * Scoring (highest wins):
+     *   3 – id/slug exact match
+     *   2 – title exact match (case-insensitive)
+     *   1 – title starts with query
+     *   0 – title contains query word (partial)
+     *  -1 – no match (but still returned as last resort)
+     */
+    bestMatch(results, query) {
+        const q = query.toLowerCase().trim();
+        const qSlug = this.normalizeSlugForSearch(q);
+        let best = results[0];
+        let bestScore = -1;
+        for (const s of results) {
+            const id = (s.id || s._id || '').toLowerCase();
+            const title = (s.name || '').toLowerCase();
+            let score = -1;
+            if (id === qSlug || id === q) {
+                score = 3;
+            }
+            else if (title === q) {
+                score = 2;
+            }
+            else if (title.startsWith(q)) {
+                score = 1;
+            }
+            else if (title.includes(q) || id.startsWith(qSlug)) {
+                score = 0;
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                best = s;
+                if (score === 3)
+                    break; // can't do better
+            }
+        }
+        return best;
+    }
+    extractSlugFromUrl(url) {
+        if (!url)
+            return null;
+        try {
+            const parts = url.split('/');
+            const lastPart = parts[parts.length - 1];
+            if (lastPart) {
+                return lastPart.replace(/\.(jpg|jpeg|png|webp|gif)$/i, '');
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+        return null;
+    }
+    async search(options) {
+        try {
+            const rawQuery = options.query || '';
+            const query = rawQuery
+                .replace(/["",':]/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+            const performSearch = async (q) => {
+                const url = `${BASE_URL}/search?keyword=${encodeURIComponent(q)}`;
+                const response = await fetch(url);
+                if (!response.ok)
+                    return [];
+                const data = (await response.json());
+                if (!data.success || !data.data)
+                    return [];
+                return data.data.filter((anime) => anime.title !== 'Dogge');
+            };
+            let results = await performSearch(query);
+            if (results.length === 0) {
+                const words = query.split(/\s+/).filter((w) => w.length >= 3);
+                if (words.length > 1) {
+                    const mid = Math.max(1, Math.floor(words.length / 2));
+                    const half = words.slice(0, mid).join(' ');
+                    results = await performSearch(half);
+                }
+                if (results.length === 0 && words.length > 2) {
+                    const firstThree = words.slice(0, 3).join(' ');
+                    results = await performSearch(firstThree);
+                }
+            }
+            const mapped = results.map((anime) => {
+                const imageUrl = anime.thumbnail || anime.image || anime.poster;
+                const slugFromUrl = this.extractSlugFromUrl(imageUrl);
+                const titleForSlug = anime.japanese_title || anime.title;
+                const id = anime.id || slugFromUrl || this.normalizeSlugForSearch(titleForSlug);
+                return {
+                    _id: id,
+                    id: id,
+                    name: anime.title,
+                    englishName: anime.title,
+                    thumbnail: imageUrl,
+                    type: anime.type,
+                    availableEpisodesDetail: {
+                        sub: Array.from({ length: Number(anime.episode) || 0 }, (_, i) => (i + 1).toString()),
+                        dub: [],
+                    },
+                };
+            });
+            return mapped;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, '123Anime search failed');
+            return [];
+        }
+    }
+    async resolveShowId(title, romaji, mode) {
+        const targets = [title, romaji].filter((t) => !!t && t.trim().length > 0);
+        if (targets.length === 0)
+            return null;
+        for (const variant of (0, title_matching_1.buildQueryVariants)(title, romaji)) {
+            const results = await this.search({ query: variant });
+            if (results.length === 0)
+                continue;
+            const candidates = results.map((r) => ({
+                title: r.name || r.englishName || '',
+                id: r._id ?? r.id ?? '',
+                type: (r.type || '').toLowerCase(),
+            }));
+            let pool = candidates;
+            if (mode) {
+                const modeMatched = candidates.filter((c) => c.type === mode);
+                if (modeMatched.length > 0) {
+                    pool = modeMatched;
+                }
+            }
+            const matchResult = (0, title_matching_1.pickBestMatch)(pool.map((c) => ({ title: c.title, id: c.id })), targets);
+            if (matchResult) {
+                return matchResult.item.id;
+            }
+        }
+        return null;
+    }
+    async getEpisodes(showId, mode) {
+        try {
+            const cacheKey = `123anime_eps_${showId}_${mode || 'any'}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+            const results = await this.search({ query: showId.replace(/ /g, '-') });
+            const show = results.find((s) => s.id === showId || s._id === showId) ||
+                (results.length > 0 ? this.bestMatch(results, showId) : undefined);
+            if (!show || !show.availableEpisodesDetail) {
+                logger_1.default.warn({ showId, mode, matchedShow: show }, '123Anime getEpisodes no show or episodes detail found');
+                return null;
+            }
+            const episodes = mode === 'dub'
+                ? show.availableEpisodesDetail.dub || []
+                : show.availableEpisodesDetail.sub || [];
+            const result = {
+                episodes,
+                description: '',
+            };
+            this.cache.set(cacheKey, result, 3600);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error, showId, mode }, '123Anime getEpisodes failed');
+            return null;
+        }
+    }
+    async getStreamUrls(showId, episodeNumber, mode) {
+        try {
+            const query = showId.replace(/ /g, '-');
+            const searchResults = await this.search({ query });
+            if (!searchResults || searchResults.length === 0) {
+                return null;
+            }
+            const exactMatch = searchResults.find((s) => s.id === showId || s._id === showId) || undefined;
+            const modeMatch = mode
+                ? searchResults.find((s) => (s.id || s._id) === showId && s.type === mode) ||
+                    searchResults.find((s) => s.type === mode) ||
+                    undefined
+                : undefined;
+            const match = modeMatch || exactMatch || this.bestMatch(searchResults, showId);
+            const animeId = match.id || match._id;
+            const url = `${BASE_URL}/episode-stream?id=${animeId}&ep=${episodeNumber}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                logger_1.default.warn({ url, status: response.status }, '123Anime stream request failed');
+                return null;
+            }
+            const data = (await response.json());
+            if (!data.success || !data.data) {
+                return null;
+            }
+            const streamingLink = data.data['streaming_link'] || data.data['stream'] || data.data['url'];
+            if (!streamingLink) {
+                logger_1.default.warn({ data }, '123Anime No streaming link found in response data');
+                return null;
+            }
+            const separator = streamingLink.includes('?') ? '&' : '?';
+            const finalUrl = `${streamingLink}${separator}autoplay=1`;
+            return [
+                {
+                    sourceName: '123Anime',
+                    links: [
+                        {
+                            resolutionStr: 'auto',
+                            link: finalUrl,
+                            hls: false,
+                        },
+                    ],
+                    type: 'iframe',
+                },
+            ];
+        }
+        catch (error) {
+            logger_1.default.error({ err: error, showId, episodeNumber, mode }, '123Anime getStreamUrls failed');
+            return null;
+        }
+    }
+}
+exports._123AnimeProvider = _123AnimeProvider;