@duplojs/http 0.6.2 → 0.7.0

package/dist/interfaces/node/bodyReaders/formData/index.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+require('../../../../core/request/index.cjs');
+var serverUtils = require('@duplojs/server-utils');
+var utils = require('@duplojs/utils');
+var readRequestFormData = require('./readRequestFormData.cjs');
+var node_fs = require('node:fs');
+require('../../../../core/errors/index.cjs');
+var error = require('./error.cjs');
+var formData = require('../../../../core/request/bodyController/formData.cjs');
+var wrongContentTypeError = require('../../../../core/errors/wrongContentTypeError.cjs');
+
+function createFormDataBodyReaderImplementation(serverParams) {
+    const serverMaxBodySize = utils.stringToBytes(serverParams.maxBodySize);
+    function addValue(mapResult, fieldName, newValue) {
+        const value = mapResult.get(fieldName);
+        if (value === undefined) {
+            mapResult.set(fieldName, newValue);
+        }
+        else {
+            mapResult.set(fieldName, utils.A.push(utils.A.coalescing(value), newValue));
+        }
+    }
+    return formData.FormDataBodyController.createReaderImplementation(async (request, params) => {
+        if (!request.headers["content-type"]?.includes("multipart/form-data")) {
+            return utils.E.error(new wrongContentTypeError.WrongContentTypeError("multipart/form-data", utils.A.join(utils.A.coalescing(request.headers["content-type"] ?? ""), " ")));
+        }
+        const filesAttache = [];
+        request.filesAttache = filesAttache;
+        const result = await readRequestFormData.readRequestFormData(request.raw.request, new Map(), {
+            maxBodySize: params.bodyMaxSize ?? serverMaxBodySize,
+            fileMaxSize: params.fileMaxSize ?? Infinity,
+            maxFileQuantity: params.maxFileQuantity,
+            mimeType: params.mimeType,
+            maxBufferSize: params.maxBufferSize,
+            maxKeyLength: params.maxKeyLength,
+        }, (header) => {
+            const fieldName = header.name;
+            if (header.filename) {
+                const extension = utils.Path.getExtensionName(header.filename);
+                const displayExtension = extension ? `.${extension}` : "";
+                const filePath = utils.Path.resolveRelative([
+                    serverParams.uploadFolder,
+                    `${Math.random().toString(36).slice(2, 10)}-${Date.now()}${displayExtension}`,
+                ]);
+                filesAttache.push(filePath);
+                const currentFile = node_fs.createWriteStream(filePath, {
+                    highWaterMark: request.raw.request.readableHighWaterMark,
+                });
+                return {
+                    onReceiveChunk: (chunk) => new Promise((resolve, reject) => void currentFile.write(chunk, (result) => {
+                        if (result instanceof Error) {
+                            return void reject(result);
+                        }
+                        return void resolve();
+                    })),
+                    onEndPart: (valueAccumulator) => {
+                        currentFile.end();
+                        addValue(valueAccumulator, fieldName, serverUtils.SF.createFileInterface(currentFile.path.toString()));
+                        return valueAccumulator;
+                    },
+                    onError: () => void currentFile.end(),
+                };
+            }
+            let currentValue = "";
+            return {
+                onReceiveChunk: (chunk) => {
+                    currentValue += chunk.toString("utf-8");
+                },
+                onEndPart: (valueAccumulator) => {
+                    addValue(valueAccumulator, fieldName, currentValue);
+                    return valueAccumulator;
+                },
+                onError: null,
+            };
+        });
+        if (utils.E.isLeft(result)) {
+            // mandatory in case of error to avoid monopolizing the client connection if a stream is not finished.
+            request.raw.response.setHeader("Connection", "close");
+            if (utils.E.hasInformation(result, "server-error")) {
+                throw utils.unwrap(result);
+            }
+            return result;
+        }
+        if (request.headers["content-type-options"]?.includes("advanced")) {
+            return utils.E.success(utils.TheFormData.fromEntries(result.entries(), params.maxIndexArray));
+        }
+        return utils.E.success(utils.O.fromEntries(result.entries()));
+    });
+}
+
+exports.readRequestFormData = readRequestFormData.readRequestFormData;
+exports.BodyParseFormDataError = error.BodyParseFormDataError;
+exports.createFormDataBodyReaderImplementation = createFormDataBodyReaderImplementation;

