chore: Update Vitest async test expectations and remove unused dependencies.

- migrate package management to pnpm
- migrate test suite to vitest
- also remove Anify integration

.dockerignore

@@ -0,0 +1,16 @@
+node_modules
+Dockerfile*
+docker-compose*
+.dockerignore
+.git
+.gitignore
+README.md
+LICENSE
+.vscode
+Makefile
+helm-charts
+.env
+.dev.vars
+.editorconfig
+.idea
+coverage*

.husky/pre-commit

@@ -1 +1 @@
-nlx lint-staged
+bunx lint-staged

Dockerfile

@@ -0,0 +1,41 @@
+# use the official Bun image
+# see all versions at https://hub.docker.com/r/oven/bun/tags
+FROM oven/bun:1 as base
+WORKDIR /usr/app
+
+# install dependencies into temp directory
+# this will cache them and speed up future builds
+FROM base AS install
+RUN mkdir -p /tmp/dev
+COPY package.json bun.lockb /tmp/dev/
+RUN cd /tmp/dev && bun install --frozen-lockfile
+
+# install with --production (exclude devDependencies)
+RUN mkdir -p /tmp/prod
+COPY package.json bun.lockb /tmp/prod/
+RUN cd /tmp/prod && bun install --frozen-lockfile --production
+
+# copy node_modules from temp directory
+# then copy all (non-ignored) project files into the image
+FROM base AS prerelease
+COPY --from=install /tmp/dev/node_modules node_modules
+COPY . .
+
+# [optional] tests & build
+ENV NODE_ENV=production
+RUN bun test
+RUN bun build --compile src/index.ts --outfile=aniplay
+
+# copy production dependencies and source code into final image
+FROM base AS release
+COPY --from=install /tmp/prod/node_modules node_modules
+COPY --from=prerelease /usr/app/src ./src
+COPY --from=prerelease /usr/app/package.json .
+COPY --from=prerelease /usr/app/tsconfig.json .
+# TODO: uncomment once v2 is ready
+# COPY --from=prerelease /usr/app/drizzle.config.ts .
+
+# run the app
+USER bun
+EXPOSE 3000
+ENTRYPOINT [ "bun", "run", "prod:server" ]

README.md

@@ -1,72 +1,12 @@
-# Aniplay API
+```
+npm install
+npm run dev
+```
 
-API for [Aniplay](https://github.com/silverAndroid/aniplay), built with Cloudflare Workers, Hono, and Drizzle ORM.
+```
-
+npm run deploy
-## Tech Stack
+```
-
-- **Cloudflare Workers**: Serverless execution environment.
-- **Hono**: Ultrafast web framework (OpenAPI).
-- **GraphQL**: Used internally for communicating with the [AniList](https://anilist.co) API.
-- **Drizzle ORM**: TypeScript ORM for D1 (Cloudflare's serverless SQL database).
-- **Vitest**: Testing framework.
-
-## Prerequisites
-
-- **Node.js**
-- **pnpm**: Package manager.
-
-## Getting Started
-
-1.  **Installation**
-
-    ```bash
-    pnpm install
-    ```
-
-2.  **Environment Setup**
-    Generate the environment types:
-
-    ```bash
-    pnpm exec wrangler types
-    ```
-
-3.  **Database Setup**
-    Apply migrations to the local D1 database:
-    ```bash
-    pnpm exec wrangler d1 migrations apply aniplay
-    ```
 
 ## Development
 
-### Running Locally
+If a route is internal-only or doesn't need to appear on the OpenAPI spec (that's autogenerated by Hono), use the `Hono` class. Otherwise, use the `OpenAPIHono` class from `@hono/zod-openapi`.
-
-Start the development server:
-
-```bash
-pnpm run dev
-```
-
-### Testing
-
-Run the tests using Vitest:
-
-```bash
-pnpm test
-```
-
-## Deployment
-
-Deploy to Cloudflare Workers:
-
-```bash
-pnpm run deploy
-```
-
-## Project Structure
-
-- `src/controllers`: API route handlers (titles, episodes, search, etc.)
-- `src/libs`: Shared utilities and logic (AniList integration, background tasks)
-- `src/middleware`: Middleware handlers (authentication, authorization, etc.)
-- `src/models`: Database schema and models
-- `src/scripts`: Utility scripts for maintenance and setup
-- `src/types`: TypeScript type definitions

bunfig.toml

@@ -0,0 +1,7 @@
+[test]
+preload = [
+  "./testSetup.ts",
+  "./src/mocks/consumet.ts",
+  "./src/mocks/getGoogleAuthToken.ts",
+  "./src/mocks/cloudflare.ts",
+]

package.json

@@ -6,7 +6,8 @@
   "type": "module",
   "scripts": {
     "dev": "wrangler dev src/index.ts --port 8080",
-    "deploy": "wrangler deploy --minify src/index.ts",
+    "env:generate": "tsx src/scripts/generateEnv.ts",
+    "env:verify": "tsx src/scripts/verifyEnv.ts",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
     "test": "vitest",
@@ -16,23 +17,25 @@
     "tsx": "tsx"
   },
   "dependencies": {
+    "@consumet/extensions": "github:consumet/consumet.ts#3dd0ccb",
     "@hono/swagger-ui": "^0.5.1",
-    "@hono/zod-openapi": "^1.1.6",
+    "@hono/zod-openapi": "^0.19.5",
-    "@hono/zod-validator": "^0.7.6",
+    "@hono/zod-validator": "^0.2.2",
     "drizzle-orm": "^0.44.7",
     "gql.tada": "^1.8.10",
     "graphql": "^16.12.0",
     "graphql-request": "^7.4.0",
     "hono": "^4.7.7",
     "jose": "^5.10.0",
+    "lodash.isequal": "^4.5.0",
     "lodash.mapkeys": "^4.6.0",
     "luxon": "^3.6.1",
-    "zod": "^4.2.1"
+    "zod": "^3.24.3"
   },
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "^0.10.15",
-    "@graphql-typed-document-node/core": "^3.2.0",
     "@trivago/prettier-plugin-sort-imports": "^4.3.0",
+    "@types/lodash.isequal": "^4.5.8",
     "@types/lodash.mapkeys": "^4.6.9",
     "@types/luxon": "^3.6.2",
     "@types/node": "^25.0.1",
@@ -51,6 +54,7 @@
     "ts-morph": "^22.0.0",
     "tsx": "^4.20.6",
     "typescript": "^5.8.3",
+    "util": "^0.12.5",
     "vitest": "~3.2.4",
     "wrangler": "^4.51.0",
     "zx": "8.1.5"

src/consumet.ts

@@ -0,0 +1,5 @@
+import { ANIME, META } from "@consumet/extensions";
+import fetchAdapter from "@haverstack/axios-fetch-adapter";
+
+const gogoAnime = new ANIME.Gogoanime(undefined, undefined, fetchAdapter);
+export const aniList = new META.Anilist(gogoAnime, undefined, fetchAdapter);

src/controllers/auth/anilist/index.ts

@@ -20,8 +20,8 @@ const UserSchema = z.object({
   }),
   statistics: z.object({
     minutesWatched: z.number().openapi({ type: "integer", format: "int64" }),
-    episodesWatched: z.int(),
+    episodesWatched: z.number().int(),
-    count: z.int(),
+    count: z.number().int(),
     meanScore: z.number().openapi({ type: "number", format: "float" }),
   }),
 });
