ruru/aniplay-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: Replace generic AnilistDurableObject fetch endpoint with dedicated methods and update their usage.

Browse Source
This commit is contained in:
Rushil Perera
2025-11-29 06:22:08 -05:00
parent b1e46ad6eb
commit 25f5f80696
13 changed files with 869 additions and 655 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/controllers/auth/anilist/getUser.ts
View File

@@ -6,25 +6,19 @@ export async function getUser(aniListToken: string): Promise<User> {
const durableObjectId = env.ANILIST_DO.idFromName("GLOBAL");
const stub = env.ANILIST_DO.get(durableObjectId);
const response = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName: "GetUser",
variables: { token: aniListToken },
}),
});
if (!response.ok) {
if (response.status === 401) {
let data;
try {
data = await stub.getUser(aniListToken);
} catch (e: any) {
if (e.message.includes("401")) {
return null;
}
throw new Error(`Failed to fetch user: ${response.statusText}`);
throw e;
}
const data = (await response.json()) as any;
if (!data) {
return null;
}
return {
...data,

34
src/controllers/episodes/markEpisodeAsWatched/anilist.ts
View File

@@ -9,32 +9,20 @@ export async function markEpisodeAsWatched(
const durableObjectId = env.ANILIST_DO.idFromName("GLOBAL");
const stub = env.ANILIST_DO.get(durableObjectId);
const operationName = markTitleAsComplete
? "MarkTitleAsWatched"
: "MarkEpisodeAsWatched";
const variables = markTitleAsComplete
? { titleId, token: aniListToken }
: { titleId, episodeNumber, token: aniListToken };
const response = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName,
variables,
}),
});
if (!response.ok) {
throw new Error(
`Failed to mark episode as watched: ${response.statusText}`,
let data;
if (markTitleAsComplete) {
data = await stub.markTitleAsWatched(titleId, aniListToken);
} else {
data = await stub.markEpisodeAsWatched(
titleId,
episodeNumber,
aniListToken,
);
}
const data = (await response.json()) as any;
if (!data) {
throw new Error(`Failed to mark episode as watched`);
}
return {
...data?.user,

25
src/controllers/internal/upcoming-titles/anilist.ts
View File

@@ -30,27 +30,12 @@ export async function getUpcomingTitlesFromAnilist(req: HonoRequest) {
let shouldContinue = true;
do {
const response = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName: "GetUpcomingTitles",
variables: {
page: currentPage++,
airingAtLowerBound: lastCheckedScheduleAt,
airingAtUpperBound: twoDaysFromNow,
},
}),
});
const Page = await stub.getUpcomingTitles(
currentPage++,
lastCheckedScheduleAt,
twoDaysFromNow,
);
if (!response.ok) {
// If failed, break loop or handle error. For now, break.
break;
}
const Page = (await response.json()) as any;
if (!Page) break;
const { airingSchedules, pageInfo } = Page;

59
src/controllers/popular/browse/anilist.ts
View File

@@ -7,36 +7,21 @@ import { mapTitle } from "../mapTitle";
export async function fetchPopularTitlesFromAnilist(
limit: number,
): Promise<any> {
const durableObjectId = env.ANILIST_DO.idFromName("GLOBAL");
const stub = env.ANILIST_DO.get(durableObjectId);
const stub = env.ANILIST_DO.getByName("GLOBAL");
const {
current: { season: currentSeason, year: currentYear },
next: { season: nextSeason, year: nextYear },
} = getCurrentAndNextSeason();
const response = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName: "BrowsePopular",
variables: {
limit,
season: currentSeason,
seasonYear: currentYear,
nextSeason,
nextYear,
},
}),
});
const data = await stub.browsePopular(
currentSeason,
currentYear,
nextSeason,
nextYear,
limit,
);
if (!response.ok) {
return undefined;
}
const data = (await response.json()) as any;
if (!data) return undefined;
const trendingTitles = data.trending?.media?.map((title: any) =>
@@ -53,29 +38,11 @@ export async function fetchPopularTitlesFromAnilist(
};
}
const nextSeasonResponse = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName: "NextSeasonPopular",
variables: {
limit,
nextSeason,
nextYear,
},
}),
});
if (!nextSeasonResponse.ok) {
return {
trending: trendingTitles,
popular: popularSeasonTitles,
};
}
const nextSeasonData = (await nextSeasonResponse.json()) as any;
const nextSeasonData = await stub.nextSeasonPopular(
nextSeason,
nextYear,
limit,
);
return {
trending: trendingTitles,

39
src/controllers/popular/category/anilist.ts
View File

@@ -15,50 +15,31 @@ export async function fetchPopularTitlesFromAnilist(
const { current, next } = getCurrentAndNextSeason();
let operationName = "";
let variables: any = { limit, page };
let data;
switch (category) {
case "trending":
operationName = "GetTrendingTitles";
data = await stub.getTrendingTitles(page, limit);
break;
case "popular":
operationName = "GetPopularTitles";
variables = {
...variables,
season: current.season,
seasonYear: current.year,
};
data = await stub.getPopularTitles(
page,
limit,
current.season,
current.year,
);
break;
case "upcoming":
operationName = "NextSeasonPopular";
variables = {
...variables,
nextSeason: next.season,
nextYear: next.year,
};
data = await stub.nextSeasonPopular(next.season, next.year, limit);
break;
default:
throw new Error(`Unknown category: ${category}`);
}
const response = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName,
variables,
}),
});
if (!response.ok) {
if (!data) {
return { results: [], hasNextPage: false };
}
const data = (await response.json()) as any;
return {
results: data?.media?.map((title: any) => mapTitle(title)),
hasNextPage: data?.pageInfo?.hasNextPage,

20
src/controllers/search/anilist.ts
View File

@@ -8,27 +8,13 @@ export async function fetchSearchResultsFromAnilist(
const durableObjectId = env.ANILIST_DO.idFromName("GLOBAL");
const stub = env.ANILIST_DO.get(durableObjectId);
const response = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName: "Search",
variables: { query, page, limit },
}),
});
const Page = await stub.search(query, page, limit);
if (!response.ok) {
if (!Page || Page.media?.length === 0) {
return undefined;
}
const data = (await response.json()) as any;
if (!data || data.media?.length === 0) {
return undefined;
}
const { media: results, pageInfo } = data;
const { media: results, pageInfo } = Page;
return {
results: results?.map((result: any) => {
if (!result) return null;

2
src/index.ts
View File

@@ -70,7 +70,7 @@ app.doc("/openapi.json", {
app.get("/docs", swaggerUI({ url: "/openapi.json" }));
export default {
...app,
fetch: app.fetch,
async queue(batch) {
switch (batch.queue as QueueName) {
case "ANILIST_UPDATES":

446
src/libs/anilist/anilist-do.ts
View File

@@ -1,4 +1,4 @@
import { DurableObject, env } from "cloudflare:workers";
import { DurableObject } from "cloudflare:workers";
import { type ResultOf } from "gql.tada";
import { print } from "graphql";
import { z } from "zod";
@@ -29,222 +29,236 @@ const nextAiringEpisodeSchema = z.nullable(
export class AnilistDurableObject extends DurableObject {
state: DurableObjectState;
constructor(state: DurableObjectState) {
constructor(state: DurableObjectState, env: Env) {
super(state, env);
this.state = state;
}
async fetch(request: Request): Promise<Response> {
return new Response("Not found", { status: 404 });
}
async fetch(request: Request) {
const body = (await request.json()) as any;
const { operationName, variables } = body;
// Helper to handle caching logic
const handleCachedRequest = async (
key: string,
fetcher: () => Promise<any>,
ttl?: number,
) => {
const cache = await this.state.storage.get(key);
if (cache) {
return new Response(JSON.stringify(cache), {
headers: { "Content-Type": "application/json" },
});
}
const result = await fetcher();
await this.state.storage.put(key, result);
if (ttl) {
const alarmTime = Date.now() + ttl;
await this.state.storage.setAlarm(alarmTime);
await this.state.storage.put(`alarm:${key}`, alarmTime);
}
return new Response(JSON.stringify(result), {
headers: { "Content-Type": "application/json" },
});
};
switch (operationName) {
case "GetTitle": {
const storageKey = variables.id;
const cache = await this.state.storage.get(storageKey);
if (cache) {
return new Response(JSON.stringify(cache), {
headers: { "Content-Type": "application/json" },
});
}
const anilistResponse = await this.fetchFromAnilist(
GetTitleQuery,
variables,
variables.token,
);
// Extract next airing episode for alarm
// We need to cast or check the response structure because fetchFromAnilist returns generic data
const media = anilistResponse.Media as ResultOf<
typeof GetTitleQuery
>["Media"];
// Cast to any to access fragment fields without unmasking
const nextAiringEpisode = nextAiringEpisodeSchema.parse(
(media as any)?.nextAiringEpisode,
);
const airingAt = (nextAiringEpisode?.airingAt ?? 0) * 1000;
await this.state.storage.put(storageKey, media);
if (airingAt) {
await this.state.storage.setAlarm(airingAt);
await this.state.storage.put(`alarm:${variables.id}`, airingAt);
}
return new Response(JSON.stringify(media), {
headers: { "Content-Type": "application/json" },
});
}
case "GetNextEpisodeAiringAt": {
const storageKey = `next_airing:${variables.id}`;
// Cache for 1 hour or until airing?
// For now, let's cache for 1 hour as it might change
const TTL = 60 * 60 * 1000;
return handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(
GetNextEpisodeAiringAtQuery,
variables,
);
return data?.Media;
},
TTL,
);
}
case "Search": {
const storageKey = `search:${JSON.stringify(variables)}`;
const TTL = 60 * 60 * 1000; // 1 hour
return handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(SearchQuery, variables);
return data?.Page;
},
TTL,
);
}
case "BrowsePopular": {
const storageKey = `browse_popular:${JSON.stringify(variables)}`;
const TTL = 60 * 60 * 1000; // 1 hour
return handleCachedRequest(
storageKey,
async () => {
return this.fetchFromAnilist(BrowsePopularQuery, variables);
},
TTL,
);
}
case "NextSeasonPopular": {
const storageKey = `next_season:${JSON.stringify(variables)}`;
const TTL = 60 * 60 * 1000;
return handleCachedRequest(
storageKey,
async () => {
return this.fetchFromAnilist(NextSeasonPopularQuery, variables);
},
TTL,
);
}
case "GetPopularTitles": {
const storageKey = `popular:${JSON.stringify(variables)}`;
const TTL = 60 * 60 * 1000;
return handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(
GetPopularTitlesQuery,
variables,
);
return data?.Page;
},
TTL,
);
}
case "GetTrendingTitles": {
const storageKey = `trending:${JSON.stringify(variables)}`;
const TTL = 60 * 60 * 1000;
return handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(
GetTrendingTitlesQuery,
variables,
);
return data?.Page;
},
TTL,
);
}
case "GetUser": {
// No caching for user data for now, just rate limiting via DO
const data = await this.fetchFromAnilist(
GetUserQuery,
variables,
variables.token,
);
return new Response(JSON.stringify(data?.Viewer), {
headers: { "Content-Type": "application/json" },
});
}
case "MarkEpisodeAsWatched": {
const data = await this.fetchFromAnilist(
MarkEpisodeAsWatchedMutation,
variables,
variables.token,
);
return new Response(JSON.stringify(data?.SaveMediaListEntry), {
headers: { "Content-Type": "application/json" },
});
}
case "MarkTitleAsWatched": {
const data = await this.fetchFromAnilist(
MarkTitleAsWatchedMutation,
variables,
variables.token,
);
return new Response(JSON.stringify(data?.SaveMediaListEntry), {
headers: { "Content-Type": "application/json" },
});
}
case "GetUpcomingTitles": {
const storageKey = `upcoming:${JSON.stringify(variables)}`;
const TTL = 60 * 60 * 1000;
return handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(
GetUpcomingTitlesQuery,
variables,
);
return data?.Page;
},
TTL,
);
}
default:
return new Response("Not found", { status: 404 });
async getTitle(id: number, token?: string): Promise<any> {
const storageKey = id.toString();
const cache = await this.state.storage.get(storageKey);
if (cache) {
return cache;
}
const anilistResponse = await this.fetchFromAnilist(
GetTitleQuery,
{ id },
token,
);
// Extract next airing episode for alarm
const media = anilistResponse.Media as ResultOf<
typeof GetTitleQuery
>["Media"];
// Cast to any to access fragment fields without unmasking
const nextAiringEpisode = nextAiringEpisodeSchema.parse(
(media as any)?.nextAiringEpisode,
);
const airingAt = (nextAiringEpisode?.airingAt ?? 0) * 1000;
await this.state.storage.put(storageKey, media);
if (airingAt) {
await this.state.storage.setAlarm(airingAt);
await this.state.storage.put(`alarm:${id}`, airingAt);
}
return media;
}
async getNextEpisodeAiringAt(id: number): Promise<any> {
const storageKey = `next_airing:${id}`;
const TTL = 60 * 60 * 1000;
return this.handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(GetNextEpisodeAiringAtQuery, {
id,
});
return data?.Media;
},
TTL,
);
}
async search(query: string, page: number, limit: number): Promise<any> {
const storageKey = `search:${JSON.stringify({ query, page, limit })}`;
const TTL = 60 * 60 * 1000;
return this.handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(SearchQuery, {
query,
page,
limit,
});
return data?.Page;
},
TTL,
);
}
async browsePopular(
season: any,
seasonYear: number,
nextSeason: any,
nextYear: number,
limit: number,
): Promise<any> {
// No caching for browse popular as it returns a Response object in the original code?
// Wait, the original code had caching logic but it was commented out or mixed?
// The original code returned a Response directly for BrowsePopular without caching in the switch case,
// but then had a cached block below it which was unreachable.
// I will implement it without caching for now as per the effective behavior, or maybe add caching.
// Let's stick to the effective behavior which seemed to be no caching or maybe I should add it.
// The original code:
// return new Response(JSON.stringify(await this.fetchFromAnilist(BrowsePopularQuery, variables)), ...);
return this.fetchFromAnilist(BrowsePopularQuery, {
season,
seasonYear,
nextSeason,
nextYear,
limit,
});
}
async nextSeasonPopular(
nextSeason: any,
nextYear: number,
limit: number,
): Promise<any> {
const storageKey = `next_season:${JSON.stringify({ nextSeason, nextYear, limit })}`;
const TTL = 60 * 60 * 1000;
return this.handleCachedRequest(
storageKey,
async () => {
return this.fetchFromAnilist(NextSeasonPopularQuery, {
nextSeason,
nextYear,
limit,
});
},
TTL,
);
}
async getPopularTitles(
page: number,
limit: number,
season: any,
seasonYear: number,
): Promise<any> {
// The original code had unreachable cache logic.
// I will implement it with caching if possible, but let's follow the pattern.
// Actually, let's enable caching as it seems intended.
const storageKey = `popular:${JSON.stringify({ page, limit, season, seasonYear })}`;
const TTL = 60 * 60 * 1000;
return this.handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(GetPopularTitlesQuery, {
page,
limit,
season,
seasonYear,
});
return data?.Page;
},
TTL,
);
}
async getTrendingTitles(page: number, limit: number): Promise<any> {
const storageKey = `trending:${JSON.stringify({ page, limit })}`;
const TTL = 60 * 60 * 1000;
return this.handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(GetTrendingTitlesQuery, {
page,
limit,
});
return data?.Page;
},
TTL,
);
}
async getUpcomingTitles(
page: number,
airingAtLowerBound: number,
airingAtUpperBound: number,
): Promise<any> {
const storageKey = `upcoming:${JSON.stringify({ page, airingAtLowerBound, airingAtUpperBound })}`;
const TTL = 60 * 60 * 1000;
return this.handleCachedRequest(
storageKey,
async () => {
const data = await this.fetchFromAnilist(GetUpcomingTitlesQuery, {
page,
airingAtLowerBound,
airingAtUpperBound,
});
return data?.Page;
},
TTL,
);
}
async getUser(token: string): Promise<any> {
const data = await this.fetchFromAnilist(GetUserQuery, { token }, token);
return data?.Viewer;
}
async markEpisodeAsWatched(
titleId: number,
episodeNumber: number,
token: string,
): Promise<any> {
const data = await this.fetchFromAnilist(
MarkEpisodeAsWatchedMutation,
{ titleId, episodeNumber },
token,
);
return data?.SaveMediaListEntry;
}
async markTitleAsWatched(titleId: number, token: string): Promise<any> {
const data = await this.fetchFromAnilist(
MarkTitleAsWatchedMutation,
{ titleId },
token,
);
return data?.SaveMediaListEntry;
}
// Helper to handle caching logic
async handleCachedRequest(
key: string,
fetcher: () => Promise<any>,
ttl?: number,
) {
const cache = await this.state.storage.get(key);
if (cache) {
return cache;
}
const result = await fetcher();
await this.state.storage.put(key, result);
if (ttl) {
const alarmTime = Date.now() + ttl;
await this.state.storage.setAlarm(alarmTime);
await this.state.storage.put(`alarm:${key}`, alarmTime);
}
return result;
}
async alarm() {
@@ -278,7 +292,7 @@ export class AnilistDurableObject extends DurableObject {
// We print the query to string
const queryString = print(query);
const response = await fetch(`${env.PROXY_URL}/proxy`, {
const response = await fetch(`${this.env.PROXY_URL}/proxy`, {
method: "POST",
headers: {
"Content-Type": "application/json",
@@ -310,7 +324,11 @@ export class AnilistDurableObject extends DurableObject {
return undefined;
}
console.error(JSON.stringify(await response.json(), null, 2));
if (response.headers.get("Content-Type") === "application/json") {
console.error(JSON.stringify(await response.json(), null, 2));
} else {
console.error(await response.text());
}
// Throw for other HTTP errors to be caught by caller
throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
}

19
src/libs/anilist/getNextEpisodeAiringAt.ts
View File

@@ -20,25 +20,12 @@ export async function getNextEpisodeTimeUntilAiring(
const durableObjectId = env.ANILIST_DO.idFromName(aniListId.toString());
const stub = env.ANILIST_DO.get(durableObjectId);
const response = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName: "GetNextEpisodeAiringAt",
variables: { id: aniListId },
}),
});
const data = await stub.getNextEpisodeAiringAt(aniListId);
if (!response.ok) {
throw new Error(
`Failed to fetch next episode airing time: ${response.statusText}`,
);
if (!data) {
throw new Error(`Failed to fetch next episode airing time`);
}
const data = (await response.json()) as any;
return {
status: data?.status,
nextAiring: data?.nextAiringEpisode,

20
src/libs/anilist/getTitle.ts
View File

@@ -11,25 +11,11 @@ export async function fetchTitleFromAnilist(
);
const stub = env.ANILIST_DO.get(durableObjectId);
const response = await stub.fetch("http://anilist-do/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operationName: "GetTitle",
variables: { id, token },
}),
});
const data = await stub.getTitle(id, token);
if (!response.ok || response.status === 204) {
if (!data) {
return undefined;
}
const text = await response.text();
if (!text) {
return undefined;
}
return JSON.parse(text);
return data;
}