@fluojs/runtime 1.0.0-beta.1

package/dist/multipart.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Represents a single uploaded multipart file buffered in memory.
+ */
+export interface UploadedFile {
+    fieldname: string;
+    originalname: string;
+    mimetype: string;
+    buffer: Buffer;
+    size: number;
+}
+/**
+ * Configures multipart parsing limits for file size, file count, and total payload size.
+ */
+export interface MultipartOptions {
+    maxFileSize?: number;
+    maxFiles?: number;
+    maxTotalSize?: number;
+}
+/**
+ * Contains parsed multipart fields and uploaded files.
+ */
+export interface MultipartResult {
+    fields: Record<string, string | string[]>;
+    files: UploadedFile[];
+}
+/**
+ * Describes request-like multipart inputs accepted by the runtime parsers.
+ */
+export interface MultipartRequestLike {
+    body?: AsyncIterable<Uint8Array> | BodyInit | null;
+    headers: Headers | Readonly<Record<string, string | string[] | undefined>>;
+    method?: string;
+    url?: string;
+    [Symbol.asyncIterator]?(): AsyncIterator<Uint8Array>;
+}
+/**
+ * Parses a multipart request into string fields and in-memory uploaded files.
+ *
+ * @param request - Web `Request` or request-like input carrying a multipart body.
+ * @param options - Multipart limits for file size, file count, and total payload size.
+ * @returns Parsed string fields plus uploaded files buffered in memory.
+ * @throws {PayloadTooLargeException} When the multipart payload, file count, or file size exceeds the configured limits.
+ */
+export declare function parseMultipart(request: Request | MultipartRequestLike, options?: MultipartOptions): Promise<MultipartResult>;
+//# sourceMappingURL=multipart.d.ts.map

package/dist/multipart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart.d.ts","sourceRoot":"","sources":["../src/multipart.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC1C,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,GAAG,IAAI,CAAC;IACnD,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,IAAI,aAAa,CAAC,UAAU,CAAC,CAAC;CACtD;AAOD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,GAAG,oBAAoB,EACvC,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CA8C1B"}

package/dist/multipart.js

