@serifpersia/dango 3.3.4

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

@@ -0,0 +1,245 @@
+import logger from '../../logger.js';
+import { waitForAnilistSlot, applyRateLimitHeaders } from '../anilist.js';
+import { parseJsonBody } from '../../utils/http.utils.js';
+const ANILIST_GRAPHQL_ENDPOINT = 'https://graphql.anilist.co';
+export const ANILIST_TO_DANGO_STATUS = {
+    CURRENT: 'Watching',
+    COMPLETED: 'Completed',
+    PAUSED: 'On-Hold',
+    DROPPED: 'Dropped',
+    PLANNING: 'Planned',
+};
+export const DANGO_TO_ANILIST_STATUS = {
+    Watching: 'CURRENT',
+    Completed: 'COMPLETED',
+    'On-Hold': 'PAUSED',
+    Dropped: 'DROPPED',
+    Planned: 'PLANNING',
+};
+export async function exchangeAuthorizationCode() {
+    throw new Error('Authorization Code flow removed — use Implicit Grant (response_type=token) instead.');
+}
+export class AniListTracker {
+    token;
+    constructor(token) {
+        this.token = token;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async request(query, variables = {}, options = {}) {
+        const retries = options.retries ?? 3;
+        await waitForAnilistSlot();
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        };
+        if (this.token)
+            headers.Authorization = `Bearer ${this.token}`;
+        let response;
+        try {
+            response = await fetch(ANILIST_GRAPHQL_ENDPOINT, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ query, variables }),
+            });
+        }
+        catch (err) {
+            logger.error({ err }, '[AniList Tracker] Network error');
+            throw new Error('Could not reach AniList. Please try again later.', { cause: err });
+        }
+        applyRateLimitHeaders(response.headers);
+        if (response.status === 429) {
+            if (retries <= 0)
+                throw new Error('AniList rate limit reached, try again later');
+            const retryHeader = response.headers.get('retry-after');
+            const waitSeconds = retryHeader ? Number.parseInt(retryHeader, 10) || 60 : 60;
+            logger.warn({ waitSeconds }, '[AniList Tracker] Rate limited, waiting before retry');
+            await this.sleep(Math.min(waitSeconds, 60) * 1000);
+            return this.request(query, variables, { retries: retries - 1 });
+        }
+        if (!response.ok && response.status === 401) {
+            throw new Error('AniList token is invalid or expired. Please reconnect your account.');
+        }
+        if (!response.ok) {
+            throw new Error(`AniList request failed with status ${response.status}`);
+        }
+        const json = await parseJsonBody(response);
+        if (json.errors && !json.data) {
+            throw new Error(json.errors.map((e) => e.message).join(', '));
+        }
+        return json.data;
+    }
+    async getViewer() {
+        const query = `
+      query {
+        Viewer {
+          id
+          name
+          avatar { medium }
+        }
+      }
+    `;
+        const data = await this.request(query);
+        return {
+            id: data.Viewer.id,
+            name: data.Viewer.name,
+            avatar: data.Viewer.avatar?.medium,
+        };
+    }
+    async fetchUserAnimeList(userIdOrName) {
+        const query = `
+      query ($userId: Int, $userName: String) {
+        MediaListCollection(userId: $userId, userName: $userName, type: ANIME) {
+          lists {
+            entries {
+              id
+              mediaId
+              status
+              progress
+              score(format: POINT_10)
+              updatedAt
+              media {
+                id
+                idMal
+                episodes
+                duration
+                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_DANGO_STATUS[entry.status] ?? 'Planned',
+                    progress: entry.progress ?? 0,
+                    score: entry.score ?? undefined,
+                    updatedAt: entry.updatedAt ?? 0,
+                    title: entry.media.title ?? {},
+                    coverImage: entry.media.coverImage?.large,
+                    totalEpisodes: entry.media.episodes ?? undefined,
+                    episodeDuration: entry.media.duration ?? undefined,
+                });
+            }
+        }
+        return entries;
+    }
+    async updateMediaEntry(params) {
+        const mutation = `
+      mutation ($mediaId: Int, $status: MediaListStatus, $progress: Int, $score: Float) {
+        SaveMediaListEntry(mediaId: $mediaId, status: $status, progress: $progress, score: $score) {
+          id
+          mediaId
+          status
+          progress
+        }
+      }
+    `;
+        const variables = { mediaId: params.mediaId };
+        const status = params.status ? DANGO_TO_ANILIST_STATUS[params.status] : undefined;
+        if (status)
+            variables.status = status;
+        if (params.progress !== undefined)
+            variables.progress = params.progress;
+        if (params.score !== undefined)
+            variables.score = params.score;
+        return this.request(mutation, variables);
+    }
+    async batchUpdateMediaEntries(entries) {
+        if (entries.length === 0)
+            return {};
+        if (entries.length === 1) {
+            return this.updateMediaEntry(entries[0]);
+        }
+        const BATCH_SIZE = 10;
+        const results = {};
+        for (let i = 0; i < entries.length; i += BATCH_SIZE) {
+            const batch = entries.slice(i, i + BATCH_SIZE);
+            const aliases = [];
+            const variables = {};
+            const varDecls = [];
+            batch.forEach((entry, idx) => {
+                const prefix = `a${i + idx}`;
+                const args = [`mediaId: $${prefix}mediaId`];
+                variables[`${prefix}mediaId`] = entry.mediaId;
+                varDecls.push(`$${prefix}mediaId: Int!`);
+                if (entry.status) {
+                    const anilistStatus = DANGO_TO_ANILIST_STATUS[entry.status];
+                    if (anilistStatus) {
+                        args.push(`status: $${prefix}status`);
+                        variables[`${prefix}status`] = anilistStatus;
+                        varDecls.push(`$${prefix}status: MediaListStatus`);
+                    }
+                }
+                if (entry.progress !== undefined) {
+                    args.push(`progress: $${prefix}progress`);
+                    variables[`${prefix}progress`] = entry.progress;
+                    varDecls.push(`$${prefix}progress: Int`);
+                }
+                if (entry.score !== undefined) {
+                    args.push(`score: $${prefix}score`);
+                    variables[`${prefix}score`] = entry.score;
+                    varDecls.push(`$${prefix}score: Float`);
+                }
+                aliases.push(`${prefix}: SaveMediaListEntry(${args.join(', ')}) { id mediaId status progress }`);
+            });
+            const mutation = `mutation (${varDecls.join(', ')}) { ${aliases.join('\n')} }`;
+            const data = await this.request(mutation, variables);
+            if (data)
+                Object.assign(results, data);
+        }
+        return results;
+    }
+    async deleteMediaEntry(entryId) {
+        const mutation = `
+      mutation ($id: Int) {
+        DeleteMediaListEntry(id: $id) { deleted }
+      }
+    `;
+        return this.request(mutation, { id: entryId });
+    }
+    async batchDeleteMediaEntries(entryIds) {
+        if (entryIds.length === 0)
+            return {};
+        if (entryIds.length === 1) {
+            return this.deleteMediaEntry(entryIds[0]);
+        }
+        const BATCH_SIZE = 10;
+        const results = {};
+        for (let i = 0; i < entryIds.length; i += BATCH_SIZE) {
+            const batch = entryIds.slice(i, i + BATCH_SIZE);
+            const aliases = [];
+            const variables = {};
+            batch.forEach((entryId, idx) => {
+                const prefix = `d${i + idx}`;
+                aliases.push(`${prefix}: DeleteMediaListEntry(id: $${prefix}id) { deleted }`);
+                variables[`${prefix}id`] = entryId;
+            });
+            const varDecls = batch.map((_, idx) => `$d${i + idx}id: Int`).join(', ');
+            const mutation = `mutation (${varDecls}) { ${aliases.join('\n')} }`;
+            const data = await this.request(mutation, variables);
+            if (data)
+                Object.assign(results, data);
+        }
+        return results;
+    }
+}