package/dist/interfaces/node/bodyReaders/formData/index.d.ts

@@ -0,0 +1,4 @@
+import { type HttpServerParams } from "../../../../core/types";
+export * from "./error";
+export * from "./readRequestFormData";
+export declare function createFormDataBodyReaderImplementation(serverParams: HttpServerParams): import("../../../../core/request").BodyReaderImplementation<"formData", import("../../../../core/request").FormDataBodyReaderParams>;

package/dist/interfaces/node/bodyReaders/formData/index.mjs

@@ -0,0 +1,90 @@
+import '../../../../core/request/index.mjs';
+import { SF } from '@duplojs/server-utils';
+import { stringToBytes, A, E, Path, unwrap, TheFormData, O } from '@duplojs/utils';
+import { readRequestFormData } from './readRequestFormData.mjs';
+import { createWriteStream } from 'node:fs';
+import '../../../../core/errors/index.mjs';
+export { BodyParseFormDataError } from './error.mjs';
+import { FormDataBodyController } from '../../../../core/request/bodyController/formData.mjs';
+import { WrongContentTypeError } from '../../../../core/errors/wrongContentTypeError.mjs';
+
+function createFormDataBodyReaderImplementation(serverParams) {
+    const serverMaxBodySize = stringToBytes(serverParams.maxBodySize);
+    function addValue(mapResult, fieldName, newValue) {
+        const value = mapResult.get(fieldName);
+        if (value === undefined) {
+            mapResult.set(fieldName, newValue);
+        }
+        else {
+            mapResult.set(fieldName, A.push(A.coalescing(value), newValue));
+        }
+    }
+    return FormDataBodyController.createReaderImplementation(async (request, params) => {
+        if (!request.headers["content-type"]?.includes("multipart/form-data")) {
+            return E.error(new WrongContentTypeError("multipart/form-data", A.join(A.coalescing(request.headers["content-type"] ?? ""), " ")));
+        }
+        const filesAttache = [];
+        request.filesAttache = filesAttache;
+        const result = await readRequestFormData(request.raw.request, new Map(), {
+            maxBodySize: params.bodyMaxSize ?? serverMaxBodySize,
+            fileMaxSize: params.fileMaxSize ?? Infinity,
+            maxFileQuantity: params.maxFileQuantity,
+            mimeType: params.mimeType,
+            maxBufferSize: params.maxBufferSize,
+            maxKeyLength: params.maxKeyLength,
+        }, (header) => {
+            const fieldName = header.name;
+            if (header.filename) {
+                const extension = Path.getExtensionName(header.filename);
+                const displayExtension = extension ? `.${extension}` : "";
+                const filePath = Path.resolveRelative([
+                    serverParams.uploadFolder,
+                    `${Math.random().toString(36).slice(2, 10)}-${Date.now()}${displayExtension}`,
+                ]);
+                filesAttache.push(filePath);
+                const currentFile = createWriteStream(filePath, {
+                    highWaterMark: request.raw.request.readableHighWaterMark,
+                });
+                return {
+                    onReceiveChunk: (chunk) => new Promise((resolve, reject) => void currentFile.write(chunk, (result) => {
+                        if (result instanceof Error) {
+                            return void reject(result);
+                        }
+                        return void resolve();
+                    })),
+                    onEndPart: (valueAccumulator) => {
+                        currentFile.end();
+                        addValue(valueAccumulator, fieldName, SF.createFileInterface(currentFile.path.toString()));
+                        return valueAccumulator;
+                    },
+                    onError: () => void currentFile.end(),
+                };
+            }
+            let currentValue = "";
+            return {
+                onReceiveChunk: (chunk) => {
+                    currentValue += chunk.toString("utf-8");
+                },
+                onEndPart: (valueAccumulator) => {
+                    addValue(valueAccumulator, fieldName, currentValue);
+                    return valueAccumulator;
+                },
+                onError: null,
+            };
+        });
+        if (E.isLeft(result)) {
+            // mandatory in case of error to avoid monopolizing the client connection if a stream is not finished.
+            request.raw.response.setHeader("Connection", "close");
+            if (E.hasInformation(result, "server-error")) {
+                throw unwrap(result);
+            }
+            return result;
+        }
+        if (request.headers["content-type-options"]?.includes("advanced")) {
+            return E.success(TheFormData.fromEntries(result.entries(), params.maxIndexArray));
+        }
+        return E.success(O.fromEntries(result.entries()));
+    });
+}
+
+export { createFormDataBodyReaderImplementation, readRequestFormData };

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.cjs