@@ -0,0 +1,195 @@
+import { PayloadTooLargeException } from '@fluojs/http';
+
+/**
+ * Represents a single uploaded multipart file buffered in memory.
+ */
+
+/**
+ * Configures multipart parsing limits for file size, file count, and total payload size.
+ */
+
+/**
+ * Contains parsed multipart fields and uploaded files.
+ */
+
+/**
+ * Describes request-like multipart inputs accepted by the runtime parsers.
+ */
+
+const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_MAX_FILES = 10;
+const DEFAULT_MAX_TOTAL_SIZE = 10 * 1024 * 1024;
+const MULTIPART_BODY_LIMIT_MESSAGE = 'Multipart body exceeds the maximum size of';
+
+/**
+ * Parses a multipart request into string fields and in-memory uploaded files.
+ *
+ * @param request - Web `Request` or request-like input carrying a multipart body.
+ * @param options - Multipart limits for file size, file count, and total payload size.
+ * @returns Parsed string fields plus uploaded files buffered in memory.
+ * @throws {PayloadTooLargeException} When the multipart payload, file count, or file size exceeds the configured limits.
+ */
+export async function parseMultipart(request, options = {}) {
+  const maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
+  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+  const maxTotalSize = options.maxTotalSize ?? DEFAULT_MAX_TOTAL_SIZE;
+  const formData = await toWebRequest(request, maxTotalSize).formData();
+  const fields = {};
+  const files = [];
+  let totalSize = 0;
+  for (const [fieldname, value] of formData.entries()) {
+    if (typeof value === 'string') {
+      totalSize += Buffer.byteLength(value, 'utf8');
+      if (totalSize > maxTotalSize) {
+        throw new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
+      }
+      appendMultipartField(fields, fieldname, value);
+      continue;
+    }
+    totalSize += value.size;
+    if (totalSize > maxTotalSize) {
+      throw new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
+    }
+    if (files.length >= maxFiles) {
+      throw new PayloadTooLargeException(`Exceeded maximum file count of ${String(maxFiles)}.`);
+    }
+    if (value.size > maxFileSize) {
+      throw new PayloadTooLargeException(`File "${fieldname}" exceeds the maximum size of ${String(maxFileSize)} bytes.`);
+    }
+    files.push({
+      buffer: Buffer.from(await value.arrayBuffer()),
+      fieldname,
+      mimetype: value.type,
+      originalname: value.name,
+      size: value.size
+    });
+  }
+  return {
+    fields,
+    files
+  };
+}
+function appendMultipartField(fields, name, value) {
+  const existing = fields[name];
+  if (existing === undefined) {
+    fields[name] = value;
+    return;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+    return;
+  }
+  fields[name] = [existing, value];
+}
+function toWebRequest(request, maxTotalSize) {
+  if (request instanceof Request) {
+    return createMultipartRequest(request.url, request.method, new Headers(request.headers), request.body, maxTotalSize);
+  }
+  const method = request.method ?? 'POST';
+  const body = supportsRequestBody(method) ? resolveRequestBody(request) : undefined;
+  return createMultipartRequest(request.url ?? 'http://localhost/', method, normalizeRequestHeaders(request.headers), body, maxTotalSize);
+}
+function resolveRequestBody(request) {
+  if (request.body !== undefined) {
+    return isAsyncIterableBody(request.body) ? createReadableStreamFromAsyncIterable(request.body) : request.body;
+  }
+  if (typeof request[Symbol.asyncIterator] === 'function') {
+    return createReadableStreamFromAsyncIterable(request);
+  }
+  return undefined;
+}
+function supportsRequestBody(method) {
+  return method !== 'GET' && method !== 'HEAD';
+}
+function isAsyncIterableBody(body) {
+  return body !== null && typeof body === 'object' && Symbol.asyncIterator in body;
+}
+function isStreamingBody(body) {
+  return body instanceof ReadableStream || isAsyncIterableBody(body);
+}
+function createReadableStreamFromAsyncIterable(source) {
+  const iterator = source[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async cancel() {
+      await iterator.return?.();
+    },
+    async pull(controller) {
+      const {
+        done,
+        value
+      } = await iterator.next();
+      if (done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(value);
+    }
+  });
+}
+function createMultipartRequest(url, method, headers, body, maxTotalSize) {
+  const contentLength = headers.get('content-length');
+  if (contentLength !== null) {
+    const parsedContentLength = Number(contentLength);
+    if (Number.isFinite(parsedContentLength) && parsedContentLength > maxTotalSize) {
+      throw new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
+    }
+  }
+  const init = {
+    headers,
+    method
+  };
+  if (body !== undefined) {
+    const limitedBody = body !== null && isStreamingBody(body) ? createByteLimitedReadableStream(body, maxTotalSize) : body;
+    init.body = limitedBody;
+    if (limitedBody instanceof ReadableStream) {
+      init.duplex = 'half';
+    }
+  }
+  return new Request(url, init);
+}
+function createByteLimitedReadableStream(stream, maxTotalSize) {
+  const source = stream instanceof ReadableStream ? stream : createReadableStreamFromAsyncIterable(stream);
+  const reader = source.getReader();
+  let totalSize = 0;
+  return new ReadableStream({
+    async cancel(reason) {
+      await reader.cancel(reason);
+    },
+    async pull(controller) {
+      const {
+        done,
+        value
+      } = await reader.read();
+      if (done) {
+        controller.close();
+        return;
+      }
+      totalSize += value.byteLength;
+      if (totalSize > maxTotalSize) {
+        const error = new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
+        await reader.cancel(error.message);
+        controller.error(error);
+        return;
+      }
+      controller.enqueue(value);
+    }
+  });
+}
+function normalizeRequestHeaders(headers) {
+  if (headers instanceof Headers) {
+    return new Headers(headers);
+  }
+  const normalized = new Headers();
+  for (const [name, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      for (const headerValue of value) {
+        normalized.append(name, headerValue);
+      }
+      continue;
+    }
+    if (value !== undefined) {
+      normalized.set(name, value);
+    }
+  }
+  return normalized;
+}

package/dist/node/internal-node-compression.d.ts

@@ -0,0 +1,7 @@
+import type { ServerResponse } from 'node:http';
+import type { FrameworkResponseCompression } from '@fluojs/http';
+type Encoding = 'br' | 'gzip' | 'identity';
+export declare function createNodeResponseCompression(response: ServerResponse, acceptEncoding: string | undefined): FrameworkResponseCompression | undefined;
+export declare function compressNodeResponse(response: ServerResponse, body: Uint8Array, encoding: Exclude<Encoding, 'identity'>): Promise<void>;
+export {};
+//# sourceMappingURL=internal-node-compression.d.ts.map

