create-monolayer-app 0.2.2 → 0.4.0

package/template/vendor/file-bucket/react-router.ts

@@ -0,0 +1,222 @@
+/* oxlint-disable no-await-in-loop, anti-slop/no-unknown-returns, anti-slop/no-runtime-typeof */
+import { FileBucket } from "./index.js";
+import { parseFileBucketRequest } from "./protocol.js";
+import type {
+  FileBucketRequest,
+  FileBucketResponses,
+  UploadGrant,
+} from "./protocol.js";
+import {
+  getUrl,
+  putUrl,
+  delete as deleteFile,
+  deleteBatch,
+  createMultipartUploadHandle,
+} from "./server.js";
+
+const MULTIPART_THRESHOLD = 8 * 1024 * 1024;
+export const MAX_REQUEST_BYTES = 64 * 1024;
+export const MAX_BATCH_KEYS = 1000;
+
+export type {
+  FileBucketRequest,
+  FileBucketOperation,
+  UploadGrant,
+  SignedUrl,
+  FileBucketResponses,
+} from "./protocol.js";
+
+export async function readLimitedJson(
+  request: Request,
+  maxBytes: number,
+): Promise<unknown> {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+    throw new RangeError("maxBytes must be a positive safe integer.");
+  }
+  const reader = request.body?.getReader();
+  if (!reader) throw new Response("Invalid JSON", { status: 400 });
+
+  const chunks: Uint8Array[] = [];
+  let length = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.byteLength;
+      if (length > maxBytes) {
+        try {
+          await reader.cancel();
+        } catch {
+          // Preserve 413 if canceling fails
+        }
+        throw new Response("Request too large", { status: 413 });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new Response("Invalid JSON", { status: 400 });
+  }
+}
+
+async function uploadGrant(
+  bucket: FileBucket,
+  input: Extract<FileBucketRequest, { operation: "put" }>,
+): Promise<UploadGrant> {
+  const options = {
+    contentType: input.contentType,
+    cacheControl: input.cacheControl,
+    metadata: input.metadata,
+  };
+  if (input.size >= MULTIPART_THRESHOLD) {
+    const handle = await createMultipartUploadHandle(bucket, input.path, {
+      ...options,
+      size: input.size,
+    });
+    return { type: "multipart", descriptor: handle.toJSON() };
+  }
+  const url = await putUrl(bucket, input.path, options);
+  const headers: Record<string, string> = {};
+  if (options.contentType) headers["Content-Type"] = options.contentType;
+  if (options.cacheControl) headers["Cache-Control"] = options.cacheControl;
+  return { type: "single", url, headers };
+}
+
+export async function dispatch(
+  bucket: FileBucket,
+  input: FileBucketRequest,
+): Promise<FileBucketResponses[FileBucketRequest["operation"]]> {
+  switch (input.operation) {
+    case "delete": {
+      await deleteFile(bucket, input.path);
+      return undefined;
+    }
+    case "deleteBatch": {
+      await deleteBatch(bucket, input.paths);
+      return undefined;
+    }
+    case "get": {
+      return {
+        url: await getUrl(bucket, input.path, {
+          contentDisposition: "attachment",
+        }),
+      };
+    }
+    case "getUrl": {
+      return {
+        url: await getUrl(bucket, input.path, {
+          expiresIn: input.expiresIn,
+          contentDisposition: input.contentDisposition,
+        }),
+      };
+    }
+    case "putUrl": {
+      return {
+        url: await putUrl(bucket, input.path, {
+          expiresIn: input.expiresIn,
+          contentType: input.contentType,
+          metadata: input.metadata,
+          cacheControl: input.cacheControl,
+        }),
+      };
+    }
+    case "put": {
+      return uploadGrant(bucket, input);
+    }
+    default: {
+      throw new Error("Unsupported file operation");
+    }
+  }
+}
+
+/**
+ * Creates a React Router server action for handling browser FileBucket operations.
+ *
+ * Register the returned action at `/resources/files`. It handles JSON POST requests for:
+ * - Direct upload signing (`put`)
+ * - Attachment download signing (`get`)
+ * - Presigned URL generation (`getUrl`, `putUrl`)
+ * - Server-side deletion (`delete`, `deleteBatch`)
+ *
+ * Resolves the `FileBucket` instance directly from the request's bucket ID.
+ * Limits request bodies to 64 KiB and batch deletions to 1,000 keys.
+ *
+ * Returns JSON for signing, an empty 204 response for successful deletion,
+ * 400 for malformed requests, 405 for methods other than POST, 413 for oversized requests,
+ * and 415 for non-JSON content types.
+ * Storage failures propagate to React Router. Route registration is the caller's responsibility.
+ *
+ * @returns A React Router action function `({ request }: { request: Request }) => Promise<Response>`.
+ *
+ * @example
+ * ```ts
+ * // app/routes/files.ts
+ * import { createFileBucketAction } from "@monolayer/file-bucket/react-router";
+ *
+ * export const action = createFileBucketAction();
+ * ```
+ */
+export function createFileBucketAction(): (args: {
+  request: Request;
+}) => Promise<Response> {
+  return async ({ request }: { request: Request }): Promise<Response> => {
+    if (request.method !== "POST") {
+      return new Response("Method not allowed", {
+        status: 405,
+        headers: { Allow: "POST" },
+      });
+    }
+
+    const contentTypeHeader = request.headers.get("content-type");
+    const mediaType = contentTypeHeader?.toLowerCase().split(";")[0]?.trim();
+    if (mediaType !== "application/json") {
+      return new Response("Unsupported Media Type", { status: 415 });
+    }
+
+    const contentLengthHeader = request.headers.get("content-length");
+    if (contentLengthHeader !== null) {
+      const declaredLength = Number(contentLengthHeader);
+      if (!Number.isNaN(declaredLength) && declaredLength > MAX_REQUEST_BYTES) {
+        return new Response("Request too large", { status: 413 });
+      }
+    }
+
+    let value: unknown;
+    try {
+      value = await readLimitedJson(request, MAX_REQUEST_BYTES);
+    } catch (error) {
+      if (error instanceof Response) return error;
+      return new Response("Invalid JSON", { status: 400 });
+    }
+
+    let input: Readonly<FileBucketRequest>;
+    try {
+      input = parseFileBucketRequest(value, { maxBatchKeys: MAX_BATCH_KEYS });
+    } catch {
+      return new Response("Invalid file request", { status: 400 });
+    }
+
+    const bucket = new FileBucket(input.bucketId);
+    const result = await dispatch(bucket, input);
+    if (result === undefined) {
+      return new Response(null, {
+        status: 204,
+        headers: { "Cache-Control": "no-store" },
+      });
+    }
+    return Response.json(result, {
+      headers: { "Cache-Control": "private, no-store" },
+    });
+  };
+}