@@ -0,0 +1,175 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var error = require('./error.cjs');
+require('../../../../core/errors/index.cjs');
+var bodySizeExceedsLimitError = require('../../../../core/errors/bodySizeExceedsLimitError.cjs');
+var bodyParseWrongChunkReceived = require('../../../../core/errors/bodyParseWrongChunkReceived.cjs');
+
+const endHeaderPart = Buffer.from("\r\n\r\n");
+const bufferStart = Buffer.from("\r\n");
+const regexBoundary = /boundary=(?<boundary>[^; ]+)/i;
+const regexHeaderPart = /name="(?<name>(?:\\"|[^"])+)"(?:; filename="(?<filename>(?:\\"|[^"])+)")?(?:;\s+filename\*=[^']+'[^']*'(?<encodedFilename>[^;\r\n\s]+))?/i;
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+async function readRequestFormData(request, firstValueAccumulator, params, onReceiveHeader) {
+    const boundary = utils.S.extract(request.headers["content-type"] ?? "", regexBoundary)?.namedGroups?.boundary;
+    if (!boundary) {
+        return utils.E.error(new error.BodyParseFormDataError("Wrong boundary."));
+    }
+    let valueAccumulator = firstValueAccumulator;
+    const startPart = Buffer.from(`\r\n--${boundary}`);
+    const endMultiPart = Buffer.from(`\r\n--${boundary}--`);
+    let currentBuffer = bufferStart;
+    let size = 0;
+    const keep = endMultiPart.length - 1;
+    let currentStream = undefined;
+    let fileQuantity = 0;
+    let currentFileSize = undefined;
+    const checkSize = (receivedChunk) => {
+        size += receivedChunk.length;
+        return size > params.maxBodySize
+            ? new bodySizeExceedsLimitError.BodySizeExceedsLimitError(params.maxBodySize)
+            : true;
+    };
+    const flushReceiveHeader = async (headerPart) => {
+        valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
+        const sizeResult = checkSize(headerPart);
+        if (sizeResult !== true) {
+            return sizeResult;
+        }
+        const extract = utils.S.extract(headerPart.toString("utf-8"), regexHeaderPart)?.namedGroups;
+        const header = extract?.name
+            ? {
+                name: extract.name.trim(),
+                filename: (extract.encodedFilename !== undefined
+                    ? safeDecode(extract.encodedFilename)
+                    : extract.filename)?.trim(),
+            }
+            : null;
+        if (!header) {
+            return new error.BodyParseFormDataError("Bad content header part.");
+        }
+        if (header.name.length > params.maxKeyLength) {
+            return new error.BodyParseFormDataError("key length exceeds limit.");
+        }
+        if (header.filename !== undefined) {
+            currentFileSize = 0;
+            fileQuantity++;
+            if (fileQuantity > params.maxFileQuantity) {
+                return new error.BodyParseFormDataError("File quantity exceeds limit.");
+            }
+            else if (params.mimeType !== undefined
+                && !params.mimeType.test(utils.Path.getExtensionName(header.filename) ?? "")) {
+                return new error.BodyParseFormDataError("File have wrong mimeType.");
+            }
+        }
+        else {
+            currentFileSize = undefined;
+        }
+        const newStream = await onReceiveHeader(header);
+        if (newStream instanceof Error) {
+            return newStream;
+        }
+        currentStream = newStream;
+        return true;
+    };
+    const flushReceiveChunk = async (chunk) => {
+        if (chunk.length === 0) {
+            return true;
+        }
+        const sizeResult = checkSize(chunk);
+        if (sizeResult !== true) {
+            return sizeResult;
+        }
+        if (!currentStream) {
+            return new error.BodyParseFormDataError("Receive chunk before header part.");
+        }
+        if (typeof currentFileSize === "number") {
+            currentFileSize += chunk.length;
+            if (params.fileMaxSize !== undefined && currentFileSize > params.fileMaxSize) {
+                return new error.BodyParseFormDataError("File size exceeds limit.");
+            }
+        }
+        await currentStream.onReceiveChunk(chunk);
+        return true;
+    };
+    const treatError = async (error) => {
+        await currentStream?.onError?.(error, valueAccumulator);
+        return utils.E.error(error);
+    };
+    try {
+        for await (const chunk of request) {
+            if (!(chunk instanceof Buffer)) {
+                return await treatError(new bodyParseWrongChunkReceived.BodyParseWrongChunkReceived("Buffer.", chunk));
+            }
+            currentBuffer = Buffer.concat([currentBuffer, chunk]);
+            if (currentBuffer.length > params.maxBufferSize) {
+                return await treatError(new error.BodyParseFormDataError("Buffer size exceeds limit."));
+            }
+            while (true) {
+                const endMultiPartIndex = currentBuffer.indexOf(endMultiPart);
+                if (endMultiPartIndex !== -1) {
+                    // check if buffer contain end of transmissions
+                    currentBuffer = currentBuffer.subarray(0, endMultiPartIndex);
+                }
+                const startPartIndex = currentBuffer.indexOf(startPart);
+                const endHeaderPartIndex = currentBuffer.indexOf(endHeaderPart);
+                if (startPartIndex !== -1 && endHeaderPartIndex !== -1) {
+                    // check if buffer contain an entire header of part
+                    const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, startPartIndex));
+                    if (resultChunk !== true) {
+                        return await treatError(resultChunk);
+                    }
+                    const endIndex = endHeaderPartIndex + endHeaderPart.length;
+                    const resultHeader = await flushReceiveHeader(currentBuffer.subarray(startPartIndex, endIndex));
+                    if (resultHeader !== true) {
+                        return await treatError(resultHeader);
+                    }
+                    currentBuffer = currentBuffer.subarray(endIndex);
+                }
+                else if (startPartIndex === -1 && endHeaderPartIndex === -1) {
+                    // check if buffer contain only data
+                    if (currentBuffer.length > keep) {
+                        const bufferRestIndex = currentBuffer.length - keep;
+                        const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, bufferRestIndex));
+                        if (resultChunk !== true) {
+                            return await treatError(resultChunk);
+                        }
+                        currentBuffer = currentBuffer.subarray(bufferRestIndex);
+                    }
+                    break;
+                }
+                else if (startPartIndex !== -1 && endHeaderPartIndex === -1) {
+                    // check if buffer contain start of header but not contain end
+                    break;
+                }
+                else {
+                    // check if buffer contain only end of header part
+                    return await treatError(new error.BodyParseFormDataError("Wrong content."));
+                }
+            }
+        }
+        const resultChunk = await flushReceiveChunk(currentBuffer);
+        if (resultChunk !== true) {
+            return await treatError(resultChunk);
+        }
+        valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
+        return valueAccumulator;
+    }
+    catch (error) {
+        await currentStream?.onError?.(error, valueAccumulator);
+        return utils.E.left("server-error", error);
+    }
+    finally {
+        request.destroy();
+    }
+}
+
+exports.readRequestFormData = readRequestFormData;

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.d.ts