package/dist/node/internal-node-compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-node-compression.d.ts","sourceRoot":"","sources":["../../src/node/internal-node-compression.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,OAAO,KAAK,EACV,4BAA4B,EAE7B,MAAM,cAAc,CAAC;AAiBtB,KAAK,QAAQ,GAAG,IAAI,GAAG,MAAM,GAAG,UAAU,CAAC;AAE3C,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,cAAc,EACxB,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,4BAA4B,GAAG,SAAS,CAqB1C;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,GACtC,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/dist/node/internal-node-compression.js

@@ -0,0 +1,68 @@
+import { createBrotliCompress, createGzip } from 'node:zlib';
+const COMPRESS_THRESHOLD = 1024;
+const SKIP_CONTENT_TYPES = new Set(['image/', 'audio/', 'video/', 'application/zip', 'application/gzip', 'application/x-bzip', 'application/x-bzip2', 'application/x-xz', 'application/zstd', 'application/octet-stream']);
+export function createNodeResponseCompression(response, acceptEncoding) {
+  if (!acceptEncoding) {
+    return undefined;
+  }
+  return {
+    async write(body, options = {}) {
+      if (body.byteLength < COMPRESS_THRESHOLD || shouldSkipContentType(options.contentType)) {
+        return false;
+      }
+      const encoding = selectEncoding(acceptEncoding);
+      if (encoding === 'identity') {
+        return false;
+      }
+      await compressNodeResponse(response, body, encoding);
+      return true;
+    }
+  };
+}
+export function compressNodeResponse(response, body, encoding) {
+  const stream = encoding === 'br' ? createBrotliCompress() : createGzip();
+  response.setHeader('Content-Encoding', encoding);
+  response.removeHeader('Content-Length');
+  return new Promise((resolve, reject) => {
+    stream.on('error', reject);
+    stream.pipe(response);
+    stream.on('finish', resolve);
+    stream.end(body);
+  });
+}
+function shouldSkipContentType(contentType) {
+  if (!contentType) {
+    return false;
+  }
+  const lower = contentType.toLowerCase();
+  for (const prefix of SKIP_CONTENT_TYPES) {
+    if (lower.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+function selectEncoding(acceptEncoding) {
+  if (!acceptEncoding) {
+    return 'identity';
+  }
+  const entries = acceptEncoding.split(',').map(entry => {
+    const [enc, qPart] = entry.trim().split(';');
+    const q = qPart ? parseFloat(qPart.replace('q=', '')) : 1;
+    return {
+      enc: enc?.trim() ?? '',
+      q: Number.isNaN(q) ? 1 : q
+    };
+  }).filter(entry => entry.q > 0).sort((a, b) => b.q - a.q);
+  for (const {
+    enc
+  } of entries) {
+    if (enc === 'br') {
+      return 'br';
+    }
+    if (enc === 'gzip') {
+      return 'gzip';
+    }
+  }
+  return 'identity';
+}

package/dist/node/internal-node-request.d.ts

@@ -0,0 +1,34 @@
+import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'node:http';
+import { PayloadTooLargeException, type FrameworkRequest } from '@fluojs/http';
+import { type MultipartOptions } from '../multipart.js';
+export declare class NodeRequestPayloadTooLargeException extends PayloadTooLargeException {
+    private readonly request;
+    constructor(request: IncomingMessage);
+    prepareResponse(response: ServerResponse): void;
+}
+/**
+ * Creates a framework request from a raw Node incoming message.
+ *
+ * @param request - Raw Node request carrying headers, URL, and body stream.
+ * @param signal - Abort signal tied to the response lifecycle.
+ * @param multipartOptions - Multipart parser options applied to multipart requests.
+ * @param maxBodySize - Maximum allowed non-multipart body size in bytes.
+ * @param preserveRawBody - Whether to retain the raw request body bytes.
+ * @returns The normalized framework request used by the dispatcher.
+ */
+export declare function createFrameworkRequest(request: IncomingMessage, signal: AbortSignal, multipartOptions?: MultipartOptions, maxBodySize?: number, preserveRawBody?: boolean): Promise<FrameworkRequest>;
+/**
+ * Creates an abort signal that fires when the Node response closes unexpectedly.
+ *
+ * @param response - Raw Node server response associated with the request.
+ * @returns An abort signal for downstream request cancellation handling.
+ */
+export declare function createRequestSignal(response: ServerResponse): AbortSignal;
+/**
+ * Resolves the request identifier from the preferred inbound headers.
+ *
+ * @param headers - Raw Node request headers.
+ * @returns The request identifier when present.
+ */
+export declare function resolveRequestIdFromHeaders(headers: IncomingHttpHeaders): string | undefined;
+//# sourceMappingURL=internal-node-request.d.ts.map

package/dist/node/internal-node-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-node-request.d.ts","sourceRoot":"","sources":["../../src/node/internal-node-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EACf,cAAc,EACf,MAAM,WAAW,CAAC;AAInB,OAAO,EAEL,wBAAwB,EACxB,KAAK,gBAAgB,EACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAEL,KAAK,gBAAgB,EAEtB,MAAM,iBAAiB,CAAC;AAOzB,qBAAa,mCAAoC,SAAQ,wBAAwB;IACnE,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,eAAe;IAIrD,eAAe,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;CAahD;AAED;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,WAAW,EACnB,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,WAAW,SAAkB,EAC7B,eAAe,UAAQ,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAqD3B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,GAAG,WAAW,CAezE;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS,CAG5F"}

package/dist/node/internal-node-request.js

@@ -0,0 +1,195 @@
+import { Readable } from 'node:stream';
+import { URL } from 'node:url';
+import { BadRequestException, PayloadTooLargeException } from '@fluojs/http';
+import { parseMultipart } from '../multipart.js';
+export class NodeRequestPayloadTooLargeException extends PayloadTooLargeException {
+  constructor(request) {
+    super('Request body exceeds the size limit.');
+    this.request = request;
+  }
+  prepareResponse(response) {
+    response.setHeader('Connection', 'close');
+    const destroyRequest = () => {
+      if (!this.request.destroyed) {
+        this.request.destroy();
+      }
+    };
+    response.once('finish', destroyRequest);
+    response.once('close', destroyRequest);
+    this.request.pause();
+  }
+}
+
+/**
+ * Creates a framework request from a raw Node incoming message.
+ *
+ * @param request - Raw Node request carrying headers, URL, and body stream.
+ * @param signal - Abort signal tied to the response lifecycle.
+ * @param multipartOptions - Multipart parser options applied to multipart requests.
+ * @param maxBodySize - Maximum allowed non-multipart body size in bytes.
+ * @param preserveRawBody - Whether to retain the raw request body bytes.
+ * @returns The normalized framework request used by the dispatcher.
+ */
+export async function createFrameworkRequest(request, signal, multipartOptions, maxBodySize = 1 * 1024 * 1024, preserveRawBody = false) {
+  const url = new URL(request.url ?? '/', 'http://localhost');
+  const headers = cloneRequestHeaders(request.headers);
+  const contentType = readPrimaryHeaderValue(headers['content-type']);
+  const isMultipart = typeof contentType === 'string' && contentType.includes('multipart/form-data');
+  let body;
+  let files;
+  let rawBody;
+  if (isMultipart) {
+    const result = await parseMultipart({
+      body: Readable.toWeb(request),
+      headers,
+      method: request.method,
+      url: url.toString()
+    }, {
+      ...multipartOptions,
+      maxTotalSize: multipartOptions?.maxTotalSize ?? maxBodySize
+    });
+    body = result.fields;
+    files = result.files;
+  } else {
+    const bodyResult = await readRequestBody(request, headers['content-type'], maxBodySize, preserveRawBody);
+    body = bodyResult.body;
+    rawBody = bodyResult.rawBody;
+  }
+  const frameworkRequest = {
+    body,
+    cookies: parseCookieHeader(headers.cookie),
+    headers,
+    method: request.method ?? 'GET',
+    params: {},
+    path: url.pathname,
+    query: parseQueryParams(url.searchParams),
+    raw: request,
+    signal,
+    url: url.pathname + url.search
+  };
+  if (files) {
+    frameworkRequest.files = files;
+  }
+  if (rawBody) {
+    frameworkRequest.rawBody = rawBody;
+  }
+  return frameworkRequest;
+}
+
+/**
+ * Creates an abort signal that fires when the Node response closes unexpectedly.
+ *
+ * @param response - Raw Node server response associated with the request.
+ * @returns An abort signal for downstream request cancellation handling.
+ */
+export function createRequestSignal(response) {
+  const controller = new AbortController();
+  const abort = reason => {
+    if (!controller.signal.aborted) {
+      controller.abort(new Error(reason));
+    }
+  };
+  response.once('close', () => {
+    if (!response.writableEnded) {
+      abort('Response closed before response commit.');
+    }
+  });
+  return controller.signal;
+}
+
+/**
+ * Resolves the request identifier from the preferred inbound headers.
+ *
+ * @param headers - Raw Node request headers.
+ * @returns The request identifier when present.
+ */
+export function resolveRequestIdFromHeaders(headers) {
+  const requestId = headers['x-request-id'] ?? headers['x-correlation-id'];
+  return Array.isArray(requestId) ? requestId[0] : requestId;
+}
+function parseQueryParams(searchParams) {
+  const query = {};
+  for (const [key, value] of searchParams.entries()) {
+    const current = query[key];
+    if (current === undefined) {
+      query[key] = value;
+      continue;
+    }
+    if (Array.isArray(current)) {
+      current.push(value);
+      continue;
+    }
+    query[key] = [current, value];
+  }
+  return query;
+}
+function cloneRequestHeaders(headers) {
+  const clonedEntries = Object.entries(headers).map(([name, value]) => [name, Array.isArray(value) ? [...value] : value]);
+  return Object.fromEntries(clonedEntries);
+}
+function readPrimaryHeaderValue(headerValue) {
+  if (Array.isArray(headerValue)) {
+    return headerValue[0];
+  }
+  return headerValue;
+}
+function decodeCookieValue(raw) {
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseCookieHeader(cookieHeader) {
+  const normalizedCookieHeader = Array.isArray(cookieHeader) ? cookieHeader.join('; ') : cookieHeader;
+  if (!normalizedCookieHeader) {
+    return {};
+  }
+  return Object.fromEntries(normalizedCookieHeader.split(';').map(pair => pair.trim()).filter(Boolean).map(pair => {
+    const index = pair.indexOf('=');
+    if (index === -1) {
+      return [pair.trim(), ''];
+    }
+    return [pair.slice(0, index).trim(), decodeCookieValue(pair.slice(index + 1).trim())];
+  }));
+}
+async function readRequestBody(request, contentType, maxBodySize = 1 * 1024 * 1024, preserveRawBody = false) {
+  const chunks = [];
+  let totalSize = 0;
+  for await (const chunk of request) {
+    const buf = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+    totalSize += buf.byteLength;
+    if (totalSize > maxBodySize) {
+      throw new NodeRequestPayloadTooLargeException(request);
+    }
+    chunks.push(buf);
+  }
+  if (chunks.length === 0) {
+    return {
+      body: undefined
+    };
+  }
+  const rawBody = Buffer.concat(chunks);
+  const bodyText = rawBody.toString('utf8');
+  if (bodyText.length === 0) {
+    return {
+      body: undefined,
+      rawBody: preserveRawBody ? rawBody : undefined
+    };
+  }
+  const primaryContentType = Array.isArray(contentType) ? contentType[0] : contentType;
+  if (typeof primaryContentType === 'string' && primaryContentType.includes('application/json')) {
+    try {
+      return {
+        body: JSON.parse(bodyText),
+        rawBody: preserveRawBody ? rawBody : undefined
+      };
+    } catch {
+      throw new BadRequestException('Request body contains invalid JSON.');
+    }
+  }
+  return {
+    body: bodyText,
+    rawBody: preserveRawBody ? rawBody : undefined
+  };
+}

package/dist/node/internal-node-response.d.ts

@@ -0,0 +1,8 @@
+import type { ServerResponse } from 'node:http';
+import { type FrameworkResponseCompression, type FrameworkResponse } from '@fluojs/http';
+export type MutableFrameworkResponse = FrameworkResponse & {
+    statusSet?: boolean;
+};
+export declare function createFrameworkResponse(response: ServerResponse, compression?: FrameworkResponseCompression): MutableFrameworkResponse;
+export declare function writeNodeAdapterErrorResponse(error: unknown, response: FrameworkResponse, requestId?: string): Promise<void>;
+//# sourceMappingURL=internal-node-response.d.ts.map

package/dist/node/internal-node-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-node-response.d.ts","sourceRoot":"","sources":["../../src/node/internal-node-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,OAAO,EAIL,KAAK,4BAA4B,EACjC,KAAK,iBAAiB,EAEvB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,wBAAwB,GAAG,iBAAiB,GAAG;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AA6CnF,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,cAAc,EACxB,WAAW,CAAC,EAAE,4BAA4B,GACzC,wBAAwB,CA+F1B;AAED,wBAAsB,6BAA6B,CACjD,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAIf"}