nukejs 0.0.19 → 0.0.20

package/dist/build-common.js

@@ -225,7 +225,9 @@ function makeApiAdapterSource(handlerFilename) {
   return `import type { IncomingMessage, ServerResponse } from 'http';
 import * as mod from ${JSON.stringify("./" + handlerFilename)};
 
-function enhance(res: ServerResponse) {
+const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB
+
+function enhanceRes(res: ServerResponse) {
   (res as any).json = function (data: any, status = 200) {
     this.statusCode = status;
     this.setHeader('Content-Type', 'application/json');
@@ -235,26 +237,46 @@ function enhance(res: ServerResponse) {
   return res;
 }
 
-async function parseBody(req: IncomingMessage): Promise<any> {
-  return new Promise((resolve, reject) => {
-    let body = '';
-    req.on('data', chunk => { body += chunk.toString(); });
-    req.on('end', () => {
-      try {
-        resolve(body && req.headers['content-type']?.includes('application/json')
-          ? JSON.parse(body) : body);
-      } catch (e) { reject(e); }
-    });
-    req.on('error', reject);
+function enhanceReq(req: IncomingMessage) {
+  const apiReq = req as any;
+  let bufferPromise: Promise<Buffer> | null = null;
+
+  const getBuffer = (): Promise<Buffer> => {
+    if (!bufferPromise) {
+      bufferPromise = new Promise((resolve, reject) => {
+        const chunks: Buffer[] = [];
+        let bytes = 0;
+        req.on('data', (chunk: Buffer) => {
+          bytes += chunk.length;
+          if (bytes > MAX_BODY_BYTES) { req.destroy(); return reject(new Error('Request body too large')); }
+          chunks.push(chunk);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+      });
+    }
+    return bufferPromise;
+  };
+
+  apiReq.buffer = () => getBuffer();
+  apiReq.text   = () => getBuffer().then(buf => buf.toString('utf8'));
+  apiReq.json   = () => getBuffer().then(buf => {
+    const parsed = JSON.parse(buf.toString('utf8'));
+    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      delete parsed.__proto__;
+      delete parsed.constructor;
+    }
+    return parsed;
   });
+
+  return apiReq;
 }
 
 export default async function handler(req: IncomingMessage, res: ServerResponse) {
   const method = (req.method || 'GET').toUpperCase();
-  const apiRes = enhance(res);
-  const apiReq = req as any;
+  const apiRes = enhanceRes(res);
+  const apiReq = enhanceReq(req);
 
-  apiReq.body   = await parseBody(req);
   // In production, route dynamic segments are injected as query-string keys by
   // the server entry, so params and query share the same parsed URL values.
   const qs = Object.fromEntries(new URL(req.url || '/', 'http://localhost').searchParams);

package/dist/http-server.js

@@ -31,9 +31,9 @@ function discoverApiPrefixes(serverDir) {
   return prefixes;
 }
 const MAX_BODY_BYTES = 10 * 1024 * 1024;
-async function parseBody(req) {
+function collectBuffer(req) {
   return new Promise((resolve, reject) => {
-    let body = "";
+    const chunks = [];
     let bytes = 0;
     req.on("data", (chunk) => {
       bytes += chunk.length;
@@ -41,27 +41,31 @@ async function parseBody(req) {
         req.destroy();
         return reject(new Error("Request body too large"));
       }
-      body += chunk.toString();
-    });
-    req.on("end", () => {
-      try {
-        if (body && req.headers["content-type"]?.includes("application/json")) {
-          const parsed = JSON.parse(body);
-          if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-            delete parsed.__proto__;
-            delete parsed.constructor;
-          }
-          resolve(parsed);
-        } else {
-          resolve(body);
-        }
-      } catch (err) {
-        reject(err);
-      }
+      chunks.push(chunk);
     });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
     req.on("error", reject);
   });
 }
+function enhanceRequest(req) {
+  const apiReq = req;
+  let bufferPromise = null;
+  const getBuffer = () => {
+    if (!bufferPromise) bufferPromise = collectBuffer(req);
+    return bufferPromise;
+  };
+  apiReq.buffer = () => getBuffer();
+  apiReq.text = () => getBuffer().then((buf) => buf.toString("utf8"));
+  apiReq.json = () => getBuffer().then((buf) => {
+    const parsed = JSON.parse(buf.toString("utf8"));
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      delete parsed.__proto__;
+      delete parsed.constructor;
+    }
+    return parsed;
+  });
+  return apiReq;
+}
 function parseQuery(url, port) {
   const query = {};
   new URL(url, `http://localhost:${port}`).searchParams.forEach((v, k) => {
@@ -145,8 +149,7 @@ function createApiHandler({ apiPrefixes, port, isDev }) {
         respondOptions(apiRes);
         return;
       }
-      const apiReq = req;
-      apiReq.body = await parseBody(req);
+      const apiReq = enhanceRequest(req);
       apiReq.params = params;
       apiReq.query = parseQuery(url, port);
       const apiModule = isDev ? await importFreshInDev(filePath) : await import(pathToFileURL(filePath).href);
@@ -165,8 +168,8 @@ function createApiHandler({ apiPrefixes, port, isDev }) {
 export {
   createApiHandler,
   discoverApiPrefixes,
+  enhanceRequest,
   enhanceResponse,
   matchApiPrefix,
-  parseBody,
   parseQuery
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nukejs",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "A minimal, opinionated full-stack React framework on Node.js that server-renders everything and hydrates only interactive parts.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",