@@ -0,0 +1,21 @@
+import { E, type MaybePromise } from "@duplojs/utils";
+import type http from "http";
+interface HeaderPartInformation {
+    name: string;
+    filename?: string;
+}
+export interface ReadRequestFormDataStreamChunkEvent<GenericValueAccumulator extends unknown = unknown> {
+    onReceiveChunk(chunk: Buffer): MaybePromise<void>;
+    onEndPart(valueAccumulator: GenericValueAccumulator): MaybePromise<GenericValueAccumulator>;
+    onError: ((error: unknown, valueAccumulator: GenericValueAccumulator) => MaybePromise<void>) | null;
+}
+export interface ReadRequestFormDataParams {
+    maxBodySize: number;
+    maxFileQuantity: number;
+    maxBufferSize: number;
+    maxKeyLength: number;
+    fileMaxSize?: number;
+    mimeType?: RegExp;
+}
+export declare function readRequestFormData<GenericValueAccumulator extends unknown, GenericOutputHeader extends E.Left = never>(request: http.IncomingMessage, firstValueAccumulator: GenericValueAccumulator, params: ReadRequestFormDataParams, onReceiveHeader: (header: HeaderPartInformation) => MaybePromise<ReadRequestFormDataStreamChunkEvent<GenericValueAccumulator> | Error>): Promise<E.Left<"server-error", unknown> | GenericOutputHeader | E.Error<Error> | GenericValueAccumulator>;
+export {};

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.mjs

