@serifpersia/dango 3.3.7 → 3.3.8

package/server/dist/controllers/manga-library.controller.js

@@ -42,6 +42,60 @@ export class MangaLibraryController {
             res.json({ inLibrary: false, status: null });
         }
     };
+    getEntry = async (req, res) => {
+        try {
+            const item = MangaLibraryRepository.getById(mangaDb(req), req.params.id);
+            if (!item)
+                return res.status(404).json({ error: 'Not in library' });
+            res.json({ item });
+        }
+        catch {
+            res.status(500).json({ error: 'Failed to load entry' });
+        }
+    };
+    linkAnilist = async (req, res) => {
+        const { id, anilistId } = req.body ?? {};
+        const targetId = typeof id === 'string' ? id : '';
+        const mediaId = Number(anilistId);
+        if (!targetId || !Number.isInteger(mediaId) || mediaId <= 0) {
+            return res.status(400).json({ error: 'id and a numeric anilistId are required' });
+        }
+        try {
+            const db = mangaDb(req);
+            const row = MangaLibraryRepository.getById(db, targetId);
+            if (!row)
+                return res.status(404).json({ error: 'Library entry not found' });
+            if (String(row.provider).toLowerCase() === 'anilist') {
+                return res
+                    .status(400)
+                    .json({ error: 'Link a provider bookmark to the AniList entry, not the reverse' });
+            }
+            let progressMigrated = false;
+            await performMangaWriteTransaction(db, (tx) => {
+                MangaLibraryRepository.setAnilistId(tx, targetId, mediaId, 'manual');
+                const orphanId = `anilist:${mediaId}`;
+                if (orphanId !== targetId) {
+                    const orphan = MangaLibraryRepository.getById(tx, orphanId);
+                    const target = MangaLibraryRepository.getById(tx, targetId);
+                    const targetProgress = MangaProgressRepository.getByManga(tx, targetId);
+                    if (orphan?.lastChapterNumber &&
+                        !target?.lastChapterNumber &&
+                        targetProgress.length === 0) {
+                        MangaLibraryRepository.setProgressPointer(tx, targetId, orphan.lastChapterNumber);
+                        MangaProgressRepository.moveSyntheticChapters(tx, orphanId, targetId);
+                        progressMigrated = true;
+                    }
+                    MangaLibraryRepository.delete(tx, orphanId);
+                    MangaProgressRepository.deleteByManga(tx, orphanId);
+                }
+            });
+            res.json({ success: true, id: targetId, progressMigrated });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to link manga to AniList');
+            res.status(500).json({ error: 'Failed to link entry' });
+        }
+    };
     getLibraryIds = async (req, res) => {
         try {
             res.json({ ids: MangaLibraryRepository.getIds(mangaDb(req)) });

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

@@ -450,7 +450,11 @@ export class WatchlistController {
                 if (dual._id !== undefined)
                     dual._id = row.id;
                 try {
-                    ShowsMetaRepository.upsert(db, { id: row.id, thumbnail: poster });
+                    ShowsMetaRepository.upsert(db, {
+                        id: row.id,
+                        thumbnail: poster,
+                        popularityScore: meta?.score ?? (meta?.averageScore != null ? meta.averageScore / 10 : undefined),
+                    });
                 }
                 catch {
                     // ignore
@@ -470,6 +474,14 @@ export class WatchlistController {
         await this.sweepOfflinePosters(db);
     }
     async sweepOfflinePosters(db) {
+        try {
+            db.run(`UPDATE shows_meta SET name = (SELECT w.name FROM watchlist w WHERE w.id = shows_meta.id)
+         WHERE (name IS NULL OR TRIM(name) = '')
+         AND EXISTS (SELECT 1 FROM watchlist w WHERE w.id = shows_meta.id AND w.name IS NOT NULL AND TRIM(w.name) != '')`);
+        }
+        catch {
+            // ignore
+        }
         const [wlMissing, metaMissing] = await Promise.all([
             WatchlistRepository.getMissingThumbnails(db),
             ShowsMetaRepository.getShowIdsMissingMeta(db),

package/server/dist/lib/anilist.js

@@ -1128,11 +1128,11 @@ function extractEpisodes(result) {
     }
     return [];
 }
-export async function searchAnilistByTitle(title) {
+export async function searchAnilistByTitle(title, type = 'ANIME') {
     const query = `
     query ($search: String) {
       Page(page: 1, perPage: 5) {
-        media(search: $search, type: ANIME) {
+        media(search: $search, type: ${type}) {
           id
           title { romaji english native }
         }
@@ -1164,7 +1164,7 @@ export async function searchAnilistByTitle(title) {
             break;
     }
     if (!media || media.length === 0) {
-        if (anyFailed && anilistUnavailable()) {
+        if (anyFailed && type === 'ANIME' && anilistUnavailable()) {
             const fb = await kitsuSearchAnime({ query: title, page: 1, perPage: 5 });
             if (fb.length > 0) {
                 const best = fb[0];
@@ -1196,6 +1196,39 @@ export async function searchAnilistByTitle(title) {
     }
     return { id: best.id, title: best.title };
 }
+export async function searchAnilistMangaByTitle(title) {
+    return searchAnilistByTitle(title, 'MANGA');
+}
+const MANGA_META_FRAGMENT = `id title { romaji english native } coverImage { large }`;
+export async function getMangaMetaById(id) {
+    if (!id)
+        return null;
+    try {
+        const result = await anilistRequest(`query ($id: Int) { Media(id: $id, type: MANGA) { ${MANGA_META_FRAGMENT} } }`, { id });
+        const m = result?.data?.Media;
+        if (!m)
+            return null;
+        return { id: m.id, title: m.title ?? {}, cover: m.coverImage?.large };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getMangaMetaByMalId(malId) {
+    const absMal = Math.abs(malId);
+    if (!absMal)
+        return null;
+    try {
+        const result = await anilistRequest(`query ($id: Int) { Media(idMal: $id, type: MANGA) { ${MANGA_META_FRAGMENT} } }`, { id: absMal });
+        const m = result?.data?.Media;
+        if (!m)
+            return null;
+        return { id: m.id, title: m.title ?? {}, cover: m.coverImage?.large };
+    }
+    catch {
+        return null;
+    }
+}
 export async function getAiredEpisodesForShows(ids, startDate, endDate) {
     const dayStart = Math.floor(startDate.getTime() / 1000);
     const dayEnd = Math.floor(endDate.getTime() / 1000);

package/server/dist/lib/mal.js

@@ -913,6 +913,75 @@ export async function fetchMalUserList(username) {
     }
     return entries;
 }
+export function mapMalMangaStatusCode(status) {
+    switch (status) {
+        case 1:
+            return 'Reading';
+        case 2:
+            return 'Completed';
+        case 3:
+            return 'On-Hold';
+        case 4:
+            return 'Dropped';
+        case 6:
+            return 'Planned';
+        default:
+            return null;
+    }
+}
+export async function fetchMalMangaList(username) {
+    const user = username.trim();
+    if (!user || /[^A-Za-z0-9_-]/.test(user))
+        throw new Error('Invalid MAL username');
+    const entries = [];
+    let offset = 0;
+    for (let page = 0; page < MAL_USER_LIST_MAX_PAGES; page++) {
+        const url = `https://myanimelist.net/mangalist/${encodeURIComponent(user)}/load.json?status=7&offset=${offset}`;
+        await politeWait();
+        const res = await fetch(url, {
+            headers: { 'User-Agent': UA, Accept: 'application/json' },
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+            redirect: 'manual',
+        });
+        if (res.status === 400 || res.status === 404)
+            throw new Error(`MAL user "${user}" not found`);
+        if (res.status === 403 || res.status === 429) {
+            throw new Error(`MAL blocked the request (HTTP ${res.status}) — try again later`);
+        }
+        if (res.status >= 300 && res.status < 400) {
+            throw new Error(`MAL list for "${user}" is private or unavailable`);
+        }
+        if (!res.ok)
+            throw new Error(`MAL list fetch failed (HTTP ${res.status})`);
+        const data = await parseJsonBody(res);
+        if (!Array.isArray(data) || data.length === 0)
+            break;
+        for (const item of data) {
+            const rec = item;
+            const malId = Number(rec.manga_id);
+            if (!malId)
+                continue;
+            const titleRaw = typeof rec.manga_title === 'string' && rec.manga_title.trim() !== ''
+                ? rec.manga_title
+                : typeof rec.manga_title_eng === 'string'
+                    ? rec.manga_title_eng
+                    : '';
+            entries.push({
+                malId,
+                title: decodeHtml(titleRaw),
+                titleEnglish: typeof rec.manga_title_eng === 'string' && rec.manga_title_eng.trim() !== ''
+                    ? decodeHtml(rec.manga_title_eng)
+                    : null,
+                status: Number(rec.status) || 0,
+                chaptersRead: Number(rec.num_read_chapters ?? rec.num_chapters_read) || 0,
+            });
+        }
+        if (data.length < MAL_USER_LIST_PAGE_SIZE)
+            break;
+        offset += MAL_USER_LIST_PAGE_SIZE;
+    }
+    return entries;
+}
 export async function malLatestReleases(store, format = 'TV', page = 1, size = 12) {
     const week = await malScheduleWeek(store);
     const seen = new Map();

package/server/dist/lib/tracker/anilist-tracker.js

@@ -11,11 +11,19 @@ export const ANILIST_TO_DANGO_STATUS = {
 };
 export const DANGO_TO_ANILIST_STATUS = {
     Watching: 'CURRENT',
+    Reading: 'CURRENT',
     Completed: 'COMPLETED',
     'On-Hold': 'PAUSED',
     Dropped: 'DROPPED',
     Planned: 'PLANNING',
 };
+export const ANILIST_TO_MANGA_STATUS = {
+    CURRENT: 'Reading',
+    COMPLETED: 'Completed',
+    PAUSED: 'On-Hold',
+    DROPPED: 'Dropped',
+    PLANNING: 'Planned',
+};
 export async function exchangeAuthorizationCode() {
     throw new Error('Authorization Code flow removed — use Implicit Grant (response_type=token) instead.');
 }
@@ -143,6 +151,64 @@ export class AniListTracker {
         }
         return entries;
     }
+    async fetchUserMangaList(userIdOrName) {
+        const query = `
+      query ($userId: Int, $userName: String) {
+        MediaListCollection(userId: $userId, userName: $userName, type: MANGA) {
+          lists {
+            entries {
+              id
+              mediaId
+              status
+              progress
+              progressVolumes
+              score(format: POINT_10)
+              updatedAt
+              media {
+                id
+                idMal
+                chapters
+                volumes
+                title { romaji english native }
+                coverImage { large }
+              }
+            }
+          }
+        }
+      }
+    `;
+        const variables = typeof userIdOrName === 'number'
+            ? { userId: userIdOrName }
+            : typeof userIdOrName === 'string'
+                ? { userName: userIdOrName }
+                : {};
+        const data = await this.request(query, variables);
+        const lists = data.MediaListCollection?.lists ?? [];
+        const entries = [];
+        for (const list of lists) {
+            for (const entry of list.entries ?? []) {
+                if (!entry.media)
+                    continue;
+                if (entry.status === 'REPEATING')
+                    continue;
+                entries.push({
+                    mediaId: entry.mediaId,
+                    entryId: entry.id,
+                    idMal: entry.media.idMal ?? undefined,
+                    status: ANILIST_TO_MANGA_STATUS[entry.status] ?? 'Planned',
+                    progress: entry.progress ?? 0,
+                    progressVolumes: entry.progressVolumes ?? undefined,
+                    score: entry.score ?? undefined,
+                    updatedAt: entry.updatedAt ?? 0,
+                    title: entry.media.title ?? {},
+                    coverImage: entry.media.coverImage?.large,
+                    totalChapters: entry.media.chapters ?? undefined,
+                    totalVolumes: entry.media.volumes ?? undefined,
+                });
+            }
+        }
+        return entries;
+    }
     async updateMediaEntry(params) {
         const mutation = `
       mutation ($mediaId: Int, $status: MediaListStatus, $progress: Int, $score: Float) {