feat: cache marka api responses

routes/api/articles/create/index.ts

@@ -6,13 +6,15 @@ import * as openai from "@lib/openai.ts";
 import { getYoutubeVideoDetails } from "@lib/youtube.ts";
 import {
   extractYoutubeId,
+  formatDate,
   isYoutubeLink,
-  toUrlSafeString,
+  safeFileName,
 } from "@lib/string.ts";
 import { createLogger } from "@lib/log/index.ts";
 import { createResource } from "@lib/marka/index.ts";
 import { webScrape } from "@lib/webScraper.ts";
 import { ArticleResource } from "@lib/marka/schema.ts";
+import { fileExtension } from "https://deno.land/x/file_extension@v2.1.0/mod.ts";
 
 const log = createLogger("api/article");
 
@@ -44,16 +46,34 @@ async function processCreateArticle(
   streamResponse.enqueue("postprocessing article");
 
   const title = result?.title || aiMeta?.headline || "";
-  const id = toUrlSafeString(title);
+
+  let finalPath = result.image;
+  if (result?.image) {
+    const extension = fileExtension(result?.image);
+    const imagePath = `resources/articles/images/${
+      safeFileName(title)
+    }_cover.${extension}`;
+    try {
+      streamResponse.enqueue("downloading image");
+      const res = await fetch(result.image);
+      streamResponse.enqueue("saving image");
+      const buffer = await res.arrayBuffer();
+      await createResource(imagePath, buffer);
+      finalPath = imagePath;
+    } catch (err) {
+      console.log("Failed to save image", err);
+    }
+  }
 
   const newArticle: ArticleResource["content"] = {
     _type: "Article",
     headline: title,
     articleBody: result.content,
     url: fetchUrl,
-    datePublished: result?.published || aiMeta?.datePublished ||
-      new Date().toISOString(),
-    image: result?.image,
+    datePublished: formatDate(
+      result?.published || aiMeta?.datePublished || undefined,
+    ),
+    image: finalPath,
     author: {
       _type: "Person",
       name: (result.schemaOrgData?.author?.name || aiMeta?.author || "")
@@ -66,9 +86,9 @@ async function processCreateArticle(
 
   streamResponse.enqueue("writing to disk");
 
-  await createResource(`articles/${id}.md`, newArticle);
+  await createResource(`articles/${title}.md`, newArticle);
 
-  streamResponse.enqueue("id: " + id);
+  streamResponse.enqueue("id: " + title);
 }
 
 async function processCreateYoutubeVideo(

routes/api/movies/[name].ts

@@ -2,8 +2,8 @@ import { Handlers } from "$fresh/server.ts";
 import { json } from "@lib/helpers.ts";
 import * as tmdb from "@lib/tmdb.ts";
 import { fileExtension } from "https://deno.land/x/file_extension@v2.1.0/mod.ts";
-import { isString, safeFileName } from "@lib/string.ts";
-import { AccessDeniedError } from "@lib/errors.ts";
+import { formatDate, isString, safeFileName } from "@lib/string.ts";
+import { AccessDeniedError, BadRequestError } from "@lib/errors.ts";
 import { createResource, fetchResource } from "@lib/marka/index.ts";
 import { ReviewResource } from "@lib/marka/schema.ts";
 
@@ -14,26 +14,22 @@ export const handler: Handlers = {
   },
   async POST(_, ctx) {
     const session = ctx.state.session;
-    if (!session) {
-      throw new AccessDeniedError();
-    }
+    if (!session) throw new AccessDeniedError();
 
     const tmdbId = parseInt(ctx.params.name);
+    if (Number.isNaN(tmdbId)) throw new BadRequestError();
 
-    const movieDetails = await tmdb.getMovie(tmdbId);
-    const movieCredits = await tmdb.getMovieCredits(tmdbId);
+    const [movieDetails, movieCredits] = await Promise.all([
+      tmdb.getMovie(tmdbId),
+      tmdb.getMovieCredits(tmdbId),
+    ]);
 
-    const releaseDate = movieDetails.release_date;
-    const posterPath = movieDetails.poster_path;
-    const director = movieCredits?.crew?.filter?.((person) =>
-      person.job === "Director"
-    )[0];
-
-    movieDetails.overview;
-
-    let finalPath = "";
-    const name = movieDetails.title || movieDetails.original_title ||
+    const name = movieDetails.title ||
+      movieDetails.original_title ||
       ctx.params.name;
+
+    const posterPath = movieDetails.poster_path;
+    let finalPath = "";
     if (posterPath) {
       const poster = await tmdb.getMoviePoster(posterPath);
       const extension = fileExtension(posterPath);
@@ -41,33 +37,32 @@ export const handler: Handlers = {
       await createResource(finalPath, poster);
     }
 
-    const tags: string[] = [];
-    if (movieDetails.genres) {
-      tags.push(
-        ...movieDetails.genres.map((g) => g.name?.toLowerCase()).filter(
-          isString,
-        ),
-      );
-    }
+    const keywords = movieDetails.genres
+      ?.map((g) => g.name?.toLowerCase())
+      .filter(isString) || [];
 
     const movie: ReviewResource["content"] = {
       _type: "Review",
       image: `resources/${finalPath}`,
-      datePublished: releaseDate,
+      datePublished: formatDate(movieDetails.release_date),
       tmdbId,
       author: {
         _type: "Person",
-        name: director?.name,
+        name: movieCredits.crew?.filter?.((person) =>
+          person.job === "Director"
+        )[0]?.name,
       },
       itemReviewed: {
-        name: name,
+        name,
       },
       reviewBody: "",
-      keywords: tags,
+      keywords,
     };
 
-    await createResource(`movies/${safeFileName(name)}.md`, movie);
+    const fileName = `${safeFileName(name)}.md`;
 
-    return json(movie);
+    await createResource(`movies/${fileName}`, movie);
+
+    return json({ name: fileName });
   },
 };

routes/api/movies/enhance/[name].ts

@@ -39,15 +39,16 @@ const POST = async (
   const movieCredits = !movie.content?.author &&
     await tmdb.getMovieCredits(tmdbId);
 
-  const releaseDate = movieDetails.release_date;
-  if (releaseDate && !movie.content?.datePublished) {
-    movie.content = movie.content || {};
-    movie.content.datePublished = formatDate(new Date(releaseDate));
-  }
   const director = movieCredits &&
     movieCredits?.crew?.filter?.((person) => person.job === "Director")[0];
+
+  movie.content ??= {
+    _type: "Review",
+  };
+
+  movie.content.datePublished ??= formatDate(movieDetails.release_date);
+
   if (director && !movie.content?.author) {
-    movie.content = movie.content || {};
     movie.content.author = {
       _type: "Person",
       name: director.name,
@@ -65,18 +66,15 @@ const POST = async (
     ];
   }
 
-  if (!movie.name) {
-    movie.name = tmdbId;
-  }
+  movie.content.tmdbId ??= tmdbId;
 
   let finalPath = "";
   const posterPath = movieDetails.poster_path;
-  if (posterPath && !movie.content?.image) {
+  if (posterPath && !movie.content.image) {
     const poster = await tmdb.getMoviePoster(posterPath);
     const extension = fileExtension(posterPath);
     finalPath = `movies/images/${safeFileName(name)}_cover.${extension}`;
     await createResource(finalPath, poster);
-    movie.content = movie.content || {};
     movie.content.image = finalPath;
   }
 

routes/api/recipes/create/index.ts

@@ -76,7 +76,7 @@ async function processCreateRecipeFromUrl(
   };
 
   if (newRecipe?.image && newRecipe.image.length > 5) {
-    const extension = fileExtension(new URL(newRecipe.image).pathname);
+    const extension = fileExtension(newRecipe.image);
     const finalPath = `resources/recipes/images/${
       safeFileName(id)
     }_cover.${extension}`;

routes/api/series/[name].ts

@@ -2,11 +2,19 @@ import { Handlers } from "$fresh/server.ts";
 import { json } from "@lib/helpers.ts";
 import * as tmdb from "@lib/tmdb.ts";
 import { fileExtension } from "https://deno.land/x/file_extension@v2.1.0/mod.ts";
-import { isString, safeFileName } from "@lib/string.ts";
-import { AccessDeniedError } from "@lib/errors.ts";
+import { formatDate, isString, safeFileName } from "@lib/string.ts";
+import { AccessDeniedError, BadRequestError } from "@lib/errors.ts";
 import { createResource, fetchResource } from "@lib/marka/index.ts";
 import { ReviewResource } from "@lib/marka/schema.ts";
 
+function pickDirector(
+  credits: Awaited<ReturnType<typeof tmdb.getSeriesCredits>>,
+  createdBy?: { name?: string }[],
+): string | undefined {
+  const crewDirector = credits?.crew?.find?.((p) => p.job === "Director");
+  return crewDirector?.name ?? createdBy?.[0]?.name;
+}
+
 export const handler: Handlers = {
   async GET(_, ctx) {
     const series = await fetchResource(`series/${ctx.params.name}`);
@@ -19,54 +27,54 @@ export const handler: Handlers = {
     }
 
     const tmdbId = parseInt(ctx.params.name);
+    if (Number.isNaN(tmdbId)) throw new BadRequestError();
 
-    const seriesDetails = await tmdb.getSeries(tmdbId);
-    const seriesCredits = await tmdb.getSeriesCredits(tmdbId);
+    const [seriesDetails, seriesCredits] = await Promise.all([
+      tmdb.getSeries(tmdbId),
+      tmdb.getSeriesCredits(tmdbId),
+    ]);
 
-    const releaseDate = seriesDetails.first_air_date;
-    const posterPath = seriesDetails.poster_path;
-    const director =
-      seriesCredits?.crew?.filter?.((person) => person.job === "Director")[0] ||
-      seriesDetails.created_by?.[0];
+    const name = seriesDetails.name ||
+      seriesDetails.original_name ||
+      ctx.params.name;
 
     let finalPath = "";
-    const name = seriesDetails.name || seriesDetails.original_name ||
-      ctx.params.name;
+    const posterPath = seriesDetails.poster_path;
     if (posterPath) {
       const poster = await tmdb.getMoviePoster(posterPath);
       const extension = fileExtension(posterPath);
-
-      finalPath = `series/images/${safeFileName(name)}_cover.${extension}`;
-      await createResource(finalPath, poster);
+      const imagePath = `series/images/${
+        safeFileName(name)
+      }_cover.${extension}`;
+      await createResource(imagePath, poster);
+      finalPath = imagePath;
     }
 
-    const tags: string[] = [];
-    if (seriesDetails.genres) {
-      tags.push(
-        ...seriesDetails.genres.map((g) => g.name?.toLowerCase()).filter(
-          isString,
-        ),
-      );
-    }
+    const keywords = seriesDetails.genres
+      ?.map((g) => g.name?.toLowerCase())
+      .filter(isString) ??
+      [];
 
     const series: ReviewResource["content"] = {
       _type: "Review",
       image: `resources/${finalPath}`,
-      datePublished: releaseDate,
+      datePublished: formatDate(seriesDetails.first_air_date),
       tmdbId,
       author: {
         _type: "Person",
-        name: director?.name,
+        name: pickDirector(seriesCredits, seriesDetails?.created_by),
       },
       itemReviewed: {
         name: name,
       },
       reviewBody: "",
-      keywords: tags,
+      keywords: keywords,
     };
 
-    await createResource(`series/${safeFileName(name)}.md`, series);
+    const fileName = `${safeFileName(name)}.md`;
 
-    return json(series);
+    await createResource(`series/${fileName}`, series);
+
+    return json({ name: fileName });
   },
 };