@@ -0,0 +1,173 @@
+import { S, E, Path } from '@duplojs/utils';
+import { BodyParseFormDataError } from './error.mjs';
+import '../../../../core/errors/index.mjs';
+import { BodySizeExceedsLimitError } from '../../../../core/errors/bodySizeExceedsLimitError.mjs';
+import { BodyParseWrongChunkReceived } from '../../../../core/errors/bodyParseWrongChunkReceived.mjs';
+
+const endHeaderPart = Buffer.from("\r\n\r\n");
+const bufferStart = Buffer.from("\r\n");
+const regexBoundary = /boundary=(?<boundary>[^; ]+)/i;
+const regexHeaderPart = /name="(?<name>(?:\\"|[^"])+)"(?:; filename="(?<filename>(?:\\"|[^"])+)")?(?:;\s+filename\*=[^']+'[^']*'(?<encodedFilename>[^;\r\n\s]+))?/i;
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+async function readRequestFormData(request, firstValueAccumulator, params, onReceiveHeader) {
+    const boundary = S.extract(request.headers["content-type"] ?? "", regexBoundary)?.namedGroups?.boundary;
+    if (!boundary) {
+        return E.error(new BodyParseFormDataError("Wrong boundary."));
+    }
+    let valueAccumulator = firstValueAccumulator;
+    const startPart = Buffer.from(`\r\n--${boundary}`);
+    const endMultiPart = Buffer.from(`\r\n--${boundary}--`);
+    let currentBuffer = bufferStart;
+    let size = 0;
+    const keep = endMultiPart.length - 1;
+    let currentStream = undefined;
+    let fileQuantity = 0;
+    let currentFileSize = undefined;
+    const checkSize = (receivedChunk) => {
+        size += receivedChunk.length;
+        return size > params.maxBodySize
+            ? new BodySizeExceedsLimitError(params.maxBodySize)
+            : true;
+    };
+    const flushReceiveHeader = async (headerPart) => {
+        valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
+        const sizeResult = checkSize(headerPart);
+        if (sizeResult !== true) {
+            return sizeResult;
+        }
+        const extract = S.extract(headerPart.toString("utf-8"), regexHeaderPart)?.namedGroups;
+        const header = extract?.name
+            ? {
+                name: extract.name.trim(),
+                filename: (extract.encodedFilename !== undefined
+                    ? safeDecode(extract.encodedFilename)
+                    : extract.filename)?.trim(),
+            }
+            : null;
+        if (!header) {
+            return new BodyParseFormDataError("Bad content header part.");
+        }
+        if (header.name.length > params.maxKeyLength) {
+            return new BodyParseFormDataError("key length exceeds limit.");
+        }
+        if (header.filename !== undefined) {
+            currentFileSize = 0;
+            fileQuantity++;
+            if (fileQuantity > params.maxFileQuantity) {
+                return new BodyParseFormDataError("File quantity exceeds limit.");
+            }
+            else if (params.mimeType !== undefined
+                && !params.mimeType.test(Path.getExtensionName(header.filename) ?? "")) {
+                return new BodyParseFormDataError("File have wrong mimeType.");
+            }
+        }
+        else {
+            currentFileSize = undefined;
+        }
+        const newStream = await onReceiveHeader(header);
+        if (newStream instanceof Error) {
+            return newStream;
+        }
+        currentStream = newStream;
+        return true;
+    };
+    const flushReceiveChunk = async (chunk) => {
+        if (chunk.length === 0) {
+            return true;
+        }
+        const sizeResult = checkSize(chunk);
+        if (sizeResult !== true) {
+            return sizeResult;
+        }
+        if (!currentStream) {
+            return new BodyParseFormDataError("Receive chunk before header part.");
+        }
+        if (typeof currentFileSize === "number") {
+            currentFileSize += chunk.length;
+            if (params.fileMaxSize !== undefined && currentFileSize > params.fileMaxSize) {
+                return new BodyParseFormDataError("File size exceeds limit.");
+            }
+        }
+        await currentStream.onReceiveChunk(chunk);
+        return true;
+    };
+    const treatError = async (error) => {
+        await currentStream?.onError?.(error, valueAccumulator);
+        return E.error(error);
+    };
+    try {
+        for await (const chunk of request) {
+            if (!(chunk instanceof Buffer)) {
+                return await treatError(new BodyParseWrongChunkReceived("Buffer.", chunk));
+            }
+            currentBuffer = Buffer.concat([currentBuffer, chunk]);
+            if (currentBuffer.length > params.maxBufferSize) {
+                return await treatError(new BodyParseFormDataError("Buffer size exceeds limit."));
+            }
+            while (true) {
+                const endMultiPartIndex = currentBuffer.indexOf(endMultiPart);
+                if (endMultiPartIndex !== -1) {
+                    // check if buffer contain end of transmissions
+                    currentBuffer = currentBuffer.subarray(0, endMultiPartIndex);
+                }
+                const startPartIndex = currentBuffer.indexOf(startPart);
+                const endHeaderPartIndex = currentBuffer.indexOf(endHeaderPart);
+                if (startPartIndex !== -1 && endHeaderPartIndex !== -1) {
+                    // check if buffer contain an entire header of part
+                    const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, startPartIndex));
+                    if (resultChunk !== true) {
+                        return await treatError(resultChunk);
+                    }
+                    const endIndex = endHeaderPartIndex + endHeaderPart.length;
+                    const resultHeader = await flushReceiveHeader(currentBuffer.subarray(startPartIndex, endIndex));
+                    if (resultHeader !== true) {
+                        return await treatError(resultHeader);
+                    }
+                    currentBuffer = currentBuffer.subarray(endIndex);
+                }
+                else if (startPartIndex === -1 && endHeaderPartIndex === -1) {
+                    // check if buffer contain only data
+                    if (currentBuffer.length > keep) {
+                        const bufferRestIndex = currentBuffer.length - keep;
+                        const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, bufferRestIndex));
+                        if (resultChunk !== true) {
+                            return await treatError(resultChunk);
+                        }
+                        currentBuffer = currentBuffer.subarray(bufferRestIndex);
+                    }
+                    break;
+                }
+                else if (startPartIndex !== -1 && endHeaderPartIndex === -1) {
+                    // check if buffer contain start of header but not contain end
+                    break;
+                }
+                else {
+                    // check if buffer contain only end of header part
+                    return await treatError(new BodyParseFormDataError("Wrong content."));
+                }
+            }
+        }
+        const resultChunk = await flushReceiveChunk(currentBuffer);
+        if (resultChunk !== true) {
+            return await treatError(resultChunk);
+        }
+        valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
+        return valueAccumulator;
+    }
+    catch (error) {
+        await currentStream?.onError?.(error, valueAccumulator);
+        return E.left("server-error", error);
+    }
+    finally {
+        request.destroy();
+    }
+}
+
+export { readRequestFormData };

