refactor(api): 🚚 Use api/ for API routes instead of server/api/

api/media/:hash/:name/index.ts

@@ -0,0 +1,64 @@
+import { apiRoute, applyConfig, handleZodError } from "@/api";
+import { response } from "@/response";
+import { zValidator } from "@hono/zod-validator";
+import { z } from "zod";
+
+export const meta = applyConfig({
+    allowedMethods: ["GET"],
+    route: "/media/:hash/:name",
+    ratelimits: {
+        max: 100,
+        duration: 60,
+    },
+    auth: {
+        required: false,
+    },
+});
+
+export const schemas = {
+    param: z.object({
+        hash: z.string(),
+        name: z.string(),
+    }),
+    header: z.object({
+        range: z.string().optional().default(""),
+    }),
+};
+
+export default apiRoute((app) =>
+    app.on(
+        meta.allowedMethods,
+        meta.route,
+        zValidator("param", schemas.param, handleZodError),
+        zValidator("header", schemas.header, handleZodError),
+        async (context) => {
+            const { hash, name } = context.req.valid("param");
+            const { range } = context.req.valid("header");
+
+            // parse `Range` header
+            const [start = 0, end = Number.POSITIVE_INFINITY] = (
+                range
+                    .split("=") // ["Range: bytes", "0-100"]
+                    .at(-1) || ""
+            ) // "0-100"
+                .split("-") // ["0", "100"]
+                .map(Number); // [0, 100]
+
+            // Serve file from filesystem
+            const file = Bun.file(`./uploads/${hash}/${name}`);
+
+            const buffer = await file.arrayBuffer();
+
+            if (!(await file.exists())) {
+                return context.json({ error: "File not found" }, 404);
+            }
+
+            // Can't directly copy file into Response because this crashes Bun for now
+            return response(buffer, 200, {
+                "Content-Type": file.type || "application/octet-stream",
+                "Content-Length": `${file.size - start}`,
+                "Content-Range": `bytes ${start}-${end}/${file.size}`,
+            });
+        },
+    ),
+);

api/media/proxy/:id.ts

@@ -0,0 +1,77 @@
+import { apiRoute, applyConfig, handleZodError } from "@/api";
+import { response } from "@/response";
+import { zValidator } from "@hono/zod-validator";
+import { z } from "zod";
+import { config } from "~/packages/config-manager";
+
+export const meta = applyConfig({
+    allowedMethods: ["GET"],
+    route: "/media/proxy/:id",
+    ratelimits: {
+        max: 100,
+        duration: 60,
+    },
+    auth: {
+        required: false,
+    },
+});
+
+export const schemas = {
+    param: z.object({
+        id: z
+            .string()
+            .transform((val) => Buffer.from(val, "base64url").toString()),
+    }),
+};
+
+export default apiRoute((app) =>
+    app.on(
+        meta.allowedMethods,
+        meta.route,
+        zValidator("param", schemas.param, handleZodError),
+        async (context) => {
+            const { id } = context.req.valid("param");
+
+            // Check if URL is valid
+            if (!URL.canParse(id)) {
+                return context.json(
+                    { error: "Invalid URL (it should be encoded as base64url" },
+                    400,
+                );
+            }
+
+            const media = await fetch(id, {
+                headers: {
+                    "Accept-Encoding": "br",
+                },
+                // @ts-expect-error Proxy is a Bun-specific feature
+                proxy: config.http.proxy.address,
+            });
+
+            // Check if file extension ends in svg or svg
+            // Cloudflare R2 serves those as application/xml
+            if (
+                media.headers.get("Content-Type") === "application/xml" &&
+                id.endsWith(".svg")
+            ) {
+                media.headers.set("Content-Type", "image/svg+xml");
+            }
+
+            const realFilename =
+                media.headers
+                    .get("Content-Disposition")
+                    ?.match(/filename="(.+)"/)?.[1] || id.split("/").pop();
+
+            return response(media.body, media.status, {
+                "Content-Type":
+                    media.headers.get("Content-Type") ||
+                    "application/octet-stream",
+                "Content-Length": media.headers.get("Content-Length") || "0",
+                "Content-Security-Policy": "",
+                "Content-Encoding": "",
+                // Real filename
+                "Content-Disposition": `inline; filename="${realFilename}"`,
+            });
+        },
+    ),
+);