@juspay/neurolink 13.8.10 → 13.8.12

package/dist/server/adapters/honoAdapter.js

@@ -7,31 +7,11 @@ import { logger } from "../../utils/logger.js";
 import { AlreadyRunningError, ServerAdapterError, ServerStopError, wrapError, } from "../errors.js";
 import { BaseServerAdapter } from "../abstract/baseServerAdapter.js";
 import { isErrorResponse } from "../utils/validation.js";
-import { isRawBodyContentType, isWebResponse, parseByteLimit, RawBodyTooLargeError, readRawBody, } from "../utils/rawBody.js";
+import { isRawBodyContentType, isWebResponse, parseByteLimit, RawBodyTooLargeError, readBoundedRequestBody, } from "../utils/rawBody.js";
 /**
  * Hono-specific server adapter
  * Supports multiple runtimes: Bun, Deno, Node.js
  */
-/** Raw bodies already read for a request, so a second extraction never hits a consumed stream. */
-const rawBodies = new WeakMap();
-/** A web `ReadableStream` of bytes as an async iterable of Buffers, releasing the reader on exit. */
-async function* webStreamChunks(stream) {
-    const reader = stream.getReader();
-    try {
-        for (;;) {
-            const { value, done } = await reader.read();
-            if (done) {
-                return;
-            }
-            if (value) {
-                yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
 export class HonoServerAdapter extends BaseServerAdapter {
     app;
     server;
@@ -44,6 +24,7 @@ export class HonoServerAdapter extends BaseServerAdapter {
     // rely on initializeFramework's own local closure variables.
     HTTPExceptionCtor;
     streamSSEFn;
+    parseFormBody;
     constructor(neurolink, config = {}) {
         super(neurolink, config);
     }
@@ -136,7 +117,7 @@ export class HonoServerAdapter extends BaseServerAdapter {
      * adapter (Express/Fastify/Koa) never pulls Hono's import graph in.
      */
     async initializeFramework() {
-        const [{ Hono }, { cors }, { HTTPException }, { logger: honoLogger }, { secureHeaders }, { streamSSE }, { timeout },] = await Promise.all([
+        const [{ Hono }, { cors }, { HTTPException }, { logger: honoLogger }, { secureHeaders }, { streamSSE }, { timeout }, { parseBody },] = await Promise.all([
             this.importFrameworkDependency("hono", "hono"),
             this.importFrameworkDependency("hono/cors", "hono"),
             this.importFrameworkDependency("hono/http-exception", "hono"),
@@ -144,9 +125,11 @@ export class HonoServerAdapter extends BaseServerAdapter {
             this.importFrameworkDependency("hono/secure-headers", "hono"),
             this.importFrameworkDependency("hono/streaming", "hono"),
             this.importFrameworkDependency("hono/timeout", "hono"),
+            this.importFrameworkDependency("hono/utils/body", "hono"),
         ]);
         this.HTTPExceptionCtor = HTTPException;
         this.streamSSEFn = streamSSE;
+        this.parseFormBody = parseBody;
         this.app = new Hono();
         // Add secure headers
         this.app.use("*", secureHeaders());
@@ -243,17 +226,12 @@ export class HonoServerAdapter extends BaseServerAdapter {
                 // Extract path parameters
                 const params = c.req.param();
                 // Reuse existing context from middleware if available, otherwise create new one
-                const existingCtx = this.requestContextStore.get(requestId);
-                const ctx = existingCtx ||
-                    this.createContext({
-                        requestId,
-                        method: c.req.method,
-                        path: c.req.path,
-                        headers: this.extractHeaders(c),
-                        query: this.extractQuery(c),
-                        params,
-                        body: await this.extractBody(c),
-                    });
+                const created = this.requestContextStore.get(requestId) ||
+                    (await this.createRequestContext(c, requestId, params));
+                if (isWebResponse(created)) {
+                    return created;
+                }
+                const ctx = created;
                 // Emit request event
                 this.emit("request", {
                     requestId,
@@ -484,15 +462,11 @@ export class HonoServerAdapter extends BaseServerAdapter {
                 let ctx = this.requestContextStore.get(requestId);
                 if (!ctx) {
                     // Create new context for the first middleware
-                    ctx = this.createContext({
-                        requestId,
-                        method: c.req.method,
-                        path: c.req.path,
-                        headers: this.extractHeaders(c),
-                        query: this.extractQuery(c),
-                        params,
-                        body: await this.extractBody(c),
-                    });
+                    const created = await this.createRequestContext(c, requestId, params);
+                    if (isWebResponse(created)) {
+                        return created;
+                    }
+                    ctx = created;
                     // Store context for sharing between middleware and route handlers
                     this.requestContextStore.set(requestId, ctx);
                 }
@@ -667,22 +641,68 @@ export class HonoServerAdapter extends BaseServerAdapter {
         });
         return query;
     }
+    /**
+     * A request's context, or the 413 that answers a JSON or form body over its
+     * limit. That answer is built here, before the context exists, so no
+     * middleware (an auth check included) and no route runs for the request.
+     * An upload over the limit still reaches its route as the error itself,
+     * which answers in its own wire format.
+     */
+    async createRequestContext(c, requestId, params) {
+        const body = await this.extractBody(c);
+        if (body instanceof RawBodyTooLargeError &&
+            !isRawBodyContentType(c.req.header("Content-Type"))) {
+            logger.warn("[HonoAdapter] Request rejected", {
+                requestId,
+                code: "PAYLOAD_TOO_LARGE",
+                error: body.message,
+            });
+            this.emitRequestError({
+                requestId,
+                error: body,
+                timestamp: new Date(),
+            });
+            return c.json({
+                error: { code: "PAYLOAD_TOO_LARGE", message: body.message },
+                metadata: { requestId, timestamp: new Date().toISOString() },
+            }, 413);
+        }
+        return this.createContext({
+            requestId,
+            method: c.req.method,
+            path: c.req.path,
+            headers: this.extractHeaders(c),
+            query: this.extractQuery(c),
+            params,
+            body,
+        });
+    }
     async extractBody(c) {
         if (!this.config.bodyParser.enabled) {
             return undefined;
         }
         const contentType = c.req.header("Content-Type") || "";
-        if (contentType.includes("application/json")) {
-            try {
-                return await c.req.json();
-            }
-            catch {
-                return undefined;
-            }
-        }
-        if (contentType.includes("application/x-www-form-urlencoded")) {
+        // JSON and url-encoded forms are read through the same bounded read as
+        // uploads, with the limits the other adapters apply: `jsonLimit` for JSON,
+        // `maxSize` for forms. The bytes are then parsed the way Hono parses a
+        // body it has already buffered. A body that cannot be read or parsed is
+        // `undefined`, as it was when Hono did the reading.
+        const isJson = contentType.includes("application/json");
+        if (isJson || contentType.includes("application/x-www-form-urlencoded")) {
             try {
-                return await c.req.parseBody();
+                const bytes = await readBoundedRequestBody(c.req.raw, parseByteLimit(isJson
+                    ? this.config.bodyParser.jsonLimit
+                    : this.config.bodyParser.maxSize));
+                if (bytes instanceof RawBodyTooLargeError) {
+                    return bytes;
+                }
+                return isJson
+                    ? JSON.parse(new TextDecoder().decode(bytes))
+                    : await this.parseFormBody(new Request(c.req.url, {
+                        method: "POST",
+                        headers: { "Content-Type": contentType },
+                        body: new Uint8Array(bytes),
+                    }));
             }
             catch {
                 return undefined;
@@ -693,37 +713,7 @@ export class HonoServerAdapter extends BaseServerAdapter {
         // a throw from the middleware path would land in onError, which answers
         // 500. The route answers 413 (or a validation error) from it.
         if (isRawBodyContentType(contentType)) {
-            const limit = parseByteLimit(this.config.bodyParser.rawMaxSize);
-            if (Number(c.req.header("Content-Length") ?? 0) > limit) {
-                return new RawBodyTooLargeError(limit);
-            }
-            // Read the web stream chunk by chunk and stop at the limit, so a
-            // chunked upload without a Content-Length cannot be buffered whole
-            // (and that before any route logic, including the API-key check, runs).
-            // The body is extracted more than once per request (middleware and
-            // route); a web stream can only be read once, so the outcome is kept
-            // per request the way Hono caches `arrayBuffer()`.
-            const cached = rawBodies.get(c.req.raw);
-            if (cached !== undefined) {
-                return cached;
-            }
-            const stream = c.req.raw.body;
-            if (!stream) {
-                return Buffer.alloc(0);
-            }
-            let outcome;
-            try {
-                outcome = await readRawBody(webStreamChunks(stream), limit);
-            }
-            catch (error) {
-                if (!(error instanceof RawBodyTooLargeError)) {
-                    throw error;
-                }
-                await stream.cancel().catch(() => undefined);
-                outcome = error;
-            }
-            rawBodies.set(c.req.raw, outcome);
-            return outcome;
+            return readBoundedRequestBody(c.req.raw, parseByteLimit(this.config.bodyParser.rawMaxSize));
         }
         return undefined;
     }

package/dist/server/utils/rawBody.d.ts

@@ -13,6 +13,8 @@
  */
 /** `true` for a content type whose body the adapters pass through unparsed. */
 export declare function isRawBodyContentType(contentType: unknown): boolean;
+/** "10mb" / "512kb" / "1gb" / a byte count → bytes, or `undefined` when it is none of those. */
+export declare function tryParseByteLimit(limit: string | number | undefined): number | undefined;
 /** "10mb" / "512kb" / "1gb" / a byte count → bytes. Falls back to 10 MB. */
 export declare function parseByteLimit(limit: string | number | undefined): number;
 /** Thrown when a raw body grows past the adapter's `maxSize`. */
@@ -22,6 +24,21 @@ export declare class RawBodyTooLargeError extends Error {
 }
 /** Read a Node request stream into one `Buffer`, refusing more than `maxBytes`. */
 export declare function readRawBody(stream: AsyncIterable<Buffer | string>, maxBytes: number): Promise<Buffer>;
+/** A web `ReadableStream` of bytes as an async iterable of Buffers, releasing the reader on exit. */
+export declare function webStreamChunks(stream: ReadableStream<Uint8Array>): AsyncIterable<Buffer>;
+/**
+ * Read a web `Request` body, refusing more than `maxBytes`.
+ *
+ * A declared `Content-Length` over the limit is refused without reading
+ * anything. Otherwise the stream is read chunk by chunk and stopped at the
+ * limit, so a chunked body without a `Content-Length` cannot be buffered whole.
+ * Over the limit the result is the error itself rather than a throw: a throw
+ * from a middleware lands in the framework's error handler, which answers 500.
+ *
+ * The outcome is kept per request, because a web stream can only be read once
+ * and the body may be asked for more than once (middleware, then route).
+ */
+export declare function readBoundedRequestBody(request: Request, maxBytes: number): Promise<Buffer | RawBodyTooLargeError>;
 /** A web `Response` returned by a route handler. */
 export declare function isWebResponse(value: unknown): value is Response;
 /** Status, headers and body bytes of a web `Response`, for adapters that write to a Node response. */

package/dist/server/utils/rawBody.js

@@ -17,8 +17,8 @@ const RAW_BODY_CONTENT_TYPE = /^\s*(multipart\/form-data|application\/octet-stre
 export function isRawBodyContentType(contentType) {
     return (typeof contentType === "string" && RAW_BODY_CONTENT_TYPE.test(contentType));
 }
-/** "10mb" / "512kb" / "1gb" / a byte count → bytes. Falls back to 10 MB. */
-export function parseByteLimit(limit) {
+/** "10mb" / "512kb" / "1gb" / a byte count → bytes, or `undefined` when it is none of those. */
+export function tryParseByteLimit(limit) {
     if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) {
         return limit;
     }
@@ -26,7 +26,7 @@ export function parseByteLimit(limit) {
         ? limit.trim().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i)
         : null;
     if (!match) {
-        return 10 * 1024 * 1024;
+        return undefined;
     }
     const units = {
         b: 1,
@@ -34,7 +34,14 @@ export function parseByteLimit(limit) {
         mb: 1024 * 1024,
         gb: 1024 * 1024 * 1024,
     };
-    return Math.floor(Number(match[1]) * units[(match[2] ?? "b").toLowerCase()]);
+    const bytes = Math.floor(Number(match[1]) * units[(match[2] ?? "b").toLowerCase()]);
+    // A digit string long enough to overflow reads as Infinity, which no body
+    // can exceed: treat it as unparseable so the caller's default applies.
+    return Number.isFinite(bytes) ? bytes : undefined;
+}
+/** "10mb" / "512kb" / "1gb" / a byte count → bytes. Falls back to 10 MB. */
+export function parseByteLimit(limit) {
+    return tryParseByteLimit(limit) ?? 10 * 1024 * 1024;
 }
 /** Thrown when a raw body grows past the adapter's `maxSize`. */
 export class RawBodyTooLargeError extends Error {
@@ -58,6 +65,64 @@ export async function readRawBody(stream, maxBytes) {
     }
     return Buffer.concat(chunks);
 }
+/** A web `ReadableStream` of bytes as an async iterable of Buffers, releasing the reader on exit. */
+export async function* webStreamChunks(stream) {
+    const reader = stream.getReader();
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done) {
+                return;
+            }
+            if (value) {
+                yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/** Bodies already read for a request, so a second read never hits a consumed stream. */
+const boundedBodies = new WeakMap();
+/**
+ * Read a web `Request` body, refusing more than `maxBytes`.
+ *
+ * A declared `Content-Length` over the limit is refused without reading
+ * anything. Otherwise the stream is read chunk by chunk and stopped at the
+ * limit, so a chunked body without a `Content-Length` cannot be buffered whole.
+ * Over the limit the result is the error itself rather than a throw: a throw
+ * from a middleware lands in the framework's error handler, which answers 500.
+ *
+ * The outcome is kept per request, because a web stream can only be read once
+ * and the body may be asked for more than once (middleware, then route).
+ */
+export async function readBoundedRequestBody(request, maxBytes) {
+    if (Number(request.headers.get("content-length") ?? 0) > maxBytes) {
+        return new RawBodyTooLargeError(maxBytes);
+    }
+    const cached = boundedBodies.get(request);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const stream = request.body;
+    if (!stream) {
+        return Buffer.alloc(0);
+    }
+    let outcome;
+    try {
+        outcome = await readRawBody(webStreamChunks(stream), maxBytes);
+    }
+    catch (error) {
+        if (!(error instanceof RawBodyTooLargeError)) {
+            throw error;
+        }
+        await stream.cancel().catch(() => undefined);
+        outcome = error;
+    }
+    boundedBodies.set(request, outcome);
+    return outcome;
+}
 /** A web `Response` returned by a route handler. */
 export function isWebResponse(value) {
     return typeof Response !== "undefined" && value instanceof Response;