package/dist/interfaces/node/bodyReaders/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var index = require('./formData/index.cjs');
+var index$1 = require('./text/index.cjs');
+
+
+
+exports.createFormDataBodyReaderImplementation = index.createFormDataBodyReaderImplementation;
+exports.createTextBodyReaderImplementation = index$1.createTextBodyReaderImplementation;

package/dist/interfaces/node/bodyReaders/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./formData";
+export * from "./text";

package/dist/interfaces/node/bodyReaders/index.mjs

@@ -0,0 +1,2 @@
+export { createFormDataBodyReaderImplementation } from './formData/index.mjs';
+export { createTextBodyReaderImplementation } from './text/index.mjs';

package/dist/interfaces/node/bodyReaders/text/index.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+require('../../../../core/request/index.cjs');
+var readRequestText = require('./readRequestText.cjs');
+var utils = require('@duplojs/utils');
+require('../../../../core/errors/index.cjs');
+var text = require('../../../../core/request/bodyController/text.cjs');
+var wrongContentTypeError = require('../../../../core/errors/wrongContentTypeError.cjs');
+var parseJsonError = require('../../../../core/errors/parseJsonError.cjs');
+
+function createTextBodyReaderImplementation(serverParams) {
+    const serverMaxBodySize = utils.stringToBytes(serverParams.maxBodySize);
+    return text.TextBodyController.createReaderImplementation(async (request, params) => {
+        if (!request.headers["content-type"]?.includes("application/json")
+            && !request.headers["content-type"]?.includes("text/plain")) {
+            return utils.E.error(new wrongContentTypeError.WrongContentTypeError("application/json or text/plain", utils.A.join(utils.A.coalescing(request.headers["content-type"] ?? ""), " ")));
+        }
+        const result = await readRequestText.readRequestText(request.raw.request, { maxBodySize: params.bodyMaxSize ?? serverMaxBodySize }, (result) => {
+            if (request.headers["content-type"]?.includes("application/json")) {
+                try {
+                    return utils.E.success(JSON.parse(result));
+                }
+                catch (error) {
+                    return utils.E.error(new parseJsonError.ParseJsonError(result, error));
+                }
+            }
+            return utils.E.success(result);
+        });
+        if (utils.E.isLeft(result)) {
+            // mandatory in case of error to avoid monopolizing the client connection if a stream is not finished.
+            request.raw.response.setHeader("Connection", "close");
+        }
+        if (utils.E.hasInformation(result, "server-error")) {
+            throw utils.unwrap(result);
+        }
+        return result;
+    });
+}
+
+exports.readRequestText = readRequestText.readRequestText;
+exports.createTextBodyReaderImplementation = createTextBodyReaderImplementation;

