@duplojs/http 0.6.1 → 0.7.0

package/dist/core/router/index.cjs

@@ -6,8 +6,10 @@ var pathToRegExp = require('./pathToRegExp.cjs');
 var index = require('../route/index.cjs');
 var buildError = require('./buildError.cjs');
 require('../functionsBuilders/route/index.cjs');
-require('../functionsBuilders/steps/index.cjs');
 var decodeUrl = require('./decodeUrl.cjs');
+var text = require('../request/bodyController/text.cjs');
+var notFoundBodyReaderImplementationError = require('./notFoundBodyReaderImplementationError.cjs');
+require('../functionsBuilders/index.cjs');
 require('./types/index.cjs');
 var _default = require('../functionsBuilders/route/default.cjs');
 var checkerStep = require('../functionsBuilders/steps/defaults/checkerStep.cjs');
@@ -18,18 +20,21 @@ var processStep = require('../functionsBuilders/steps/defaults/processStep.cjs')
 var hooks = require('../hub/hooks.cjs');
 var build = require('../functionsBuilders/route/build.cjs');
 
-async function buildRouter(inputHub) {
-    const hub = inputHub
-        .addRouteFunctionBuilder(_default.defaultRouteFunctionBuilder)
-        .addStepFunctionBuilder([
+async function buildRouter(hub) {
+    const { environment } = hub.config;
+    const { hooksRouteLifeCycle, routes, hooksHubLifeCycle, bodyReaderImplementations, } = hub;
+    const routeFunctionBuilders = [
+        ...hub.routeFunctionBuilders,
+        _default.defaultRouteFunctionBuilder,
+    ];
+    const stepFunctionBuilders = [
+        ...hub.stepFunctionBuilders,
         checkerStep.defaultCheckerStepFunctionBuilder,
         cutStep.defaultCutStepFunctionBuilder,
         handlerStep.defaultHandlerStepFunctionBuilder,
         extractStep.defaultExtractStepFunctionBuilder,
         processStep.defaultProcessStepFunctionBuilder,
-    ]);
-    const { environment } = hub.config;
-    const { hooksRouteLifeCycle, routeFunctionBuilders, routes, stepFunctionBuilders, hooksHubLifeCycle, } = hub.aggregates();
+    ];
     const hooksBeforeBuildRoute = utils.pipe(hooksHubLifeCycle, utils.A.map(({ beforeBuildRoute }) => beforeBuildRoute), utils.A.filter(utils.isType("function")));
     const buildParams = {
         environment,
@@ -44,14 +49,23 @@ async function buildRouter(inputHub) {
         if (utils.E.isLeft(buildedRoute)) {
             throw new buildError.RouterBuildError(route, utils.unwrap(buildedRoute));
         }
+        const routeBodyController = route.definition.bodyController ?? hub.defaultBodyController;
+        const bodyReader = utils.pipe(bodyReaderImplementations, utils.A.reduce(utils.A.reduceFrom(null), ({ element, next, exit }) => utils.pipe(element, routeBodyController.tryToCreateReader, utils.E.whenIsRight(exit), utils.E.whenIsLeft(utils.justReturn(next(null))))));
+        if (!bodyReader) {
+            throw new notFoundBodyReaderImplementationError.NotFoundBodyReaderImplementationError(route, routeBodyController);
+        }
         return nextWithObject(lastValue, {
             [route.definition.method]: utils.A.concat(lastValue[route.definition.method] ?? [], utils.A.map(route.definition.paths, utils.O.to({
                 pattern: pathToRegExp.pathToRegExp,
                 buildedRoute: utils.justReturn(utils.unwrap(buildedRoute)),
                 matchedPath: utils.forward,
+                bodyReader: utils.justReturn(bodyReader),
             }))),
         });
     });
+    const bodyControllerNotfoundRoute = text.controlBodyAsText();
+    const bodyReaderNotFoundRoute = utils.unwrap(bodyControllerNotfoundRoute.tryToCreateReader(text.TextBodyController.createReaderImplementation(() => Promise.resolve(utils.E.error(new Error("Inaccessible body in not found route."))))));
+    utils.asserts(bodyReaderNotFoundRoute, utils.isType("object"));
     const buildedNotfoundRoute = await utils.asyncPipe(index.createRoute({
         method: "GET",
         paths: ["/"],
@@ -59,6 +73,7 @@ async function buildRouter(inputHub) {
         preflightSteps: [],
         steps: [hub.notfoundHandler],
         metadata: [],
+        bodyController: bodyControllerNotfoundRoute,
     }), async (route) => {
         const result = await build.buildRouteFunction(route, buildParams);
         return utils.E.whenIsLeft(result, (element) => {
@@ -76,6 +91,7 @@ async function buildRouter(inputHub) {
                     ...decodedUrl,
                     params: {},
                     matchedPath: null,
+                    bodyReader: bodyReaderNotFoundRoute,
                 }));
             }
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
@@ -90,6 +106,7 @@ async function buildRouter(inputHub) {
                     ...decodedUrl,
                     params: result.groups ?? {},
                     matchedPath: routerElement.matchedPath,
+                    bodyReader: routerElement.bodyReader,
                 }));
             }
             return buildedNotfoundRoute(new Request({
@@ -97,6 +114,7 @@ async function buildRouter(inputHub) {
                 ...decodedUrl,
                 params: {},
                 matchedPath: null,
+                bodyReader: bodyReaderNotFoundRoute,
             }));
         },
         hooksRouteLifeCycle,
@@ -112,4 +130,5 @@ exports.RouterBuildError = buildError.RouterBuildError;
 exports.decodeUrl = decodeUrl.decodeUrl;
 exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
 exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
+exports.NotFoundBodyReaderImplementationError = notFoundBodyReaderImplementationError.NotFoundBodyReaderImplementationError;
 exports.buildRouter = buildRouter;

package/dist/core/router/index.d.ts

@@ -4,4 +4,5 @@ export * from "./types";
 export * from "./pathToRegExp";
 export * from "./buildError";
 export * from "./decodeUrl";
-export declare function buildRouter(inputHub: Hub): Promise<BuildedRouter>;
+export * from "./notFoundBodyReaderImplementationError";
+export declare function buildRouter(hub: Hub): Promise<BuildedRouter>;

package/dist/core/router/index.mjs

@@ -1,12 +1,14 @@
 import '../hub/index.mjs';
-import { pipe, A, isType, G, E, unwrap, O, forward, justReturn, asyncPipe } from '@duplojs/utils';
+import { pipe, A, isType, G, E, unwrap, justReturn, O, forward, asserts, asyncPipe } from '@duplojs/utils';
 import { pathToRegExp } from './pathToRegExp.mjs';
 import { createRoute } from '../route/index.mjs';
 import { RouterBuildError } from './buildError.mjs';
 import '../functionsBuilders/route/index.mjs';
-import '../functionsBuilders/steps/index.mjs';
 import { decodeUrl } from './decodeUrl.mjs';
 export { regexQueryAnalyser, regexUrlAnalyser } from './decodeUrl.mjs';
+import { controlBodyAsText, TextBodyController } from '../request/bodyController/text.mjs';
+import { NotFoundBodyReaderImplementationError } from './notFoundBodyReaderImplementationError.mjs';
+import '../functionsBuilders/index.mjs';
 import './types/index.mjs';
 import { defaultRouteFunctionBuilder } from '../functionsBuilders/route/default.mjs';
 import { defaultCheckerStepFunctionBuilder } from '../functionsBuilders/steps/defaults/checkerStep.mjs';
@@ -17,18 +19,21 @@ import { defaultProcessStepFunctionBuilder } from '../functionsBuilders/steps/de
 import { launchHookBeforeBuildRoute } from '../hub/hooks.mjs';
 import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
 
-async function buildRouter(inputHub) {
-    const hub = inputHub
-        .addRouteFunctionBuilder(defaultRouteFunctionBuilder)
-        .addStepFunctionBuilder([
+async function buildRouter(hub) {
+    const { environment } = hub.config;
+    const { hooksRouteLifeCycle, routes, hooksHubLifeCycle, bodyReaderImplementations, } = hub;
+    const routeFunctionBuilders = [
+        ...hub.routeFunctionBuilders,
+        defaultRouteFunctionBuilder,
+    ];
+    const stepFunctionBuilders = [
+        ...hub.stepFunctionBuilders,
         defaultCheckerStepFunctionBuilder,
         defaultCutStepFunctionBuilder,
         defaultHandlerStepFunctionBuilder,
         defaultExtractStepFunctionBuilder,
         defaultProcessStepFunctionBuilder,
-    ]);
-    const { environment } = hub.config;
-    const { hooksRouteLifeCycle, routeFunctionBuilders, routes, stepFunctionBuilders, hooksHubLifeCycle, } = hub.aggregates();
+    ];
     const hooksBeforeBuildRoute = pipe(hooksHubLifeCycle, A.map(({ beforeBuildRoute }) => beforeBuildRoute), A.filter(isType("function")));
     const buildParams = {
         environment,
@@ -43,14 +48,23 @@ async function buildRouter(inputHub) {
         if (E.isLeft(buildedRoute)) {
             throw new RouterBuildError(route, unwrap(buildedRoute));
         }
+        const routeBodyController = route.definition.bodyController ?? hub.defaultBodyController;
+        const bodyReader = pipe(bodyReaderImplementations, A.reduce(A.reduceFrom(null), ({ element, next, exit }) => pipe(element, routeBodyController.tryToCreateReader, E.whenIsRight(exit), E.whenIsLeft(justReturn(next(null))))));
+        if (!bodyReader) {
+            throw new NotFoundBodyReaderImplementationError(route, routeBodyController);
+        }
         return nextWithObject(lastValue, {
             [route.definition.method]: A.concat(lastValue[route.definition.method] ?? [], A.map(route.definition.paths, O.to({
                 pattern: pathToRegExp,
                 buildedRoute: justReturn(unwrap(buildedRoute)),
                 matchedPath: forward,
+                bodyReader: justReturn(bodyReader),
             }))),
         });
     });
+    const bodyControllerNotfoundRoute = controlBodyAsText();
+    const bodyReaderNotFoundRoute = unwrap(bodyControllerNotfoundRoute.tryToCreateReader(TextBodyController.createReaderImplementation(() => Promise.resolve(E.error(new Error("Inaccessible body in not found route."))))));
+    asserts(bodyReaderNotFoundRoute, isType("object"));
     const buildedNotfoundRoute = await asyncPipe(createRoute({
         method: "GET",
         paths: ["/"],
@@ -58,6 +72,7 @@ async function buildRouter(inputHub) {
         preflightSteps: [],
         steps: [hub.notfoundHandler],
         metadata: [],
+        bodyController: bodyControllerNotfoundRoute,
     }), async (route) => {
         const result = await buildRouteFunction(route, buildParams);
         return E.whenIsLeft(result, (element) => {
@@ -75,6 +90,7 @@ async function buildRouter(inputHub) {
                     ...decodedUrl,
                     params: {},
                     matchedPath: null,
+                    bodyReader: bodyReaderNotFoundRoute,
                 }));
             }
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
@@ -89,6 +105,7 @@ async function buildRouter(inputHub) {
                     ...decodedUrl,
                     params: result.groups ?? {},
                     matchedPath: routerElement.matchedPath,
+                    bodyReader: routerElement.bodyReader,
                 }));
             }
             return buildedNotfoundRoute(new Request({
@@ -96,6 +113,7 @@ async function buildRouter(inputHub) {
                 ...decodedUrl,
                 params: {},
                 matchedPath: null,
+                bodyReader: bodyReaderNotFoundRoute,
             }));
         },
         hooksRouteLifeCycle,
@@ -106,4 +124,4 @@ async function buildRouter(inputHub) {
     };
 }
 
-export { RouterBuildError, buildRouter, decodeUrl, pathToRegExp };
+export { NotFoundBodyReaderImplementationError, RouterBuildError, buildRouter, decodeUrl, pathToRegExp };

package/dist/core/router/notFoundBodyReaderImplementationError.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+
+class NotFoundBodyReaderImplementationError extends utils.kindHeritage("not-found-body-reader-implementation-error", kind.createCoreLibKind("not-found-body-reader-implementation-error"), Error) {
+    route;
+    bodyController;
+    constructor(route, bodyController) {
+        super({}, ["Body reader implementation not found."]);
+        this.route = route;
+        this.bodyController = bodyController;
+    }
+}
+
+exports.NotFoundBodyReaderImplementationError = NotFoundBodyReaderImplementationError;

package/dist/core/router/notFoundBodyReaderImplementationError.d.ts

@@ -0,0 +1,11 @@
+import { type BodyController } from "../request";
+import { type Route } from "../route";
+declare const NotFoundBodyReaderImplementationError_base: new (params: {
+    "@DuplojsHttpCore/not-found-body-reader-implementation-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/not-found-body-reader-implementation-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"not-found-body-reader-implementation-error", unknown>, unknown>;
+export declare class NotFoundBodyReaderImplementationError extends NotFoundBodyReaderImplementationError_base {
+    route: Route;
+    bodyController: BodyController;
+    constructor(route: Route, bodyController: BodyController);
+}
+export {};

package/dist/core/router/notFoundBodyReaderImplementationError.mjs

@@ -0,0 +1,14 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+class NotFoundBodyReaderImplementationError extends kindHeritage("not-found-body-reader-implementation-error", createCoreLibKind("not-found-body-reader-implementation-error"), Error) {
+    route;
+    bodyController;
+    constructor(route, bodyController) {
+        super({}, ["Body reader implementation not found."]);
+        this.route = route;
+        this.bodyController = bodyController;
+    }
+}
+
+export { NotFoundBodyReaderImplementationError };

package/dist/core/router/types/buildedRouter.d.ts

@@ -1,11 +1,11 @@
 import { type createStepFunctionBuilder, type createRouteFunctionBuilder } from "../../functionsBuilders";
 import { type HookHubLifeCycle } from "../../hub";
 import { type RequestInitializationData } from "../../request";
-import { type HookRouteLifeCycle, type Route, type RouteDefinition } from "../../route";
-export type RouterInitializationData = Omit<RequestInitializationData, "matchedPath" | "params" | "path" | "query">;
+import { type HookRouteLifeCycle, type Route } from "../../route";
+export type RouterInitializationData = Omit<RequestInitializationData, "matchedPath" | "bodyReader" | "params" | "path" | "query">;
 export interface BuildedRouter {
     exec(initializationData: RouterInitializationData): Promise<void>;
-    readonly routes: readonly Route<RouteDefinition>[];
+    readonly routes: ReadonlySet<Route>;
     readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
     readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
     readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];

package/dist/core/steps/extract.d.ts

@@ -6,7 +6,9 @@ import { type Metadata } from "../metadata";
 export interface DisabledExtractKeysCustom {
 }
 export type DisabledExtractKeys = O.GetPropsWithValue<DisabledExtractKeysCustom, true>;
-export type ExtractShape<GenericRequest extends Request = Request> = Partial<Record<Exclude<keyof GenericRequest, O.GetPropsWithValueExtends<GenericRequest, AnyFunction> | DisabledExtractKeys>, DP.DataParser | Record<string, DP.DataParser>>>;
+export type ExtractShape<GenericRequest extends Request = Request> = Partial<Record<Exclude<keyof GenericRequest, O.GetPropsWithValueExtends<GenericRequest, AnyFunction> | DisabledExtractKeys | "body" | "bodyReader" | symbol>, DP.DataParser | Record<string, DP.DataParser>> & {
+    body: (DP.DataParser | Record<string, DP.DataParser>);
+}>;
 export interface ExtractStepDefinition {
     readonly shape: ExtractShape;
     readonly responseContract?: ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>;

package/dist/core/steps/types/steps.d.ts

@@ -1,11 +1,9 @@
-import { type Kind, type O } from "@duplojs/utils";
 import { type CheckerStep } from "../checker";
 import { type CutStep } from "../cut";
 import { type ExtractStep } from "../extract";
 import { type HandlerStep } from "../handler";
 import { type PresetCheckerStep } from "../presetChecker";
 import { type ProcessStep } from "../process";
-import { type stepKind } from "../kind";
 export interface StepsCustom {
 }
-export type Steps = (StepsCustom[O.GetPropsWithValueExtends<StepsCustom, Kind<typeof stepKind.definition>>] | CheckerStep | CutStep | ExtractStep | HandlerStep | PresetCheckerStep | ProcessStep);
+export type Steps = (StepsCustom[keyof StepsCustom] | CheckerStep | CutStep | ExtractStep | HandlerStep | PresetCheckerStep | ProcessStep);

package/dist/core/types/hosts.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/types/hosts.d.ts

@@ -0,0 +1,4 @@
+import { type O } from "@duplojs/utils";
+export interface HostCustom {
+}
+export type Hosts = O.GetPropsWithValue<HostCustom, true>;

package/dist/core/types/hosts.mjs

@@ -0,0 +1 @@
+

package/dist/core/types/httpServerParams.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/types/httpServerParams.d.ts

@@ -0,0 +1,11 @@
+import { type BytesInString } from "@duplojs/utils";
+import { type Hosts } from "./hosts";
+export interface HttpServerParams {
+    readonly host: Hosts;
+    readonly port: number;
+    readonly maxBodySize: BytesInString | number;
+    readonly informationHeaderKey: string;
+    readonly predictedHeaderKey: string;
+    readonly fromHookHeaderKey: string;
+    readonly uploadFolder: string;
+}

package/dist/core/types/httpServerParams.mjs

@@ -0,0 +1 @@
+

package/dist/core/types/index.cjs

@@ -2,4 +2,6 @@
 
 require('./environment.cjs');
 require('./forbiddenBigintDataParser.cjs');
+require('./httpServerParams.cjs');
+require('./hosts.cjs');
 

package/dist/core/types/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./environment";
 export * from "./forbiddenBigintDataParser";
+export * from "./httpServerParams";
+export * from "./hosts";

package/dist/core/types/index.mjs

@@ -1,2 +1,4 @@
 import './environment.mjs';
 import './forbiddenBigintDataParser.mjs';
+import './httpServerParams.mjs';
+import './hosts.mjs';

package/dist/interfaces/bun/types/request.cjs

@@ -1,5 +1,5 @@
 'use strict';
 
-require('../../../core/request.cjs');
+require('../../../core/request/index.cjs');
 require('../../../core/steps/index.cjs');
 

package/dist/interfaces/bun/types/request.mjs

@@ -1,2 +1,2 @@
-import '../../../core/request.mjs';
+import '../../../core/request/index.mjs';
 import '../../../core/steps/index.mjs';

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

@@ -0,0 +1,14 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../../kind.cjs');
+
+class BodyParseFormDataError extends utils.kindHeritage("body-parse-form-data-error", kind.createInterfacesNodeLibKind("body-parse-form-data-error"), Error) {
+    information;
+    constructor(information) {
+        super({}, [`Body parse form date error: ${information}`]);
+        this.information = information;
+    }
+}
+
+exports.BodyParseFormDataError = BodyParseFormDataError;

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

@@ -0,0 +1,8 @@
+declare const BodyParseFormDataError_base: new (params: {
+    "@DuplojsHttpInterfacesNode/body-parse-form-data-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-form-data-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-form-data-error", unknown>, unknown>;
+export declare class BodyParseFormDataError extends BodyParseFormDataError_base {
+    information: string;
+    constructor(information: string);
+}
+export {};

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

@@ -0,0 +1,12 @@
+import { kindHeritage } from '@duplojs/utils';
+import { createInterfacesNodeLibKind } from '../../kind.mjs';
+
+class BodyParseFormDataError extends kindHeritage("body-parse-form-data-error", createInterfacesNodeLibKind("body-parse-form-data-error"), Error) {
+    information;
+    constructor(information) {
+        super({}, [`Body parse form date error: ${information}`]);
+        this.information = information;
+    }
+}
+
+export { BodyParseFormDataError };

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 };