feat: move all routes to resources folder

routes/resources/api/recipes/[name].ts

@@ -0,0 +1,23 @@
+import { HandlerContext } from "$fresh/server.ts";
+import { getDocument } from "../../../lib/documents.ts";
+import { parseRecipe } from "../../../lib/recipes.ts";
+
+export async function getRecipe(name: string) {
+  const document = await getDocument(`Recipes/${name}.md`);
+
+  const recipe = parseRecipe(document, name);
+
+  return recipe;
+}
+
+export const handler = async (
+  _req: Request,
+  _ctx: HandlerContext,
+): Promise<Response> => {
+  const recipe = await getRecipe(_ctx.params.name);
+
+  const headers = new Headers();
+  headers.append("Content-Type", "application/json");
+
+  return new Response(JSON.stringify(recipe));
+};

routes/resources/api/recipes/images/[image].ts

@@ -0,0 +1,128 @@
+import { HandlerContext } from "$fresh/server.ts";
+import {
+  ImageMagick,
+  initializeImageMagick,
+  MagickGeometry,
+} from "https://deno.land/x/imagemagick_deno@0.0.14/mod.ts";
+import { parseMediaType } from "https://deno.land/std@0.175.0/media_types/parse_media_type.ts";
+import * as cache from "../../../../lib/cache.ts";
+
+await initializeImageMagick();
+
+async function getRemoteImage(image: string) {
+  const sourceRes = await fetch(image);
+  if (!sourceRes.ok) {
+    return "Error retrieving image from URL.";
+  }
+  const mediaType = parseMediaType(sourceRes.headers.get("Content-Type")!)[0];
+  if (mediaType.split("/")[0] !== "image") {
+    return "URL is not image type.";
+  }
+  return {
+    buffer: new Uint8Array(await sourceRes.arrayBuffer()),
+    mediaType,
+  };
+}
+
+function getWidthHeight(
+  current: { width: number; height: number },
+  final: { width: number; height: number },
+) {
+  const ratio = (current.width / final.width) > (current.height / final.height)
+    ? (current.height / final.height)
+    : (current.width / final.width);
+
+  return new MagickGeometry(
+    current.width / ratio,
+    current.height / ratio,
+  );
+}
+
+function modifyImage(
+  imageBuffer: Uint8Array,
+  params: { width: number; height: number; mode: "resize" | "crop" },
+) {
+  return new Promise<Uint8Array>((resolve) => {
+    ImageMagick.read(imageBuffer, (image) => {
+      const sizingData = getWidthHeight(image, params);
+      if (params.mode === "resize") {
+        image.resize(sizingData);
+      } else {
+        image.crop(sizingData);
+      }
+      image.write((data) => resolve(data));
+    });
+  });
+}
+
+function parseParams(reqUrl: URL) {
+  const height = Number(reqUrl.searchParams.get("height")) || 0;
+  const width = Number(reqUrl.searchParams.get("width")) || 0;
+  if (height === 0 && width === 0) {
+    //return "Missing non-zero 'height' or 'width' query parameter.";
+  }
+  if (height < 0 || width < 0) {
+    return "Negative height or width is not supported.";
+  }
+  const maxDimension = 2048;
+  if (height > maxDimension || width > maxDimension) {
+    return `Width and height cannot exceed ${maxDimension}.`;
+  }
+  return {
+    height,
+    width,
+  };
+}
+
+async function getImageResponse(
+  remoteImage: { buffer: Uint8Array; mediaType: string },
+  params: { width: number; height: number },
+): Promise<Response> {
+  const modifiedImage = await modifyImage(remoteImage.buffer, {
+    ...params,
+    mode: "resize",
+  });
+
+  const response = new Response(modifiedImage, {
+    headers: {
+      "Content-Type": remoteImage.mediaType,
+    },
+  });
+
+  return response;
+}
+
+export const handler = async (
+  _req: Request,
+  _ctx: HandlerContext,
+): Promise<Response> => {
+  const imageUrl = Deno.env.get("SILVERBULLET_SERVER") + "/Recipes/images/" +
+    _ctx.params.image;
+
+  const url = new URL(_req.url);
+
+  const params = parseParams(url);
+
+  if (typeof params === "string") {
+    return new Response(params, { status: 400 });
+  }
+
+  const imageId = `${imageUrl}.${params.width}.${params.height}`;
+  const cachedResponse = await cache.get(imageId);
+  if (cachedResponse) {
+    const _r = await cachedResponse;
+    console.log({ cachedResponse, _r });
+    return (await cachedResponse).clone();
+  }
+
+  const remoteImage = await getRemoteImage(imageUrl);
+  if (typeof remoteImage === "string") {
+    return new Response(remoteImage, { status: 400 });
+  }
+
+  const response = getImageResponse(remoteImage, params);
+
+  await cache.set(imageId, response);
+
+  return response;
+};

routes/resources/api/recipes/index.ts

@@ -0,0 +1,34 @@
+import { HandlerContext } from "$fresh/server.ts";
+import { getDocument, getDocuments } from "../../../lib/documents.ts";
+import { parseRecipe } from "../../../lib/recipes.ts";
+
+export async function getRecipes() {
+  const documents = await getDocuments();
+
+  return Promise.all(
+    documents.filter((d) => {
+      return d.name.startsWith("Recipes/") &&
+        d.contentType === "text/markdown" &&
+        !d.name.endsWith("index.md");
+    }).map(async (doc) => {
+      const document = await getDocument(doc.name);
+      const recipe = parseRecipe(document, doc.name);
+      return {
+        ...recipe,
+        id: recipe.id.replace(/^Recipes\//, "").replace(/\.md$/, ""),
+      };
+    }),
+  );
+}
+
+export const handler = async (
+  _req: Request,
+  _ctx: HandlerContext,
+): Promise<Response> => {
+  const headers = new Headers();
+  headers.append("Content-Type", "application/json");
+
+  const recipes = await getRecipes();
+
+  return new Response(JSON.stringify(recipes), { headers });
+};