package/dist/interfaces/node/bodyReaders/text/index.d.ts

@@ -0,0 +1,3 @@
+import { type HttpServerParams } from "../../../../core/types";
+export * from "./readRequestText";
+export declare function createTextBodyReaderImplementation(serverParams: HttpServerParams): import("../../../../core/request").BodyReaderImplementation<"text", import("../../../../core/request").TextBodyReaderParams>;

package/dist/interfaces/node/bodyReaders/text/index.mjs

@@ -0,0 +1,38 @@
+import '../../../../core/request/index.mjs';
+import { readRequestText } from './readRequestText.mjs';
+import { stringToBytes, E, A, unwrap } from '@duplojs/utils';
+import '../../../../core/errors/index.mjs';
+import { TextBodyController } from '../../../../core/request/bodyController/text.mjs';
+import { WrongContentTypeError } from '../../../../core/errors/wrongContentTypeError.mjs';
+import { ParseJsonError } from '../../../../core/errors/parseJsonError.mjs';
+
+function createTextBodyReaderImplementation(serverParams) {
+    const serverMaxBodySize = stringToBytes(serverParams.maxBodySize);
+    return TextBodyController.createReaderImplementation(async (request, params) => {
+        if (!request.headers["content-type"]?.includes("application/json")
+            && !request.headers["content-type"]?.includes("text/plain")) {
+            return E.error(new WrongContentTypeError("application/json or text/plain", A.join(A.coalescing(request.headers["content-type"] ?? ""), " ")));
+        }
+        const result = await readRequestText(request.raw.request, { maxBodySize: params.bodyMaxSize ?? serverMaxBodySize }, (result) => {
+            if (request.headers["content-type"]?.includes("application/json")) {
+                try {
+                    return E.success(JSON.parse(result));
+                }
+                catch (error) {
+                    return E.error(new ParseJsonError(result, error));
+                }
+            }
+            return E.success(result);
+        });
+        if (E.isLeft(result)) {
+            // mandatory in case of error to avoid monopolizing the client connection if a stream is not finished.
+            request.raw.response.setHeader("Connection", "close");
+        }
+        if (E.hasInformation(result, "server-error")) {
+            throw unwrap(result);
+        }
+        return result;
+    });
+}
+
+export { createTextBodyReaderImplementation, readRequestText };