feat: support sending "new episode" notifications to devices

src/controllers/episodes/getByAniListId/episode.ts

@@ -1,20 +0,0 @@
-import { z } from "zod";
-
-import { EpisodeNumberSchema } from "~/types/schema";
-
-export type Episode = z.infer<typeof Episode>;
-export const Episode = z.object({
-  id: z.string(),
-  number: EpisodeNumberSchema,
-  title: z.string().nullish(),
-  img: z.string().nullish(),
-  description: z.string().nullish(),
-  rating: z.number().int().nullish(),
-  updatedAt: z.number().int().default(0).openapi({ format: "int64" }),
-});
-
-export type EpisodesResponse = z.infer<typeof EpisodesResponse>;
-export const EpisodesResponse = z.object({
-  providerId: z.string(),
-  episodes: z.array(Episode),
-});

src/controllers/episodes/getByAniListId/index.ts

@@ -3,17 +3,14 @@ import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 import { fetchFromMultipleSources } from "~/libs/fetchFromMultipleSources";
 import { readEnvVariable } from "~/libs/readEnvVariable";
 import type { Env } from "~/types/env";
+import { EpisodesResponseSchema } from "~/types/episode";
 import {
   AniListIdQuerySchema,
   ErrorResponse,
   ErrorResponseSchema,
-  SuccessResponseSchema,
 } from "~/types/schema";
 
 import { getEpisodesFromAnify } from "./anify";
-import { EpisodesResponse } from "./episode";
-
-const EpisodesResponseSchema = SuccessResponseSchema(EpisodesResponse);
 
 const route = createRoute({
   tags: ["aniplay", "episodes"],

src/controllers/episodes/getEpisodeUrl/index.ts

@@ -2,19 +2,18 @@ import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 
 import { readEnvVariable } from "~/libs/readEnvVariable";
 import type { Env } from "~/types/env";
+import {
+  FetchUrlResponse,
+  FetchUrlResponseSchema,
+} from "~/types/episode/fetch-url-response";
 import {
   AniListIdQuerySchema,
   ErrorResponse,
   ErrorResponseSchema,
-  SuccessResponseSchema,
 } from "~/types/schema";
 
-import { FetchUrlResponse as FetchUrlResponseSchema } from "./responseType";
-
 const FetchUrlRequest = z.object({ id: z.string(), provider: z.string() });
 
-const FetchUrlResponse = SuccessResponseSchema(FetchUrlResponseSchema);
-
 const route = createRoute({
   tags: ["aniplay", "episodes"],
   summary: "Fetch stream URL for an episode",

src/controllers/episodes/getEpisodeUrl/responseType.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-
-import { SkippableSchema } from "~/types/schema";
-
-export type FetchUrlResponse = z.infer<typeof FetchUrlResponse>;
-export const FetchUrlResponse = z.object({
-  source: z.string(),
-  subtitles: z.array(z.object({ url: z.string(), lang: z.string() })),
-  audio: z.array(z.object({ url: z.string(), lang: z.string() })),
-  intro: SkippableSchema,
-  outro: SkippableSchema,
-  headers: z.record(z.string()).optional(),
-});

src/controllers/new-episode/index.ts

@@ -0,0 +1,111 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { env } from "hono/adapter";
+import mapKeys from "lodash.mapkeys";
+import { DateTime } from "luxon";
+import { z } from "zod";
+
+import { Case, changeStringCase } from "~/libs/changeStringCase";
+import type { AdminSdkCredentials } from "~/libs/fcm/getGoogleAuthToken";
+import { sendFcmMessage } from "~/libs/fcm/sendFcmMessage";
+import { verifyQstashHeader } from "~/libs/qstash/verifyQstashHeader";
+import { readEnvVariable } from "~/libs/readEnvVariable";
+import { getTokensSubscribedToTitle } from "~/models/token";
+import type { Env } from "~/types/env";
+import type { EpisodesResponseSchema } from "~/types/episode";
+import type { FetchUrlResponse } from "~/types/episode/fetch-url-response";
+import {
+  AniListIdSchema,
+  EpisodeNumberSchema,
+  ErrorResponse,
+  SuccessResponse,
+} from "~/types/schema";
+
+const app = new Hono();
+
+app.post(
+  "/",
+  zValidator(
+    "json",
+    z.object({
+      aniListId: AniListIdSchema,
+      episodeNumber: EpisodeNumberSchema,
+    }),
+  ),
+  async (c) => {
+    const { aniListId, episodeNumber } = await c.req.json<{
+      aniListId: number;
+      episodeNumber: number;
+    }>();
+
+    if (!(await verifyQstashHeader(env<Env, typeof c>(c, "workerd"), c.req))) {
+      return c.json(ErrorResponse, { status: 401 });
+    }
+
+    const domain = c.req.url.replace(c.req.path, "");
+
+    console.log(`${domain}/episodes/${aniListId}`);
+    const { success, result: fetchEpisodesResult } = await fetch(
+      `${domain}/episodes/${aniListId}`,
+    ).then((res) => res.json<EpisodesResponseSchema>());
+    if (!success) {
+      return c.json(ErrorResponse, { status: 500 });
+    }
+
+    const { episodes, providerId } = fetchEpisodesResult;
+    const episode = episodes.find(
+      (episode) => episode.number === episodeNumber,
+    );
+    if (!episode) {
+      return c.json(ErrorResponse, { status: 404 });
+    }
+
+    const { success: fetchUrlSuccess, result: fetchUrlResult } = await fetch(
+      `${domain}/episodes/${aniListId}/url`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          id: episode.id,
+          provider: providerId,
+        }),
+      },
+    ).then((res) => res.json<FetchUrlResponse>());
+    if (!fetchUrlSuccess) {
+      return c.json(ErrorResponse, { status: 500 });
+    }
+
+    const tokens = await getTokensSubscribedToTitle(
+      env<Env, typeof c>(c, "workerd"),
+      aniListId,
+    );
+
+    await Promise.all(
+      tokens.map(async (token) => {
+        return sendFcmMessage(
+          mapKeys(
+            readEnvVariable<AdminSdkCredentials>(c.env, "ADMIN_SDK_JSON"),
+            (_, key) => changeStringCase(key, Case.snake_case, Case.camelCase),
+          ) as unknown as AdminSdkCredentials,
+          {
+            token,
+            data: {
+              type: "new_episode",
+              episodes: JSON.stringify(episodes),
+              episodeStreamInfo: JSON.stringify(fetchUrlResult),
+              aniListId: aniListId.toString(),
+              episodeNumber: episodeNumber.toString(),
+            },
+            android: { priority: "high" },
+          },
+        );
+      }),
+    );
+
+    return c.json(SuccessResponse, 200);
+  },
+);
+
+export default app;

src/controllers/upcoming-titles/anilist.ts

@@ -52,7 +52,6 @@ export async function getUpcomingTitlesFromAnilist(env: Env) {
     env,
     "schedule_last_checked_at",
   ).then((value) => (value ? Number(value) : DateTime.now().toUnixInteger()));
-  console.log(lastCheckedScheduleAt);
   const twoDaysFromNow = DateTime.now().plus({ days: 2 }).toUnixInteger();
 
   let currentPage = 1;