@riddl/core 0.2.3 → 0.2.4

package/dist/api.js

@@ -3,6 +3,7 @@ import { json, recursiveAwait } from "./utils.js";
 import { CORS_DEFAULT, METHOD } from "./constants.js";
 import { log } from "./log.js";
 import { parseBody, parseOutput, parseParam, parseQuery } from "./validation.js";
+import { cleanupTempFiles } from "./multipart.js";
 import { parseRouteId } from "./parser.js";
 import { buildRouter } from "./routing.js";
 import { openapiHandler, registerRoutes } from "./openapi.js";
@@ -41,6 +42,10 @@ export const api = async ({ routeModuleMap, config, base = "", cors = true, regi
     const effectiveCorsSettings = cors ? typeof cors === "object" ? cors : CORS_DEFAULT : undefined;
     const handler = async (request) => {
         var _a, _b, _c;
+        // Temp files produced by streamed multipart uploads; removed once the
+        // handler has finished reading them (it copies bytes to permanent
+        // storage before returning).
+        const tempFiles = [];
         try {
             log("request: %O", request);
             const event = {
@@ -69,7 +74,7 @@ export const api = async ({ routeModuleMap, config, base = "", cors = true, regi
             }
             const param = await parseParam(params !== null && params !== void 0 ? params : {}, endpoint);
             const query = await parseQuery(request, endpoint);
-            const body = await parseBody(request, endpoint);
+            const body = await parseBody(request, endpoint, tempFiles);
             log("handler: %O", endpoint.handle);
             const output = await endpoint.handle({ body, query, param, event: ctxEvent });
             for (const mw of [...routeWithMiddlewares.middlewares].reverse()) {
@@ -124,6 +129,14 @@ export const api = async ({ routeModuleMap, config, base = "", cors = true, regi
                 status: 500,
             });
         }
+        finally {
+            // Runs after the Response is built (handlers copy uploads to
+            // permanent storage before returning), so deleting the temp files
+            // here is safe. Streaming responses (SSE) never set `tempFiles`.
+            if (tempFiles.length > 0) {
+                await cleanupTempFiles(tempFiles);
+            }
+        }
     };
     return {
         handler,

package/dist/multipart.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A file part materialised on disk. It quacks like the WHATWG `File` the
+ * previous `request.formData()` path produced — `name`, `type`, `size`,
+ * `stream()`, `arrayBuffer()`, `slice()` — but its bytes live in a temp file
+ * and are read lazily, so a large upload is never held in memory.
+ */
+export type UploadedFile = Blob & {
+    name: string;
+};
+export type FormValue = string | UploadedFile;
+export type FormBody = Record<string, FormValue | FormValue[]>;
+/**
+ * Stream-parse a `multipart/form-data` request body, writing each uploaded
+ * file straight to a temp file on disk instead of buffering the whole payload
+ * in memory (which is what `request.formData()` does). Text fields are
+ * collected as strings; file fields become disk-backed {@link UploadedFile}s.
+ *
+ * Returns the parsed body together with the temp paths the caller must delete
+ * once the handler has finished reading the files — see
+ * {@link cleanupTempFiles}.
+ */
+export declare const parseMultipart: (req: Request) => Promise<{
+    body: FormBody;
+    tempFiles: string[];
+}>;
+/** Best-effort removal of the temp files produced by {@link parseMultipart}. */
+export declare const cleanupTempFiles: (tempFiles: string[]) => Promise<unknown>;

package/dist/multipart.js

@@ -0,0 +1,65 @@
+import busboy from "busboy";
+import { randomBytes } from "node:crypto";
+import { createWriteStream, openAsBlob } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+const addEntry = (body, name, value) => {
+    const existing = body[name];
+    if (existing === undefined) {
+        body[name] = value;
+    }
+    else if (Array.isArray(existing)) {
+        existing.push(value);
+    }
+    else {
+        body[name] = [existing, value];
+    }
+};
+/**
+ * Stream-parse a `multipart/form-data` request body, writing each uploaded
+ * file straight to a temp file on disk instead of buffering the whole payload
+ * in memory (which is what `request.formData()` does). Text fields are
+ * collected as strings; file fields become disk-backed {@link UploadedFile}s.
+ *
+ * Returns the parsed body together with the temp paths the caller must delete
+ * once the handler has finished reading the files — see
+ * {@link cleanupTempFiles}.
+ */
+export const parseMultipart = async (req) => {
+    const contentType = req.headers.get("content-type");
+    if (!req.body || !contentType) {
+        return { body: {}, tempFiles: [] };
+    }
+    const tempFiles = [];
+    const body = {};
+    await new Promise((resolve, reject) => {
+        const bb = busboy({ headers: { "content-type": contentType } });
+        // File parts finish writing asynchronously; `close` can fire before the
+        // last temp file is fully flushed, so we wait on these before resolving.
+        const pending = [];
+        bb.on("field", (name, value) => addEntry(body, name, value));
+        bb.on("file", (name, stream, info) => {
+            const tempPath = join(tmpdir(), `riddl-upload-${randomBytes(16).toString("hex")}`);
+            tempFiles.push(tempPath);
+            pending.push(pipeline(stream, createWriteStream(tempPath)).then(async () => {
+                const blob = await openAsBlob(tempPath, {
+                    type: info.mimeType,
+                });
+                addEntry(body, name, Object.assign(blob, { name: info.filename }));
+            }));
+        });
+        bb.on("error", reject);
+        bb.on("close", () => {
+            Promise.all(pending)
+                .then(() => resolve())
+                .catch(reject);
+        });
+        Readable.fromWeb(req.body).pipe(bb);
+    });
+    return { body, tempFiles };
+};
+/** Best-effort removal of the temp files produced by {@link parseMultipart}. */
+export const cleanupTempFiles = (tempFiles) => Promise.all(tempFiles.map((path) => unlink(path).catch(() => undefined)));

package/dist/validation.d.ts

@@ -1,5 +1,5 @@
 import { GenericApiEndpoint } from "./types";
-export declare const parseBody: (req: Request, module: GenericApiEndpoint) => Promise<unknown>;
+export declare const parseBody: (req: Request, module: GenericApiEndpoint, tempFiles?: string[]) => Promise<unknown>;
 export declare const parseQuery: (request: Request, module: GenericApiEndpoint) => Promise<Record<string, string | string[]>>;
 export declare const parseParam: (params: Record<string, string>, module: GenericApiEndpoint) => Promise<Record<string, string | never>>;
 export declare const parseOutput: (out: unknown, module: GenericApiEndpoint) => Promise<Record<string, unknown> | unknown[]>;

package/dist/validation.js

@@ -2,6 +2,7 @@ import { fromZodError } from "zod-validation-error";
 import { log } from "./log.js";
 import { z } from "./zod.js";
 import { error } from "./errors.js";
+import { parseMultipart } from "./multipart.js";
 const parseJsonBody = async (req) => {
     var _a;
     const clonedRequest = req.clone();
@@ -17,27 +18,33 @@ const parseJsonBody = async (req) => {
         }
     }
 };
-export const parseBody = async (req, module) => {
-    var _a, _b, _c, _d, _e, _f;
+export const parseBody = async (req, module, tempFiles = []) => {
+    var _a, _b;
     let body = {};
     // GET, HEAD, DELETE, OPTIONS have no body
     const method = req.method.toUpperCase();
     if (["GET", "HEAD", "DELETE", "OPTIONS"].includes(method)) {
         return body;
     }
-    const clonedRequest = req.clone();
+    const contentType = (_a = req.headers.get("content-type")) !== null && _a !== void 0 ? _a : "";
     // JSON body
-    if ((_a = clonedRequest.headers.get("content-type")) === null || _a === void 0 ? void 0 : _a.startsWith("application/json")) {
-        body = await clonedRequest.json().catch(() => {
+    if (contentType.startsWith("application/json")) {
+        body = await req.clone().json().catch(() => {
             throw error(400, "Invalid JSON body");
         });
     }
-    // Form body
-    else if (((_b = clonedRequest.headers
-        .get("content-type")) === null || _b === void 0 ? void 0 : _b.startsWith("application/x-www-form-urlencoded")) ||
-        ((_c = clonedRequest.headers.get("content-type")) === null || _c === void 0 ? void 0 : _c.startsWith("multipart/form-data"))) {
+    // Multipart form body: stream uploads to disk rather than buffering the
+    // whole payload in memory. Consume `req` directly (no `clone()` — a tee
+    // would re-buffer the unread branch, defeating the point).
+    else if (contentType.startsWith("multipart/form-data")) {
+        const result = await parseMultipart(req);
+        tempFiles.push(...result.tempFiles);
+        body = result.body;
+    }
+    // URL-encoded form body (always small — buffering is fine)
+    else if (contentType.startsWith("application/x-www-form-urlencoded")) {
         const formBody = {};
-        const form = await clonedRequest.formData();
+        const form = await req.clone().formData();
         for (const [key, value] of form.entries()) {
             if (formBody[key]) {
                 const existing = formBody[key];
@@ -55,16 +62,16 @@ export const parseBody = async (req, module) => {
         body = formBody;
     }
     // Text body
-    else if ((_d = clonedRequest.headers.get("content-type")) === null || _d === void 0 ? void 0 : _d.startsWith("text/plain")) {
-        body = { text: await clonedRequest.text() };
+    else if (contentType.startsWith("text/plain")) {
+        body = { text: await req.clone().text() };
     }
     // Binary body
-    else if ((_e = clonedRequest.headers.get("content-type")) === null || _e === void 0 ? void 0 : _e.startsWith("application/octet-stream")) {
-        const buffer = await clonedRequest.arrayBuffer();
+    else if (contentType.startsWith("application/octet-stream")) {
+        const buffer = await req.clone().arrayBuffer();
         body = { buffer };
     }
     log("body: %O", body);
-    const validator = (_f = module.Input) !== null && _f !== void 0 ? _f : z.object({});
+    const validator = (_b = module.Input) !== null && _b !== void 0 ? _b : z.object({});
     const validation = validator.safeParse(body);
     if (!validation.success) {
         throw error(400, `Invalid body.\n${fromZodError(validation.error).message}`);

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@riddl/core",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "license": "MIT",
   "type": "module",
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^8.4.0",
+    "busboy": "^1.6.0",
     "debug": "^4.4.0",
     "express": "^5.2.1",
     "set-cookie-parser": "^3.0.1",
@@ -22,6 +23,7 @@
     "/dist"
   ],
   "devDependencies": {
+    "@types/busboy": "^1.5.4",
     "@types/debug": "^4.1.12",
     "@types/express": "^5.0.6",
     "@types/set-cookie-parser": "^2.4.10",