@@ -129,11 +129,15 @@ app.openapi(route, async (c) => {
       let hasNextPage = true;
 
       do {
-        const { mediaList, pageInfo } = await getWatchingTitles(
+        const stub = env.ANILIST_DO.getByName(user.name!);
+        const { mediaList, pageInfo } = await stub
+          .getTitles(
             user.name!,
             currentPage++,
+            ["CURRENT", "PLANNING", "PAUSED", "REPEATING"],
             aniListToken,
-        ).then((data) => data!);
+          )
+          .then((data) => data!);
         if (!mediaList) {
           break;
         }

src/controllers/episodes/getByAniListId/index.ts

@@ -52,7 +52,7 @@ app.openapi(route, async (c) => {
   // Check if we should use mock data
   const { useMockData } = await import("~/libs/useMockData");
   if (useMockData()) {
-    const { mockEpisodes } = await import("~/mocks");
+    const { mockEpisodes } = await import("~/mocks/mockData");
 
     return c.json({
       success: true,

src/controllers/episodes/getEpisodeUrl/anify.ts

@@ -0,0 +1,64 @@
+import { sortByProperty } from "~/libs/sortByProperty";
+import type { FetchUrlResponse } from "~/types/episode/fetch-url-response";
+
+import { type SkipTime, convertSkipTime } from "./convertSkipTime";
+import {
+  audioPriority,
+  qualityPriority,
+  subtitlesPriority,
+} from "./priorities";
+
+export async function getSourcesFromAnify(
+  provider: string,
+  watchId: string,
+  aniListId: number,
+): Promise<FetchUrlResponse | null> {
+  const response = await fetch("https://anify.eltik.cc/sources", {
+    body: JSON.stringify({
+      watchId,
+      providerId: provider,
+      episodeNumber: "1",
+      id: aniListId.toString(),
+      subType: "sub",
+    }),
+    method: "POST",
+  }).then((res) => res.json() as Promise<AnifySourcesResponse>);
+  const { sources, subtitles, audio, intro, outro, headers } = response;
+
+  if (!sources || sources.length === 0) {
+    return null;
+  }
+
+  const source = sources.sort(sortByProperty(qualityPriority, "quality"))[0]
+    ?.url;
+  subtitles?.sort(sortByProperty(subtitlesPriority, "lang"));
+  audio?.sort(sortByProperty(audioPriority, "lang"));
+
+  return {
+    source,
+    audio,
+    subtitles,
+    intro: convertSkipTime(intro),
+    outro: convertSkipTime(outro),
+    headers: Object.keys(headers ?? {}).length > 0 ? headers : undefined,
+  };
+}
+
+interface AnifySourcesResponse {
+  sources: VideoSource[];
+  subtitles: LanguageSource[];
+  audio: LanguageSource[];
+  intro: SkipTime;
+  outro: SkipTime;
+  headers?: Record<string, string>;
+}
+
+interface VideoSource {
+  url: string;
+  quality: string;
+}
+
+interface LanguageSource {
+  url: string;
+  lang: string;
+}

src/controllers/episodes/getEpisodeUrl/index.ts

@@ -123,7 +123,7 @@ app.openapi(route, async (c) => {
   //  Check if we should use mock data
   const { useMockData } = await import("~/libs/useMockData");
   if (useMockData()) {
-    const { mockEpisodeUrl } = await import("~/mocks");
+    const { mockEpisodeUrl } = await import("~/mocks/mockData");
 
     return c.json({ success: true, result: mockEpisodeUrl });
   }

src/controllers/episodes/markEpisodeAsWatched/index.ts

@@ -84,7 +84,7 @@ app.openapi(route, async (c) => {
       isComplete,
     );
     if (isComplete) {
-      await updateWatchStatus(deviceId, aniListId, "COMPLETED");
+      await updateWatchStatus(c.req, deviceId, aniListId, "COMPLETED");
     }
 
     if (!user) {

src/controllers/internal/upcoming-titles/anilist.ts

@@ -15,7 +15,7 @@ type AiringSchedule = {
   id: number;
 };
 
-export async function getUpcomingTitlesFromAnilist() {
+export async function getUpcomingTitlesFromAnilist(req: HonoRequest) {
   const durableObjectId = env.ANILIST_DO.idFromName("GLOBAL");
   const stub = env.ANILIST_DO.get(durableObjectId);
 

src/controllers/internal/upcoming-titles/index.ts

@@ -9,8 +9,8 @@ import { getUpcomingTitlesFromAnilist } from "./anilist";
 
 const app = new Hono();
 
-export async function checkUpcomingTitles() {
+app.post("/", async (c) => {
-  const titles = await getUpcomingTitlesFromAnilist();
+  const titles = await getUpcomingTitlesFromAnilist(c.req);
 
   await Promise.allSettled(
     titles.map(async (title) => {
@@ -44,10 +44,6 @@ export async function checkUpcomingTitles() {
       });
     }),
   );
-}
-
-app.post("/", async (c) => {
-  await checkUpcomingTitles();
 
   return c.json(SuccessResponse, 200);
 });

src/controllers/popular/browse/index.ts

@@ -23,8 +23,8 @@ const route = createRoute({
   path: "/",
   request: {
     query: z.object({
-      limit: z.coerce
+      limit: z
-        .number()
+        .number({ coerce: true })
         .int()
         .default(10)
         .describe("The number of titles to return"),

src/controllers/popular/category/anilist.ts

@@ -30,7 +30,7 @@ export async function fetchPopularTitlesFromAnilist(
       );
       break;
     case "upcoming":
-      data = await stub.nextSeasonPopular(next.season, next.year, page, limit);
+      data = await stub.nextSeasonPopular(next.season, next.year, limit);
       break;
     default:
       throw new Error(`Unknown category: ${category}`);

src/controllers/popular/category/index.ts

@@ -22,12 +22,12 @@ const route = createRoute({
   path: "/{category}",
   request: {
     query: z.object({
-      limit: z.coerce
+      limit: z
-        .number()
+        .number({ coerce: true })
         .int()
-        .prefault(10)
+        .default(10)
         .describe("The number of titles to return"),
-      page: z.coerce.number().int().min(1).prefault(1),
+      page: z.number({ coerce: true }).int().min(1).default(1),
     }),
     params: z.object({ category: PopularCategory }),
   },

src/controllers/search/index.ts

@@ -17,8 +17,8 @@ const route = createRoute({
   request: {
     query: z.object({
       query: z.string(),
-      page: z.coerce.number().int().min(1).prefault(1),
+      page: z.number({ coerce: true }).int().min(1).default(1),
-      limit: z.coerce.number().int().prefault(10),
+      limit: z.number({ coerce: true }).int().default(10),
     }),
   },
   responses: {
@@ -41,7 +41,7 @@ app.openapi(route, async (c) => {
   // Check if we should use mock data
   const { useMockData } = await import("~/libs/useMockData");
   if (useMockData()) {
-    const { mockSearchResults } = await import("~/mocks");
+    const { mockSearchResults } = await import("~/mocks/mockData");
 
     // Paginate mock results
     const startIndex = (page - 1) * limit;

src/controllers/title/index.spec.ts

@@ -51,7 +51,7 @@ describe('requests the "/title" route', () => {
       headers: new Headers({ "x-anilist-token": "asd" }),
     });
 
-    await expect(response.json()).resolves.toMatchSnapshot();
+    expect(await response.json()).toMatchSnapshot();
     expect(response.status).toBe(200);
   });
 
@@ -63,7 +63,7 @@ describe('requests the "/title" route', () => {
 
     const response = await app.request("/title?id=10");
 
-    await expect(response.json()).resolves.toMatchSnapshot();
+    expect(await response.json()).toMatchSnapshot();
     expect(response.status).toBe(200);
   });
 
@@ -75,7 +75,7 @@ describe('requests the "/title" route', () => {
 
     const response = await app.request("/title?id=-1");
 
-    await expect(response.json()).resolves.toEqual({ success: false });
+    expect(await response.json()).toEqual({ success: false });
     expect(response.status).toBe(404);
   });
 });

src/controllers/title/index.ts

@@ -2,7 +2,6 @@ import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 
 import { fetchTitleFromAnilist } from "~/libs/anilist/getTitle";
 import { fetchFromMultipleSources } from "~/libs/fetchFromMultipleSources";
-import { userProfileMiddleware } from "~/middleware/userProfile";
 import {
   AniListIdQuerySchema,
   ErrorResponse,
@@ -10,7 +9,6 @@ import {
   SuccessResponseSchema,
 } from "~/types/schema";
 import { Title } from "~/types/title";
-import type { User } from "~/types/user";
 
 const app = new OpenAPIHono();
 
@@ -42,7 +40,6 @@ const route = createRoute({
       description: "Title could not be found",
     },
   },
-  middleware: [userProfileMiddleware],
 });
 
 app.openapi(route, async (c) => {
@@ -52,18 +49,13 @@ app.openapi(route, async (c) => {
   // Check if we should use mock data
   const { useMockData } = await import("~/libs/useMockData");
   if (useMockData()) {
-    const { mockTitleDetails } = await import("~/mocks");
+    const { mockTitleDetails } = await import("~/mocks/mockData");
 
     return c.json({ success: true, result: mockTitleDetails() }, 200);
   }
 
   const { result: title, errorOccurred } = await fetchFromMultipleSources([
-    () =>
+    () => fetchTitleFromAnilist(aniListId, aniListToken ?? undefined),
-      fetchTitleFromAnilist(
-        aniListId,
-        (c.get("user") as User)?.id,
-        aniListToken ?? undefined,
-      ),
   ]);
 
   if (errorOccurred) {

src/controllers/watch-status/anilist.ts

@@ -30,11 +30,19 @@ const DeleteMediaListEntryMutation = graphql(`
   }
 `);
 
-export async function updateWatchStatusOnAnilist(
+/** Updates the watch status for a title on Anilist. If the token is null, the watch status will not be updated.
+ *
+ * @returns true if the watch status was updated or if the token was null, false if it was not
+ */
+export async function maybeUpdateWatchStatusOnAnilist(
   titleId: number,
   watchStatus: WatchStatus | null,
-  aniListToken: string,
+  aniListToken: string | undefined,
 ) {
+  if (!aniListToken) {
+    return true;
+  }
+
   const client = new GraphQLClient("https://graphql.anilist.co/");
   const headers = new Headers({ Authorization: `Bearer ${aniListToken}` });
 

src/controllers/watch-status/index.spec.ts

@@ -22,6 +22,8 @@ vi.mock("~/mocks", () => ({
 describe("requests the /watch-status route", () => {
   const db = getTestDb(env);
   let app: typeof import("../../../src/index").app;
+  let maybeUpdateWatchStatusOnAnilist: any;
+  let queueTask: any;
   let maybeScheduleNextAiringEpisode: any;
   let removeTask: any;
 
@@ -29,6 +31,10 @@ describe("requests the /watch-status route", () => {
     await resetTestDb(db);
     vi.resetModules();
 
+    vi.doMock("./anilist", () => ({
+      maybeUpdateWatchStatusOnAnilist: vi.fn().mockResolvedValue(undefined),
+    }));
+
     vi.doMock("~/libs/tasks/queueTask", () => ({
       queueTask: vi.fn().mockResolvedValue(undefined),
     }));
@@ -46,6 +52,10 @@ describe("requests the /watch-status route", () => {
     }));
 
     app = (await import("~/index")).app;
+    maybeUpdateWatchStatusOnAnilist = (
+      await import("~/controllers/watch-status/anilist")
+    ).maybeUpdateWatchStatusOnAnilist;
+    queueTask = (await import("~/libs/tasks/queueTask")).queueTask;
     removeTask = (await import("~/libs/tasks/removeTask")).removeTask;
     maybeScheduleNextAiringEpisode = (
       await import("~/libs/maybeScheduleNextAiringEpisode")
@@ -109,6 +119,34 @@ describe("requests the /watch-status route", () => {
     expect(res.status).toBe(500);
   });
 
+  it("saving title, Anilist request fails, should succeed", async () => {
+    vi.mocked(maybeUpdateWatchStatusOnAnilist).mockRejectedValue(
+      new Error("Anilist failed"),
+    );
+
+    const res = await app.request(
+      "/watch-status",
+      {
+        method: "POST",
+        headers: new Headers({
+          "x-anilist-token": "asd",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          deviceId: "123",
+          watchStatus: "CURRENT",
+          titleId: -1,
+        }),
+      },
+      env,
+    );
+
+    await expect(res.json()).resolves.toEqual({ success: true });
+    expect(res.status).toBe(200);
+    // Should queue task if direct update fails
+    expect(queueTask).toHaveBeenCalled();
+  });
+
   it("watch status is null, should succeed", async () => {
     const res = await app.request(
       "/watch-status",

src/controllers/watch-status/index.ts

@@ -1,4 +1,5 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import type { HonoRequest } from "hono";
 
 import { AnilistUpdateType } from "~/libs/anilist/updateType.ts";
 import { maybeScheduleNextAiringEpisode } from "~/libs/maybeScheduleNextAiringEpisode";
@@ -15,12 +16,15 @@ import {
 } from "~/types/schema";
 import { WatchStatus } from "~/types/title/watchStatus";
 
+import { maybeUpdateWatchStatusOnAnilist } from "./anilist";
+
 const app = new OpenAPIHono<Cloudflare.Env>();
 
 const UpdateWatchStatusRequest = z.object({
   deviceId: z.string(),
   watchStatus: WatchStatus.nullable(),
   titleId: AniListIdSchema,
+  isRetrying: z.boolean().optional().default(false),
 });
 
 const route = createRoute({
@@ -62,6 +66,7 @@ const route = createRoute({
 });
 
 export async function updateWatchStatus(
+  req: HonoRequest,
   deviceId: string,
   titleId: number,
   watchStatus: WatchStatus | null,
@@ -79,8 +84,14 @@ export async function updateWatchStatus(
 }
 
 app.openapi(route, async (c) => {
-  const { deviceId, watchStatus, titleId } =
+  const {
-    await c.req.json<typeof UpdateWatchStatusRequest._type>();
+    deviceId,
+    watchStatus,
+    titleId,
+    isRetrying = false,
+  } = await c.req.json<typeof UpdateWatchStatusRequest._type>();
+  const aniListToken = c.req.header("X-AniList-Token");
+
   // Check if we should use mock data
   const { useMockData } = await import("~/libs/useMockData");
   if (useMockData()) {
@@ -88,24 +99,35 @@ app.openapi(route, async (c) => {
     return c.json(SuccessResponse, { status: 200 });
   }
 
+  if (!isRetrying) {
     try {
-    await updateWatchStatus(deviceId, titleId, watchStatus);
+      await updateWatchStatus(c.req, deviceId, titleId, watchStatus);
     } catch (error) {
       console.error("Error setting watch status");
       console.error(error);
       return c.json(ErrorResponse, { status: 500 });
     }
+  }
+
+  try {
+    await maybeUpdateWatchStatusOnAnilist(
+      Number(titleId),
+      watchStatus,
+      aniListToken,
+    );
+  } catch (error) {
+    console.error("Failed to update watch status on Anilist");
+    console.error(error);
+    if (isRetrying) {
+      return c.json(ErrorResponse, { status: 500 });
+    }
 
-  const aniListToken = c.req.header("X-AniList-Token");
-  if (aniListToken) {
     await queueTask(
       "ANILIST_UPDATES",
       {
-        [AnilistUpdateType.UpdateWatchStatus]: {
+        deviceId,
-          aniListToken,
-          titleId,
         watchStatus,
-        },
+        titleId,
         updateType: AnilistUpdateType.UpdateWatchStatus,
       },
       { req: c.req, scheduleConfig: { delay: { minute: 1 } } },

src/index.ts

@@ -1,16 +1,11 @@
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
-import { Duration, type DurationLike } from "luxon";
 
-import { onNewEpisode } from "~/controllers/internal/new-episode";
+import { maybeUpdateLastConnectedAt } from "~/controllers/maybeUpdateLastConnectedAt";
-import { AnilistUpdateType } from "~/libs/anilist/updateType";
-import { calculateExponentialBackoff } from "~/libs/calculateExponentialBackoff";
 import type { QueueName } from "~/libs/tasks/queueName.ts";
-import {
+
-  MAX_QUEUE_DELAY_SECONDS,
+import { onNewEpisode } from "./controllers/internal/new-episode";
-  type QueueBody,
+import type { QueueBody } from "./libs/tasks/queueTask";
-} from "~/libs/tasks/queueTask";
-import { maybeUpdateLastConnectedAt } from "~/middleware/maybeUpdateLastConnectedAt";
 
 export const app = new OpenAPIHono<{ Bindings: Env }>();
 
@@ -77,101 +72,28 @@ app.get("/docs", swaggerUI({ url: "/openapi.json" }));
 export default {
   fetch: app.fetch,
   async queue(batch) {
-    onMessageQueue(batch, async (message, queueName) => {
+    switch (batch.queue as QueueName) {
-      switch (queueName) {
       case "ANILIST_UPDATES":
-          const anilistUpdateBody =
+        batch.retryAll();
-            message.body as QueueBody["ANILIST_UPDATES"];
-          console.log("queue run", message.body);
-          switch (anilistUpdateBody.updateType) {
-            case AnilistUpdateType.UpdateWatchStatus:
-              if (!anilistUpdateBody[AnilistUpdateType.UpdateWatchStatus]) {
-                console.error(
-                  `Discarding update, unknown body ${JSON.stringify(message.body)}`,
-                );
-                return;
-              }
-
-              const { updateWatchStatusOnAnilist } =
-                await import("~/controllers/watch-status/anilist");
-              const payload =
-                anilistUpdateBody[AnilistUpdateType.UpdateWatchStatus];
-              await updateWatchStatusOnAnilist(
-                payload.titleId,
-                payload.watchStatus,
-                payload.aniListToken,
-              );
-              break;
-            default:
-              throw new Error(
-                `Unhandled update type: ${anilistUpdateBody.updateType}`,
-              );
-          }
         break;
       case "NEW_EPISODE":
-          const newEpisodeBody = message.body as QueueBody["NEW_EPISODE"];
+        for (const message of (batch as MessageBatch<QueueBody["NEW_EPISODE"]>)
+          .messages) {
           await onNewEpisode(
-            newEpisodeBody.aniListId,
+            message.body.aniListId,
-            newEpisodeBody.episodeNumber,
+            message.body.episodeNumber,
           );
-          break;
+          message.ack();
-        default:
+        }
-          throw new Error(`Unhandled queue name: ${queueName}`);
+        break;
     }
-    });
   },
   async scheduled(event, env, ctx) {
-    switch (event.cron) {
+    const { processDelayedTasks } = await import(
-      case "0 */12 * * *":
+      "~/libs/tasks/processDelayedTasks"
-        const { processDelayedTasks } =
+    );
-          await import("~/libs/tasks/processDelayedTasks");
+    await processDelayedTasks(env, ctx);
-        await processDelayedTasks(env);
-        break;
-      case "0 18 * * *":
-        const { checkUpcomingTitles } =
-          await import("~/controllers/internal/upcoming-titles");
-        await checkUpcomingTitles();
-        break;
-      default:
-        throw new Error(`Unhandled cron: ${event.cron}`);
-    }
   },
 } satisfies ExportedHandler<Env>;
 
-const retryDelayConfig: Partial<
-  Record<QueueName, { min: DurationLike; max: DurationLike }>
-> = {
-  NEW_EPISODE: {
-    min: Duration.fromObject({ hours: 1 }),
-    max: Duration.fromObject({ hours: 12 }),
-  },
-};
-
-function onMessageQueue<QN extends QueueName>(
-  messageBatch: MessageBatch<unknown>,
-  callback: (message: Message<QueueBody[QN]>, queueName: QN) => void,
-) {
-  for (const message of messageBatch.messages) {
-    try {
-      callback(message as Message<QueueBody[QN]>, messageBatch.queue as QN);
-      message.ack();
-    } catch (error) {
-      console.error(
-        `Failed to process message ${message.id} for queue ${messageBatch.queue} with body ${JSON.stringify(message.body)}`,
-      );
-      console.error(error);
-      message.retry({
-        delaySeconds: Math.min(
-          calculateExponentialBackoff({
-            attempt: message.attempts,
-            baseMin: retryDelayConfig[messageBatch.queue as QN]?.min,
-            absCap: retryDelayConfig[messageBatch.queue as QN]?.max,
-          }),
-          MAX_QUEUE_DELAY_SECONDS,
-        ),
-      });
-    }
-  }
-}
-
 export { AnilistDurableObject as AnilistDo } from "~/libs/anilist/anilist-do.ts";

src/libs/anilist/anilist-do.ts

@@ -1,7 +1,6 @@
 import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
 import { DurableObject } from "cloudflare:workers";
 import { print } from "graphql";
-import { DateTime } from "luxon";
 import { z } from "zod";
 
 import {
@@ -9,7 +8,6 @@ import {
   GetNextEpisodeAiringAtQuery,
   GetPopularTitlesQuery,
   GetTitleQuery,
-  GetTitleUserDataQuery,
   GetTrendingTitlesQuery,
   GetUpcomingTitlesQuery,
   GetUserProfileQuery,
@@ -20,13 +18,12 @@ import {
   SearchQuery,
 } from "~/libs/anilist/queries";
 import { sleep } from "~/libs/sleep.ts";
-import type { Title } from "~/types/title";
 
 const nextAiringEpisodeSchema = z.nullable(
   z.object({
-    episode: z.int(),
+    episode: z.number().int(),
-    airingAt: z.int(),
+    airingAt: z.number().int(),
-    timeUntilAiring: z.int(),
+    timeUntilAiring: z.number().int(),
   }),
 );
 
@@ -41,54 +38,30 @@ export class AnilistDurableObject extends DurableObject {
     return new Response("Not found", { status: 404 });
   }
 
-  async getTitle(
+  async getTitle(id: number, token?: string) {
-    id: number,
+    return this.handleCachedRequest(
-    userId?: number,
-    token?: string,
-  ): Promise<Title | null> {
-    const promises: Promise<any>[] = [
-      this.handleCachedRequest(
       `title:${id}`,
       async () => {
-          const anilistResponse = await this.fetchFromAnilist(GetTitleQuery, {
+        const anilistResponse = await this.fetchFromAnilist(
-            id,
+          GetTitleQuery,
-          });
+          { id },
+          token,
+        );
         return anilistResponse?.Media ?? null;
       },
       (media) => {
         if (!media) return undefined;
-
         // Cast to any to access fragment fields without unmasking
         const nextAiringEpisode = nextAiringEpisodeSchema.parse(
           (media as any)?.nextAiringEpisode,
         );
-          return nextAiringEpisode?.airingAt
+        const airingAt = (nextAiringEpisode?.airingAt ?? 0) * 1000;
-            ? DateTime.fromMillis(nextAiringEpisode?.airingAt)
+        if (airingAt) {
-            : undefined;
+          return airingAt - Date.now();
+        }
+        return undefined;
       },
-      ),
-    ];
-    promises.push(
-      userId
-        ? this.handleCachedRequest(
-            `title:${id}:${userId}`,
-            async () => {
-              const anilistResponse = await this.fetchFromAnilist(
-                GetTitleUserDataQuery,
-                { id },
-                { token },
     );
-              return anilistResponse?.Media ?? null;
-            },
-            DateTime.now().plus({ days: 1 }),
-          )
-        : Promise.resolve({ mediaListEntry: null }),
-    );
-
-    return Promise.all(promises).then(([title, userTitle]) => ({
-      ...title,
-      ...userTitle,
-    }));
   }
 
   async getNextEpisodeAiringAt(id: number) {
@@ -100,7 +73,7 @@ export class AnilistDurableObject extends DurableObject {
         });
         return data?.Media;
       },
-      DateTime.now().plus({ hours: 1 }),
+      60 * 60 * 1000,
     );
   }
 
@@ -115,7 +88,7 @@ export class AnilistDurableObject extends DurableObject {
         });
         return data?.Page;
       },
-      DateTime.now().plus({ hours: 1 }),
+      60 * 60 * 1000,
     );
   }
 
@@ -128,7 +101,8 @@ export class AnilistDurableObject extends DurableObject {
   ) {
     return this.handleCachedRequest(
       `popular:${JSON.stringify({ season, seasonYear, nextSeason, nextYear, limit })}`,
-      () => {
+      async () => {
+        console.log(nextSeason, nextYear, print(BrowsePopularQuery));
         return this.fetchFromAnilist(BrowsePopularQuery, {
           season,
           seasonYear,
@@ -137,27 +111,21 @@ export class AnilistDurableObject extends DurableObject {
           limit,
         });
       },
-      DateTime.now().plus({ days: 1 }),
+      24 * 60 * 60 * 1000,
     );
   }
 
-  async nextSeasonPopular(
+  async nextSeasonPopular(nextSeason: any, nextYear: number, limit: number) {
-    nextSeason: any,
-    nextYear: number,
-    page: number,
-    limit: number,
-  ) {
     return this.handleCachedRequest(
-      `next_season:${JSON.stringify({ nextSeason, nextYear, page, limit })}`,
+      `next_season:${JSON.stringify({ nextSeason, nextYear, limit })}`,
       async () => {
         return this.fetchFromAnilist(NextSeasonPopularQuery, {
           nextSeason,
           nextYear,
           limit,
-          page,
+        });
-        }).then((data) => data?.Page);
       },
-      DateTime.now().plus({ days: 1 }),
+      24 * 60 * 60 * 1000,
     );
   }
 
@@ -170,14 +138,15 @@ export class AnilistDurableObject extends DurableObject {
     return this.handleCachedRequest(
       `popular:${JSON.stringify({ page, limit, season, seasonYear })}`,
       async () => {
-        return this.fetchFromAnilist(GetPopularTitlesQuery, {
+        const data = await this.fetchFromAnilist(GetPopularTitlesQuery, {
           page,
           limit,
           season,
           seasonYear,
-        }).then((data) => data?.Page);
+        });
+        return data?.Page;
       },
-      DateTime.now().plus({ days: 1 }),
+      24 * 60 * 60 * 1000,
     );
   }
 
@@ -191,7 +160,7 @@ export class AnilistDurableObject extends DurableObject {
         });
         return data?.Page;
       },
-      DateTime.now().plus({ days: 1 }),
+      24 * 60 * 60 * 1000,
     );
   }
 
@@ -210,7 +179,7 @@ export class AnilistDurableObject extends DurableObject {
         });
         return data?.Page;
       },
-      DateTime.now().plus({ days: 1 }),
+      24 * 60 * 60 * 1000,
     );
   }
 
@@ -218,10 +187,10 @@ export class AnilistDurableObject extends DurableObject {
     return this.handleCachedRequest(
       `user:${token}`,
       async () => {
-        const data = await this.fetchFromAnilist(GetUserQuery, {}, { token });
+        const data = await this.fetchFromAnilist(GetUserQuery, {}, token);
         return data?.Viewer;
       },
-      DateTime.now().plus({ days: 30 }),
+      60 * 60 * 24 * 30 * 1000,
     );
   }
 
@@ -232,11 +201,11 @@ export class AnilistDurableObject extends DurableObject {
         const data = await this.fetchFromAnilist(
           GetUserProfileQuery,
           { token },
-          { token },
+          token,
         );
         return data?.Viewer;
       },
-      DateTime.now().plus({ days: 30 }),
+      60 * 60 * 24 * 30 * 1000,
     );
   }
 
@@ -248,7 +217,7 @@ export class AnilistDurableObject extends DurableObject {
     const data = await this.fetchFromAnilist(
       MarkEpisodeAsWatchedMutation,
       { titleId, episodeNumber },
-      { token },
+      token,
     );
     return data?.SaveMediaListEntry;
   }
@@ -257,7 +226,7 @@ export class AnilistDurableObject extends DurableObject {
     const data = await this.fetchFromAnilist(
       MarkTitleAsWatchedMutation,
       { titleId },
-      { token },
+      token,
     );
     return data?.SaveMediaListEntry;
   }
@@ -266,7 +235,7 @@ export class AnilistDurableObject extends DurableObject {
   async handleCachedRequest<T>(
     key: string,
     fetcher: () => Promise<T>,
-    ttl?: DateTime | ((data: T) => DateTime | undefined),
+    ttl?: number | ((data: T) => number | undefined),
   ) {
     const cache = await this.state.storage.get(key);
     console.debug(`Retrieving request ${key} from cache:`, cache != null);
@@ -278,8 +247,9 @@ export class AnilistDurableObject extends DurableObject {
     await this.state.storage.put(key, result);
 
     const calculatedTtl = typeof ttl === "function" ? ttl(result) : ttl;
-    if (calculatedTtl) {
+
-      const alarmTime = calculatedTtl.toMillis();
+    if (calculatedTtl && calculatedTtl > 0) {
+      const alarmTime = Date.now() + calculatedTtl;
       await this.state.storage.setAlarm(alarmTime);
       await this.state.storage.put(`alarm:${key}`, alarmTime);
     }
@@ -290,13 +260,11 @@ export class AnilistDurableObject extends DurableObject {
   async alarm() {
     const now = Date.now();
     const alarms = await this.state.storage.list({ prefix: "alarm:" });
-    console.debug(`Retrieved alarms from cache:`, Object.entries(alarms));
     for (const [key, ttl] of Object.entries(alarms)) {
       if (now >= ttl) {
         // The key in alarms is `alarm:${storageKey}`
         // We want to delete the storageKey
         const storageKey = key.replace("alarm:", "");
-        console.debug(`Deleting storage key ${storageKey} & alarm ${key}`);
         await this.state.storage.delete(storageKey);
         await this.state.storage.delete(key);
       }
@@ -304,13 +272,10 @@ export class AnilistDurableObject extends DurableObject {
   }
 
   async fetchFromAnilist<Result = any, Variables = any>(
-    query: TypedDocumentNode<Result, Variables>,
+    queryString: string,
     variables: Variables,
-    {
+    token?: string | undefined,
-      token,
+  ): Promise<Result> {
-      shouldRetryOnRateLimit = true,
-    }: { token?: string | undefined; shouldRetryOnRateLimit?: boolean } = {},
-  ): Promise<Result | undefined> {
     const headers: any = {
       "Content-Type": "application/json",
     };
@@ -321,7 +286,7 @@ export class AnilistDurableObject extends DurableObject {
 
     // Use the query passed in, or fallback if needed (though we expect it to be passed)
     // We print the query to string
-    const queryString = print(query);
+    // const queryString = print(query);
 
     const response = await fetch(`${this.env.PROXY_URL}/proxy`, {
       method: "POST",
@@ -340,17 +305,14 @@ export class AnilistDurableObject extends DurableObject {
     });
 
     // 1. Handle Rate Limiting (429)
-    if (shouldRetryOnRateLimit && response.status === 429) {
+    if (response.status === 429) {
       const retryAfter = await response
-        .json<{ headers: Record<string, string> }>()
+        .json()
         .then(({ headers }) => new Headers(headers).get("Retry-After"));
       console.log("429, retrying in", retryAfter);
 
       await sleep(Number(retryAfter || 1) * 1000); // specific fallback or ensure logic
-      return this.fetchFromAnilist(query, variables, {
+      return this.fetchFromAnilist(query, variables, token);
-        token,
-        shouldRetryOnRateLimit: false,
-      });
     }
 
     // 2. Handle HTTP Errors (like 404 or 500)

src/libs/anilist/getTitle.ts

@@ -5,11 +5,10 @@ import type { Title } from "~/types/title";
 
 export async function fetchTitleFromAnilist(
   id: number,
-  userId?: number | undefined,
   token?: string | undefined,
 ): Promise<Title | undefined> {
   if (useMockData()) {
-    const { mockTitleDetails } = await import("~/mocks");
+    const { mockTitleDetails } = await import("~/mocks/mockData");
     return mockTitleDetails();
   }
 
@@ -18,7 +17,8 @@ export async function fetchTitleFromAnilist(
   );
   const stub = env.ANILIST_DO.get(durableObjectId);
 
-  const data = await stub.getTitle(id, userId, token);
+  const data = await stub.getTitle(id, token);
+
   if (!data) {
     return undefined;
   }

src/libs/anilist/queries.ts

@@ -14,18 +14,6 @@ export const GetTitleQuery = graphql(
   [MediaFragment],
 );
 
-export const GetTitleUserDataQuery = graphql(`
-  query GetTitleUserData($id: Int!) {
-    Media(id: $id) {
-      mediaListEntry {
-        id
-        progress
-        status
-      }
-    }
-  }
-`);
-
 export const SearchQuery = graphql(
   `
     query Search($query: String!, $page: Int!, $limit: Int!) {
@@ -259,9 +247,8 @@ export const NextSeasonPopularQuery = graphql(
       $nextSeason: MediaSeason
       $nextYear: Int
       $limit: Int!
-      $page: Int!
     ) {
-      Page(page: $page, perPage: $limit) {
+      Page(page: 1, perPage: $limit) {
         media(
           season: $nextSeason
           seasonYear: $nextYear

src/libs/calculateExponentialBackoff.ts

@@ -1,53 +0,0 @@
-import { Duration, type DurationLike } from "luxon";
-
-interface CalculateExponentialBackoffOptions {
-  attempt: number;
-  baseMin?: DurationLike;
-  absCap?: DurationLike;
-  fuzzFactor?: number;
-}
-
-/**
- * Generates a backoff time where both the Minimum floor and Maximum ceiling
- * are "fuzzed" with jitter to prevent clustering at the edges.
- *
- * @param attempt - The current retry attempt (0-indexed).
- * @param baseMin - The nominal minimum wait time (default: 1s).
- * @param absCap - The absolute maximum wait time (default: 60s).
- * @param fuzzFactor - How much to wobble the edges (0.1 = +/- 10%).
- *
- * @returns A random duration between the nominal minimum and maximum, in seconds.
- */
-export function calculateExponentialBackoff({
-  attempt,
-  baseMin: baseMinDuration = Duration.fromObject({ minutes: 1 }),
-  absCap: absCapDuration = Duration.fromObject({ hours: 1 }),
-  fuzzFactor = 0.2,
-}: CalculateExponentialBackoffOptions): number {
-  const baseMin = Duration.fromDurationLike(baseMinDuration).as("seconds");
-  const absCap = Duration.fromDurationLike(absCapDuration).as("seconds");
-
-  // 1. Calculate nominal boundaries
-  // Example: If baseMin is 1s, the nominal boundaries are 1s, 2s, 4s, 8s... (The 'ceiling' grows exponentially)
-  const nominalMin = baseMin;
-  const nominalCeiling = Math.min(baseMin * Math.pow(2, attempt), absCap);
-
-  // 2. Fuzz the Min (The Floor)
-  // Example: If min is 1s and fuzz is 0.2, the floor becomes random between 0.8s and 1.2s
-  const minFuzz = nominalMin * fuzzFactor;
-  const fuzzedMin = nominalMin + (Math.random() * 2 * minFuzz - minFuzz);
-
-  // 3. Fuzz the Max (The Ceiling)
-  // Example: If ceiling is 4s (and fuzz is 0.2), it becomes random between 3.2s and 4.8s
-  const maxFuzz = nominalCeiling * fuzzFactor;
-  const fuzzedCeiling =
-    nominalCeiling + (Math.random() * 2 * maxFuzz - maxFuzz);
-
-  // Safety: Ensure we don't return a negative number or cross boundaries weirdly
-  // (e.g. if fuzz makes min > max, we swap or clamp)
-  const safeMin = Math.max(0, fuzzedMin);
-  const safeMax = Math.max(safeMin, fuzzedCeiling);
-
-  // 4. Return random value in the new fuzzy range
-  return safeMin + Math.random() * (safeMax - safeMin);
-}

src/libs/gcloud/getAdminSdkCredentials.ts

@@ -3,13 +3,11 @@ import mapKeys from "lodash.mapkeys";
 
 import { Case, changeStringCase } from "../changeStringCase";
 
-export function getAdminSdkCredentials(
+export function getAdminSdkCredentials(env: Cloudflare.Env = cloudflareEnv) {
-  env: Cloudflare.Env = cloudflareEnv,
-): AdminSdkCredentials {
   return mapKeys(
     JSON.parse(env.ADMIN_SDK_JSON) as AdminSdkCredentials,
     (_, key) => changeStringCase(key, Case.snake_case, Case.camelCase),
-  ) satisfies AdminSdkCredentials;
+  );
 }
 
 export interface AdminSdkCredentials {

src/libs/tasks/processDelayedTasks.spec.ts

@@ -1,158 +1,204 @@
-import { env } from "cloudflare:test";
-import { DateTime } from "luxon";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import { getTestEnv } from "../test/getTestEnv";
 import { processDelayedTasks } from "./processDelayedTasks";
 
 describe("processDelayedTasks", () => {
-  beforeEach(async () => {
+  let mockEnv: Cloudflare.Env;
-    const tasksToDelete = await env.DELAYED_TASKS.list({
+  let mockCtx: ExecutionContext;
-      prefix: "delayed-task:",
+  let kvGetSpy: ReturnType<typeof vi.fn>;
-    });
+  let kvDeleteSpy: ReturnType<typeof vi.fn>;
-    console.log(`Found ${tasksToDelete.keys.length} tasks to delete`);
+  let kvPutSpy: ReturnType<typeof vi.fn>;
-    for (const task of tasksToDelete.keys) {
+  let queueSendSpy: ReturnType<typeof vi.fn>;
-      await env.DELAYED_TASKS.delete(task.name);
+
-    }
+  beforeEach(() => {
+    kvGetSpy = vi.fn(() => Promise.resolve(null));
+    kvDeleteSpy = vi.fn(() => Promise.resolve());
+    kvPutSpy = vi.fn(() => Promise.resolve());
+    queueSendSpy = vi.fn(() => Promise.resolve());
+
+    mockEnv = {
+      DELAYED_TASKS: {
+        get: kvGetSpy,
+        delete: kvDeleteSpy,
+        put: kvPutSpy,
+        list: vi.fn(() =>
+          Promise.resolve({
+            keys: [],
+            list_complete: true as const,
+            cacheStatus: null,
+          }),
+        ),
+        getWithMetadata: vi.fn(() =>
+          Promise.resolve({ value: null, metadata: null }),
+        ),
+      } as any,
+      NEW_EPISODE: {
+        send: queueSendSpy,
+      } as any,
+      ANILIST_UPDATES: {
+        send: vi.fn(() => Promise.resolve()),
+      } as any,
+    } as any;
+
+    mockCtx = {
+      waitUntil: vi.fn(() => {}),
+      passThroughOnException: vi.fn(() => {}),
+    } as any;
   });
 
   it("handles empty KV namespace", async () => {
-    await processDelayedTasks(env);
+    await processDelayedTasks(mockEnv, mockCtx);
 
-    await expect(
+    expect(kvDeleteSpy).not.toHaveBeenCalled();
-      env.DELAYED_TASKS.list({ prefix: "delayed-task:" }).then(
+    expect(queueSendSpy).not.toHaveBeenCalled();
-        (result) => result.keys,
-      ),
-    ).resolves.toHaveLength(0);
   });
 
-  it("queues tasks within 9 hours of scheduled time", async () => {
+  it("queues tasks within 12 hours of scheduled time", async () => {
-    const now = DateTime.now();
+    const now = Math.floor(Date.now() / 1000);
-    const scheduledTime = now.plus({ hours: 6 }).toSeconds();
+    const scheduledTime = now + 6 * 3600; // 6 hours from now
+
     const taskMetadata = {
       queueName: "NEW_EPISODE",
       body: { aniListId: 123, episodeNumber: 1 },
       headers: { "Content-Type": "application/json" },
       scheduledEpochTime: scheduledTime,
       taskId: "task-1",
-      createdAt: now.minus({ hours: 18 }).toSeconds(),
+      createdAt: now - 18 * 3600,
       retryCount: 0,
     };
-    await env.DELAYED_TASKS.put(
+
-      `delayed-task:${scheduledTime}:task-1`,
+    mockEnv.DELAYED_TASKS.list = vi.fn(() =>
-      JSON.stringify(taskMetadata),
+      Promise.resolve({
+        keys: [{ name: `delayed-task:${scheduledTime}:task-1` }],
+        list_complete: true as const,
+        cacheStatus: null,
+      }),
     );
 
-    await processDelayedTasks(env);
+    kvGetSpy.mockReturnValue(Promise.resolve(JSON.stringify(taskMetadata)));
 
-    await expect(
+    await processDelayedTasks(mockEnv, mockCtx);
-      env.DELAYED_TASKS.get(`delayed-task:${scheduledTime}:task-1`),
+
-    ).resolves.toBeNull();
+    expect(queueSendSpy).toHaveBeenCalledTimes(1);
+    expect(kvDeleteSpy).toHaveBeenCalledTimes(1);
+    expect(kvDeleteSpy).toHaveBeenCalledWith(
+      `delayed-task:${scheduledTime}:task-1`,
+    );
   });
 
-  it("does not queue tasks beyond 9 hours", async () => {
+  it("does not queue tasks beyond 12 hours", async () => {
-    const now = DateTime.now();
+    const now = Math.floor(Date.now() / 1000);
-    const scheduledTime = now.plus({ hours: 24 }).toSeconds();
+    const scheduledTime = now + 24 * 3600; // 24 hours from now
+
     const taskMetadata = {
       queueName: "NEW_EPISODE",
       body: { aniListId: 456, episodeNumber: 2 },
       headers: { "Content-Type": "application/json" },
       scheduledEpochTime: scheduledTime,
       taskId: "task-2",
-      createdAt: now.toSeconds(),
+      createdAt: now,
       retryCount: 0,
     };
-    await env.DELAYED_TASKS.put(
+
-      `delayed-task:${scheduledTime}:task-2`,
+    mockEnv.DELAYED_TASKS.list = vi.fn(() =>
-      JSON.stringify(taskMetadata),
+      Promise.resolve({
+        keys: [{ name: `delayed-task:${scheduledTime}:task-2` }],
+        list_complete: true as const,
+        cacheStatus: null,
+      }),
     );
 
-    await processDelayedTasks(env);
+    kvGetSpy.mockReturnValue(Promise.resolve(JSON.stringify(taskMetadata)));
 
-    await expect(
+    await processDelayedTasks(mockEnv, mockCtx);
-      env.DELAYED_TASKS.get(`delayed-task:${scheduledTime}:task-2`),
+
-    ).resolves.toBeTruthy();
+    expect(queueSendSpy).not.toHaveBeenCalled();
+    expect(kvDeleteSpy).not.toHaveBeenCalled();
   });
 
   it("increments retry count on queue failure", async () => {
-    const now = DateTime.now();
+    const now = Math.floor(Date.now() / 1000);
-    const scheduledTime = now.plus({ hours: 1 }).toSeconds();
+    const scheduledTime = now + 1 * 3600; // 1 hour from now
+
     const taskMetadata = {
       queueName: "NEW_EPISODE",
       body: { aniListId: 789, episodeNumber: 3 },
       headers: { "Content-Type": "application/json" },
       scheduledEpochTime: scheduledTime,
       taskId: "task-3",
-      createdAt: now.minus({ hours: 23 }).toSeconds(),
+      createdAt: now - 23 * 3600,
       retryCount: 0,
     };
-    const mockEnv = getTestEnv({
+
-      NEW_EPISODE: {
+    mockEnv.DELAYED_TASKS.list = vi.fn(() =>
-        send: vi.fn().mockRejectedValue(new Error("Queue error")),
+      Promise.resolve({
-        sendBatch: vi.fn().mockRejectedValue(new Error("Queue error")),
+        keys: [{ name: `delayed-task:${scheduledTime}:task-3` }],
-      },
+        list_complete: true as const,
-    });
+        cacheStatus: null,
-    await mockEnv.DELAYED_TASKS.put(
+      }),
-      `delayed-task:${scheduledTime}:task-3`,
-      JSON.stringify(taskMetadata),
     );
 
-    await processDelayedTasks(mockEnv);
+    kvGetSpy.mockReturnValue(Promise.resolve(JSON.stringify(taskMetadata)));
+    queueSendSpy.mockRejectedValue(new Error("Queue error"));
 
-    const updatedMetadata = JSON.parse(
+    await processDelayedTasks(mockEnv, mockCtx);
-      (await mockEnv.DELAYED_TASKS.get(
+
-        `delayed-task:${scheduledTime}:task-3`,
+    expect(kvPutSpy).toHaveBeenCalledTimes(1);
-      ))!,
+    const updatedMetadata = JSON.parse(kvPutSpy.mock.calls[0][1]);
-    );
     expect(updatedMetadata.retryCount).toBe(1);
+    expect(kvDeleteSpy).not.toHaveBeenCalled();
   });
 
   it("logs alert after 3 failed attempts", async () => {
     const consoleErrorSpy = vi.fn(() => {});
     const originalConsoleError = console.error;
     console.error = consoleErrorSpy as any;
-    const now = DateTime.now();
+
-    const scheduledTime = now.plus({ hours: 1 }).toSeconds();
+    const now = Math.floor(Date.now() / 1000);
+    const scheduledTime = now + 1 * 3600;
+
     const taskMetadata = {
       queueName: "NEW_EPISODE",
-      body: { aniListId: 789, episodeNumber: 4 },
+      body: { aniListId: 999, episodeNumber: 4 },
       headers: { "Content-Type": "application/json" },
       scheduledEpochTime: scheduledTime,
       taskId: "task-4",
-      createdAt: now.minus({ hours: 23 }).toSeconds(),
+      createdAt: now - 23 * 3600,
-      retryCount: 2,
+      retryCount: 2, // Will become 3 after this failure
     };
-    const mockEnv = getTestEnv({
+
-      NEW_EPISODE: {
+    mockEnv.DELAYED_TASKS.list = vi.fn(() =>
-        send: vi.fn().mockRejectedValue(new Error("Queue error")),
+      Promise.resolve({
-        sendBatch: vi.fn().mockRejectedValue(new Error("Queue error")),
+        keys: [{ name: `delayed-task:${scheduledTime}:task-4` }],
-      },
+        list_complete: true as const,
-    });
+        cacheStatus: null,
-    await mockEnv.DELAYED_TASKS.put(
+      }),
-      `delayed-task:${scheduledTime}:task-4`,
-      JSON.stringify(taskMetadata),
     );
 
-    await processDelayedTasks(mockEnv);
+    kvGetSpy.mockReturnValue(Promise.resolve(JSON.stringify(taskMetadata)));
+    queueSendSpy.mockRejectedValue(new Error("Queue error"));
+
+    await processDelayedTasks(mockEnv, mockCtx);
 
     // Check that alert was logged
     const alertCalls = consoleErrorSpy.mock.calls.filter((call: any) =>
       call[0]?.includes("🚨 ALERT"),
     );
     expect(alertCalls.length).toBeGreaterThan(0);
+
     console.error = originalConsoleError;
   });
 
   it("handles multiple tasks in single cron run", async () => {
-    const now = DateTime.now();
+    const now = Math.floor(Date.now() / 1000);
 
     const task1Metadata = {
       queueName: "NEW_EPISODE",
       body: { aniListId: 100, episodeNumber: 1 },
       headers: { "Content-Type": "application/json" },
-      scheduledEpochTime: now.plus({ hours: 2 }).toSeconds(),
+      scheduledEpochTime: now + 2 * 3600,
       taskId: "task-1",
-      createdAt: now.minus({ hours: 20 }).toSeconds(),
+      createdAt: now - 20 * 3600,
       retryCount: 0,
     };
 
@@ -160,53 +206,47 @@ describe("processDelayedTasks", () => {
       queueName: "NEW_EPISODE",
       body: { aniListId: 200, episodeNumber: 2 },
       headers: { "Content-Type": "application/json" },
-      scheduledEpochTime: now.plus({ hours: 5 }).toSeconds(),
+      scheduledEpochTime: now + 5 * 3600,
       taskId: "task-2",
-      createdAt: now.minus({ hours: 19 }).toSeconds(),
+      createdAt: now - 19 * 3600,
       retryCount: 0,
     };
-    await env.DELAYED_TASKS.put(
+
-      `delayed-task:${task1Metadata.scheduledEpochTime}:task-1`,
+    mockEnv.DELAYED_TASKS.list = vi.fn(() =>
-      JSON.stringify(task1Metadata),
+      Promise.resolve({
-    );
+        keys: [
-    await env.DELAYED_TASKS.put(
+          { name: `delayed-task:${task1Metadata.scheduledEpochTime}:task-1` },
-      `delayed-task:${task2Metadata.scheduledEpochTime}:task-2`,
+          { name: `delayed-task:${task2Metadata.scheduledEpochTime}:task-2` },
-      JSON.stringify(task2Metadata),
+        ],
+        list_complete: true as const,
+        cacheStatus: null,
+      }),
     );
 
-    await processDelayedTasks(env);
+    kvGetSpy
+      .mockReturnValueOnce(Promise.resolve(JSON.stringify(task1Metadata)))
+      .mockReturnValueOnce(Promise.resolve(JSON.stringify(task2Metadata)));
 
-    await expect(
+    await processDelayedTasks(mockEnv, mockCtx);
-      env.DELAYED_TASKS.get(
+
-        `delayed-task:${task1Metadata.scheduledEpochTime}:task-1`,
+    expect(queueSendSpy).toHaveBeenCalledTimes(2);
-      ),
+    expect(kvDeleteSpy).toHaveBeenCalledTimes(2);
-    ).resolves.toBeNull();
-    await expect(
-      env.DELAYED_TASKS.get(
-        `delayed-task:${task2Metadata.scheduledEpochTime}:task-2`,
-      ),
-    ).resolves.toBeNull();
   });
 
   it("skips tasks with null values in KV", async () => {
-    const queueSendSpy = vi.fn().mockResolvedValue(undefined);
+    mockEnv.DELAYED_TASKS.list = vi.fn(() =>
-    const mockEnv = getTestEnv({
+      Promise.resolve({
-      NEW_EPISODE: {
+        keys: [{ name: "delayed-task:123:invalid" }],
-        send: queueSendSpy,
+        list_complete: true as const,
-        sendBatch: queueSendSpy,
+        cacheStatus: null,
-      },
+      }),
-      ANILIST_UPDATES: {
+    );
-        send: queueSendSpy,
-        sendBatch: queueSendSpy,
-      },
-    });
-    await mockEnv.DELAYED_TASKS.put(`delayed-task:123:invalid`, null);
 
-    await processDelayedTasks(mockEnv);
+    kvGetSpy.mockReturnValue(Promise.resolve(null));
+
+    await processDelayedTasks(mockEnv, mockCtx);
 
     expect(queueSendSpy).not.toHaveBeenCalled();
-    await expect(
+    expect(kvDeleteSpy).not.toHaveBeenCalled();
-      mockEnv.DELAYED_TASKS.get(`delayed-task:123:invalid`),
-    ).resolves.toBeNull();
   });
 });

src/libs/tasks/processDelayedTasks.ts

@@ -2,11 +2,15 @@ import { DateTime } from "luxon";
 
 import type { DelayedTaskMetadata } from "./delayedTask";
 import { deserializeDelayedTask } from "./delayedTask";
-import { MAX_QUEUE_DELAY_SECONDS, queueTask } from "./queueTask";
+import { queueTask } from "./queueTask";
 
+const MAX_DELAY_SECONDS = 12 * 60 * 60; // 43,200 seconds (12 hours)
 const RETRY_ALERT_THRESHOLD = 3;
 
-export async function processDelayedTasks(env: Cloudflare.Env): Promise<void> {
+export async function processDelayedTasks(
+  env: Cloudflare.Env,
+  ctx: ExecutionContext,
+): Promise<void> {
   console.log("Starting delayed task processing cron job");
 
   const kvNamespace = env.DELAYED_TASKS;
@@ -27,7 +31,7 @@ export async function processDelayedTasks(env: Cloudflare.Env): Promise<void> {
   console.log(`Found ${keys.length} delayed tasks to check`);
 
   const currentTime = Math.floor(Date.now() / 1000);
-  const maxQueueTime = currentTime + MAX_QUEUE_DELAY_SECONDS;
+  const twelveHoursFromNow = currentTime + MAX_DELAY_SECONDS;
 
   let processedCount = 0;
   let queuedCount = 0;
@@ -36,17 +40,16 @@ export async function processDelayedTasks(env: Cloudflare.Env): Promise<void> {
   for (const key of keys) {
     try {
       const value = await kvNamespace.get(key.name);
-      if (!value || value == "null") {
+      if (!value) {
-        console.warn(`Task key ${key.name} has no value, removing`);
+        console.warn(`Task key ${key.name} has no value, skipping`);
-        await kvNamespace.delete(key.name);
         continue;
       }
 
       const metadata: DelayedTaskMetadata = deserializeDelayedTask(value);
       processedCount++;
 
-      // Check if task is ready to be queued (within 9 hours of scheduled time)
+      // Check if task is ready to be queued (within 12 hours of scheduled time)
-      if (metadata.scheduledEpochTime <= maxQueueTime) {
+      if (metadata.scheduledEpochTime <= twelveHoursFromNow) {
         const remainingDelay = Math.max(
           0,
           metadata.scheduledEpochTime - currentTime,
@@ -97,7 +100,7 @@ export async function processDelayedTasks(env: Cloudflare.Env): Promise<void> {
         }
       } else {
         const hoursUntilReady =
-          (metadata.scheduledEpochTime - maxQueueTime) / 3600;
+          (metadata.scheduledEpochTime - twelveHoursFromNow) / 3600;
         console.log(
           `Task ${metadata.taskId} not ready yet (${hoursUntilReady.toFixed(1)} hours until queueable)`,
         );

src/libs/tasks/queueTask.spec.ts

@@ -35,8 +35,8 @@ describe("queueTask - delayed task handling", () => {
     (globalThis as any).crypto = { randomUUID: vi.fn(() => "test-uuid-123") };
   });
 
-  describe("tasks with delay <= 9 hours", () => {
+  describe("tasks with delay <= 12 hours", () => {
-    it("queues task directly when delay is less than 9 hours", async () => {
+    it("queues task directly when delay is less than 12 hours", async () => {
       await queueTask(
         "NEW_EPISODE",
         { aniListId: 123, episodeNumber: 1 },
@@ -52,12 +52,12 @@ describe("queueTask - delayed task handling", () => {
       expect(kvPutSpy).not.toHaveBeenCalled();
     });
 
-    it("queues task directly when delay is exactly 9 hours", async () => {
+    it("queues task directly when delay is exactly 12 hours", async () => {
       await queueTask(
         "NEW_EPISODE",
         { aniListId: 456, episodeNumber: 2 },
         {
-          scheduleConfig: { delay: { hours: 9 } },
+          scheduleConfig: { delay: { hours: 12 } },
           env: mockEnv,
         },
       );

src/libs/tasks/queueTask.ts

@@ -9,11 +9,9 @@ import type { QueueName } from "./queueName";
 
 export type QueueBody = {
   ANILIST_UPDATES: {
-    [AnilistUpdateType.UpdateWatchStatus]: {
+    deviceId: string;
-      titleId: number;
     watchStatus: WatchStatus | null;
-      aniListToken: string;
+    titleId: number;
-    };
     updateType: AnilistUpdateType;
   };
   NEW_EPISODE: { aniListId: number; episodeNumber: number };
@@ -30,10 +28,6 @@ interface QueueTaskOptionalArgs {
   env?: Cloudflare.Env;
 }
 
-export const MAX_QUEUE_DELAY_SECONDS = Duration.fromObject({ hours: 12 }).as(
-  "seconds",
-);
-
 export async function queueTask(
   queueName: QueueName,
   body: QueueBody[QueueName],
@@ -46,14 +40,17 @@ export async function queueTask(
     req?.header(),
   );
 
+  const MAX_DELAY_SECONDS = 12 * 60 * 60; // 43,200 seconds (12 hours)
+
   // If delay exceeds 12 hours, store in KV for later processing
-  if (scheduleTime > MAX_QUEUE_DELAY_SECONDS) {
+  if (scheduleTime > MAX_DELAY_SECONDS) {
     if (!env || !env.DELAYED_TASKS) {
       throw new Error("DELAYED_TASKS KV namespace not available");
     }
 
-    const { generateTaskKey, serializeDelayedTask } =
+    const { generateTaskKey, serializeDelayedTask } = await import(
-      await import("./delayedTask");
+      "./delayedTask"
+    );
     const taskId = crypto.randomUUID();
     const scheduledEpochTime = Math.floor(Date.now() / 1000) + scheduleTime;
 
@@ -79,18 +76,7 @@ export async function queueTask(
   // Otherwise, queue directly
   const contentType =
     headers["Content-Type"] === "application/json" ? "json" : "text";
-  if (env) {
+  if (!env) {
-    console.debug(
-      `Queueing task in queue ${queueName}: ${JSON.stringify(body)}`,
-    );
-    await env[queueName].send(
-      { body, headers },
-      {
-        contentType,
-        delaySeconds: scheduleTime,
-      },
-    );
-  } else {
     const Cloudflare = await import("cloudflare").then(
       ({ Cloudflare }) => Cloudflare,
     );
@@ -114,6 +100,14 @@ export async function queueTask(
       delay_seconds: scheduleTime,
       account_id: env.CLOUDFLARE_ACCOUNT_ID,
     });
+  } else {
+    await env[queueName].send(
+      { body, headers },
+      {
+        contentType,
+        delaySeconds: scheduleTime,
+      },
+    );
   }
 }
 function buildTask(
@@ -125,21 +119,16 @@ function buildTask(
   let scheduleTime: number = 0;
   if (scheduleConfig) {
     const { delay, epochTime } = scheduleConfig;
-    console.log(`scheduleConfig ${JSON.stringify(scheduleConfig)}`);
     if (epochTime) {
-      console.log(`epochTime ${epochTime}`);
+      console.log("epochTime", epochTime);
       scheduleTime = DateTime.fromSeconds(epochTime)
         .diffNow("second")
         .as("second");
     } else if (delay) {
-      console.log(`delay ${JSON.stringify(delay)}`);
+      console.log("delay", delay);
       scheduleTime = Duration.fromDurationLike(delay).as("second");
     }
   }
-  console.log(`scheduleTime ${scheduleTime}`);
-  const authorizationHeader = headers?.["X-Anilist-Token"]
-    ? { Authorization: `Bearer ${headers["X-Anilist-Token"]}` }
-    : {};
 
   switch (queueName) {
     case "ANILIST_UPDATES":
@@ -148,8 +137,8 @@ function buildTask(
         body,
         scheduleTime,
         headers: {
-          ...authorizationHeader,
           "Content-Type": "application/json",
+          "X-Anilist-Token": headers?.["X-Anilist-Token"],
         },
       };
     default:

src/libs/test/getTestEnv.ts

@@ -8,12 +8,10 @@ export function getTestEnvVariables(): Cloudflare.Env {
 export function getTestEnv({
   ADMIN_SDK_JSON = '{"client_email": "test@test.com", "project_id": "test-26g38"}',
   LOG_DB_QUERIES = "false",
-  ...mockEnv
 }: Partial<Cloudflare.Env> = {}): Cloudflare.Env {
   return {
     ...env,
     ADMIN_SDK_JSON,
     LOG_DB_QUERIES,
-    ...mockEnv,
   };
 }

src/middleware/userProfile.ts

@@ -1,25 +0,0 @@
-import { createMiddleware } from "hono/factory";
-
-import type { User } from "~/types/user";
-
-export const userProfileMiddleware = createMiddleware<
-  Cloudflare.Env & {
-    Variables: {
-      user: User;
-    };
-    Bindings: Env;
-  }
->(async (c, next) => {
-  const aniListToken = await c.req.header("X-AniList-Token");
-  if (!aniListToken) {
-    return next();
-  }
-
-  const user = await c.env.ANILIST_DO.getByName("GLOBAL").getUser(aniListToken);
-  if (!user) {
-    return c.json({ error: "User not found" }, 401);
-  }
-
-  c.set("user", user);
-  return next();
-});

src/scripts/generateEnv.ts

@@ -0,0 +1,47 @@
+import { Project } from "ts-morph";
+import { $ } from "zx";
+
+import { logStep } from "~/libs/logStep";
+
+await logStep(
+  'Re-generating "env.d.ts"',
+  () => $`wrangler types src/types/env.d.ts`.quiet(),
+  "Generated env.d.ts",
+);
+
+const secretNames = await logStep(
+  "Fetching secrets from Cloudflare",
+  async (): Promise<string[]> => {
+    const { stdout } = await $`wrangler secret list`.quiet();
+    return JSON.parse(stdout.toString()).map(
+      (secret: { name: string; type: "secret_text" }) => secret.name,
+    );
+  },
+  "Fetched secrets",
+);
+
+const project = new Project({});
+
+const envSourceFile = project.addSourceFileAtPath("src/types/env.d.ts");
+envSourceFile.insertImportDeclaration(2, {
+  isTypeOnly: true,
+  moduleSpecifier: "hono",
+  namedImports: ["Env as HonoEnv"],
+});
+envSourceFile
+  .getInterfaceOrThrow("Env")
+  .addExtends(["HonoEnv", "Record<string, unknown>"]);
+envSourceFile.getInterfaceOrThrow("Env").addProperties(
+  secretNames.map((name) => ({
+    name,
+    type: `string`,
+  })),
+);
+
+await project.save();
+
+await logStep(
+  "Formatting env.d.ts",
+  () => $`prettier --write src/types/env.d.ts`.quiet(),
+  "Formatted env.d.ts",
+);

src/scripts/ipCheck.ts

@@ -0,0 +1,29 @@
+// import { GraphQLClient } from "graphql-request";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import nodeFetch from "node-fetch";
+
+// import { GetTitleQuery } from "../libs/anilist/getTitle.ts";
+
+const agent = new HttpsProxyAgent(
+  "http://ruru:pdh!CQB@kpc3vyb3cwc@45.56.108.251:3128",
+);
+const response = await nodeFetch("https://httpbin.org/ip", { agent });
+console.log(await response.text());
+console.log(response.status);
+console.log(nodeFetch);
+
+// const client = new GraphQLClient("https://graphql.anilist.co/", {
+//   fetch: (input, init) => {
+//     console.log("custom fetch");
+//     const agent = new HttpsProxyAgent(
+//       "http://ruru:pdh!CQB@kpc3vyb3cwc@45.56.108.251:3128",
+//     );
+//     return nodeFetch(input, { ...init, agent });
+//   },
+// });
+
+// console.log(
+//   await client
+//     .request(GetTitleQuery, { id: 186794 })
+//     .then((data) => data?.Media ?? undefined),
+// );

src/scripts/verifyEnv.ts

@@ -0,0 +1,40 @@
+import { readFile } from "fs/promises";
+import { $, sleep } from "zx";
+
+import { logStep } from "~/libs/logStep";
+
+await $`cp src/types/env.d.ts /tmp/env.d.ts`.quiet();
+
+await logStep(
+  'Generating "env.d.ts"',
+  // @ts-ignore
+  () => import("./generateEnv"),
+  "Generated env.d.ts",
+);
+
+await logStep("Comparing env.d.ts", async () => {
+  function filterComments(content: Buffer) {
+    return content
+      .toString()
+      .split("\n")
+      .filter((line) => !line.trim().startsWith("//"))
+      .join("\n");
+  }
+
+  const currentFileContent = filterComments(await readFile("/tmp/env.d.ts"));
+  const generatedFileContent = filterComments(
+    await readFile("src/types/env.d.ts"),
+  );
+
+  if (currentFileContent === generatedFileContent) {
+    console.log("env.d.ts is up to date");
+    return;
+  }
+
+  const isCI = process.env["IS_CI"] === "true";
+  const vcsCommand = isCI ? "git" : "sl";
+  await $`${vcsCommand} diff src/types/env.d.ts`.stdio("inherit");
+  // add 1 second to make sure spawn completes
+  await sleep(1000);
+  throw new Error("env.d.ts is out of date");
+});

src/types/episode/fetch-url-response.ts

@@ -9,7 +9,7 @@ export const FetchUrlResponseSchema = z.object({
   audio: z.array(z.object({ url: z.string(), lang: z.string() })),
   intro: SkippableSchema,
   outro: SkippableSchema,
-  headers: z.record(z.string(), z.string()).optional(),
+  headers: z.record(z.string()).optional(),
 });
 
 export type FetchUrlResponse = z.infer<typeof FetchUrlResponse> & {

src/types/episode/index.ts

@@ -9,8 +9,8 @@ export const Episode = z.object({
   title: z.string().nullish(),
   img: z.string().nullish(),
   description: z.string().nullish(),
-  rating: z.int().nullish(),
+  rating: z.number().int().nullish(),
-  updatedAt: z.int().prefault(0).openapi({ format: "int64" }),
+  updatedAt: z.number().int().default(0).openapi({ format: "int64" }),
 });
 
 export type EpisodesResponse = z.infer<typeof EpisodesResponse>;

src/types/schema.ts

@@ -24,9 +24,9 @@ export const ErrorResponseSchema = z.object({
   success: z.literal(false).openapi({ type: "boolean" }),
 });
 
-export const NullableNumberSchema = z.int().nullable();
+export const NullableNumberSchema = z.number().int().nullable();
 
-export const AniListIdSchema = z.int().openapi({ format: "int64" });
+export const AniListIdSchema = z.number().int().openapi({ format: "int64" });
 export const AniListIdQuerySchema = z
   .string()
   .openapi({ type: "integer", format: "int64" });

src/types/title/index.ts

@@ -8,17 +8,17 @@ export type Title = z.infer<typeof Title>;
 export const Title = z.object({
   nextAiringEpisode: z.nullable(
     z.object({
-      episode: z.int(),
+      episode: z.number().int(),
-      airingAt: z.int().openapi({ format: "int64" }),
+      airingAt: z.number().int().openapi({ format: "int64" }),
-      timeUntilAiring: z.int().openapi({ format: "int64" }),
+      timeUntilAiring: z.number().int().openapi({ format: "int64" }),
     }),
   ),
   mediaListEntry: z.nullable(
     z.object({
       status: z.nullable(WatchStatus),
       progress: NullableNumberSchema,
-      id: z.int(),
+      id: z.number().int(),
-      updatedAt: z.int().openapi({ format: "int64" }).optional(),
+      updatedAt: z.number().int().openapi({ format: "int64" }).optional(),
     }),
   ),
   countryOfOrigin: countryCodeSchema,
@@ -50,5 +50,5 @@ export const Title = z.object({
     }),
   ),
   idMal: NullableNumberSchema,
-  id: z.int().openapi({ format: "int64" }),
+  id: z.number().int().openapi({ format: "int64" }),
 });

src/types/title/mediaFragment.ts

@@ -21,6 +21,11 @@ export const MediaFragment = graphql(`
       medium
     }
     countryOfOrigin
+    mediaListEntry {
+      id
+      progress
+      status
+    }
     nextAiringEpisode {
       timeUntilAiring
       airingAt

src/types/user.ts

@@ -3,18 +3,12 @@ import { z } from "zod";
 export type User = z.infer<typeof User>;
 export const User = z
   .object({
-    id: z.number().openapi({ type: "integer", format: "int64" }),
-    name: z.string(),
-  })
-  .optional()
-  .nullable();
-
-export type UserProfile = z.infer<typeof UserProfile>;
-export const UserProfile = z.object({
     statistics: z.object({
       minutesWatched: z.number().openapi({ type: "integer", format: "int64" }),
       episodesWatched: z.number().openapi({ type: "integer", format: "int64" }),
-    count: z.int(),
+      count: z
+        .number()
+        .int() /* .openapi({ type: "integer", format: "int64" }) */,
       meanScore: z.number().openapi({ type: "number", format: "float" }),
     }),
     id: z.number().openapi({ type: "integer", format: "int64" }),
@@ -23,4 +17,6 @@ export const UserProfile = z.object({
       medium: z.string(),
       large: z.string(),
     }),
-});
+  })
+  .optional()
+  .nullable();

worker-configuration.d.ts

@@ -22,12 +22,12 @@ declare namespace Cloudflare {
 		NEW_EPISODE: Queue;
 	}
 }
-interface Env extends Cloudflare.Env { }
+interface Env extends Cloudflare.Env {}
 type StringifyValues<EnvType extends Record<string, unknown>> = {
 	[Binding in keyof EnvType]: EnvType[Binding] extends string ? EnvType[Binding] : string;
 };
 declare namespace NodeJS {
-    interface ProcessEnv extends StringifyValues<Pick<Cloudflare.Env, "ADMIN_SDK_JSON" | "CLOUDFLARE_TOKEN" | "CLOUDFLARE_D1_TOKEN" | "CLOUDFLARE_ACCOUNT_ID" | "CLOUDFLARE_DATABASE_ID" | "PROXY_URL" | "USE_MOCK_DATA" | "LOG_DB_QUERIES">> { }
+	interface ProcessEnv extends StringifyValues<Pick<Cloudflare.Env, "ADMIN_SDK_JSON" | "CLOUDFLARE_TOKEN" | "CLOUDFLARE_D1_TOKEN" | "CLOUDFLARE_ACCOUNT_ID" | "CLOUDFLARE_DATABASE_ID" | "PROXY_URL" | "USE_MOCK_DATA" | "LOG_DB_QUERIES">> {}
 }
 
 // Begin runtime types
@@ -1644,7 +1644,7 @@ declare abstract class Body {
  */
 declare var Response: {
     prototype: Response;
-    new(body?: BodyInit | null, init?: ResponseInit): Response;
+    new (body?: BodyInit | null, init?: ResponseInit): Response;
     error(): Response;
     redirect(url: string, status?: number): Response;
     json(any: any, maybeInit?: (ResponseInit | Response)): Response;
@@ -2192,7 +2192,7 @@ interface ReadableStream<R = any> {
  */
 declare const ReadableStream: {
     prototype: ReadableStream;
-    new(underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;
+    new (underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;
     new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
 };
 /**
@@ -3034,7 +3034,7 @@ type WebSocketEventMap = {
  */
 declare var WebSocket: {
     prototype: WebSocket;
-    new(url: string, protocols?: (string[] | string)): WebSocket;
+    new (url: string, protocols?: (string[] | string)): WebSocket;
     readonly READY_STATE_CONNECTING: number;
     readonly CONNECTING: number;
     readonly READY_STATE_OPEN: number;
@@ -3091,7 +3091,7 @@ interface WebSocket extends EventTarget<WebSocketEventMap> {
     extensions: string | null;
 }
 declare const WebSocketPair: {
-    new(): {
+    new (): {
         0: WebSocket;
         1: WebSocket;
     };
@@ -9414,19 +9414,19 @@ interface IncomingRequestCfPropertiesTLSClientAuthPlaceholder {
 }
 /** Possible outcomes of TLS verification */
 declare type CertVerificationStatus = 
-    /** Authentication succeeded */
+/** Authentication succeeded */
-    "SUCCESS"
+"SUCCESS"
-    /** No certificate was presented */
+/** No certificate was presented */
  | "NONE"
-    /** Failed because the certificate was self-signed */
+/** Failed because the certificate was self-signed */
  | "FAILED:self signed certificate"
-    /** Failed because the certificate failed a trust chain check */
+/** Failed because the certificate failed a trust chain check */
  | "FAILED:unable to verify the first certificate"
-    /** Failed because the certificate not yet valid */
+/** Failed because the certificate not yet valid */
  | "FAILED:certificate is not yet valid"
-    /** Failed because the certificate is expired */
+/** Failed because the certificate is expired */
  | "FAILED:certificate has expired"
-    /** Failed for another unspecified reason */
+/** Failed for another unspecified reason */
  | "FAILED";
 /**
  * An upstream endpoint's response to a TCP `keepalive` message from Cloudflare.
@@ -9478,13 +9478,13 @@ interface D1ExecResult {
     duration: number;
 }
 type D1SessionConstraint = 
-    // Indicates that the first query should go to the primary, and the rest queries
+// Indicates that the first query should go to the primary, and the rest queries
-    // using the same D1DatabaseSession will go to any replica that is consistent with
+// using the same D1DatabaseSession will go to any replica that is consistent with
-    // the bookmark maintained by the session (returned by the first query).
+// the bookmark maintained by the session (returned by the first query).
-    'first-primary'
+'first-primary'
-    // Indicates that the first query can go anywhere (primary or replica), and the rest queries
+// Indicates that the first query can go anywhere (primary or replica), and the rest queries
-    // using the same D1DatabaseSession will go to any replica that is consistent with
+// using the same D1DatabaseSession will go to any replica that is consistent with
-    // the bookmark maintained by the session (returned by the first query).
+// the bookmark maintained by the session (returned by the first query).
  | 'first-unconstrained';
 type D1SessionBookmark = string;
 declare abstract class D1Database {
@@ -9599,7 +9599,7 @@ declare type EmailExportedHandler<Env = unknown> = (message: ForwardableEmailMes
 declare module "cloudflare:email" {
     let _EmailMessage: {
         prototype: EmailMessage;
-        new(from: string, to: string, raw: ReadableStream | string): EmailMessage;
+        new (from: string, to: string, raw: ReadableStream | string): EmailMessage;
     };
     export { _EmailMessage as EmailMessage };
 }
@@ -10251,9 +10251,6 @@ declare namespace CloudflareWorkersModule {
     export const env: Cloudflare.Env;
     export const exports: Cloudflare.Exports;
 }
-declare module 'cloudflare:test' {
-    export = CloudflareWorkersModule;
-}
 declare module 'cloudflare:workers' {
     export = CloudflareWorkersModule;
 }

wrangler.toml

@@ -17,8 +17,6 @@ class_name = "AnilistDo"
 
 [observability]
 enabled = true
-logs.destinations = ["otel-logs"]
-traces.destinations = ["otel-traces"]
 
 [[durable_objects.bindings]]
 name = "ANILIST_DO"
@@ -41,14 +39,6 @@ deleted_classes = ["AnilistDo"]
 tag = "v4"
 new_sqlite_classes = ["AnilistDo"]
 
-[[migrations]]
-tag = "v5"
-deleted_classes = ["AnilistDo"]
-
-[[migrations]]
-tag = "v6"
-new_sqlite_classes = ["AnilistDo"]
-
 [[queues.producers]]
 queue = "anilist-updates"
 binding = "ANILIST_UPDATES"
@@ -69,7 +59,7 @@ id = "c8db249d8ee7462b91f9c374321776e4"
 preview_id = "ff38240eb2aa4b1388c705f4974f5aec"
 
 [triggers]
-crons = ["0 */12 * * *", "0 18 * * *"]
+crons = ["0 */12 * * *"]
 
 [[d1_databases]]
 binding = "DB"