@duplojs/http 0.6.2 → 0.7.1

package/dist/core/hub/index.mjs

@@ -1,140 +1,112 @@
 import { createCoreLibKind } from '../kind.mjs';
 import { routeKind } from '../route/index.mjs';
-import { A, pipe, P, isType, O } from '@duplojs/utils';
+import { kindHeritage, pipe, P, A, isType, O } from '@duplojs/utils';
 import '../steps/index.mjs';
-import { Request } from '../request.mjs';
+import { Request } from '../request/index.mjs';
 import { defaultNotfoundHandler } from './defaultNotfoundHandler.mjs';
 import { defaultExtractContract } from './defaultExtractContract.mjs';
+import { defaultBodyController } from './defaultBodyController.mjs';
 export { createHookHubLifeCycle, hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hooks.mjs';
 import { createHandlerStep } from '../steps/handler.mjs';
 
 const hubKind = createCoreLibKind("hub");
+class Hub extends kindHeritage("hub", createCoreLibKind("hub")) {
+    config;
+    plugins = [];
+    hooksRouteLifeCycle = [];
+    hooksHubLifeCycle = [];
+    routes = new Set();
+    routeFunctionBuilders = [];
+    stepFunctionBuilders = [];
+    bodyReaderImplementations = [];
+    classRequest = Request;
+    notfoundHandler = defaultNotfoundHandler;
+    defaultExtractContract = defaultExtractContract;
+    defaultBodyController = defaultBodyController;
+    constructor(config) {
+        super({});
+        this.config = config;
+    }
+    register(routes) {
+        pipe(routes, P.when(routeKind.has, A.coalescing), P.when(isType("iterable"), A.from), P.otherwise(O.values), A.map((route) => this.routes.add(route)));
+        return this;
+    }
+    addRouteFunctionBuilder(functionBuilder) {
+        this.routeFunctionBuilders.push(...A.coalescing(functionBuilder));
+        return this;
+    }
+    addStepFunctionBuilder(functionBuilder) {
+        this.stepFunctionBuilders.push(...A.coalescing(functionBuilder));
+        return this;
+    }
+    addRouteHooks(hook) {
+        this.hooksRouteLifeCycle.push(...A.coalescing(hook));
+        return this;
+    }
+    addHubHooks(hook) {
+        this.hooksHubLifeCycle.push(...A.coalescing(hook));
+        return this;
+    }
+    addBodyReaderImplementation(bodyReaderImplementation) {
+        this.bodyReaderImplementations.push(...A.coalescing(bodyReaderImplementation));
+        return this;
+    }
+    plug(plugin) {
+        const pluginResult = typeof plugin === "function"
+            ? plugin(this)
+            : plugin;
+        if (pluginResult.bodyReaderImplementations) {
+            this.addBodyReaderImplementation(pluginResult.bodyReaderImplementations);
+        }
+        if (pluginResult.hooksHubLifeCycle) {
+            this.addHubHooks(pluginResult.hooksHubLifeCycle);
+        }
+        if (pluginResult.hooksRouteLifeCycle) {
+            this.addRouteHooks(pluginResult.hooksRouteLifeCycle);
+        }
+        if (pluginResult.routeFunctionBuilders) {
+            this.addRouteFunctionBuilder(pluginResult.routeFunctionBuilders);
+        }
+        if (pluginResult.routes) {
+            this.register(pluginResult.routes);
+        }
+        if (pluginResult.stepFunctionBuilders) {
+            this.addStepFunctionBuilder(pluginResult.stepFunctionBuilders);
+        }
+        this.plugins.push(pluginResult);
+        return this;
+    }
+    setNotfoundHandler(responseContract, theFunction) {
+        this.notfoundHandler = createHandlerStep({
+            responseContract,
+            theFunction: (floor, params) => theFunction(params),
+            metadata: [],
+        });
+        return this;
+    }
+    setDefaultExtractContract(responseContract) {
+        this.defaultExtractContract = responseContract;
+        return this;
+    }
+    aggregatesHooksHubLifeCycle(hookName) {
+        return A.flatMap(this.hooksHubLifeCycle, (hooks) => hooks[hookName] ?? []);
+    }
+    setDefaultBodyController(bodyController) {
+        this.defaultBodyController = bodyController;
+        return this;
+    }
+    aggregatesHooksRouteLifeCycle(hookName) {
+        return A.flatMap(this.hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? []);
+    }
+    /**
+     * @internal
+     */
+    static "new"(config) {
+        return new Hub(config);
+    }
+}
 function createHub(config) {
-    return {
-        ...hubKind.addTo({}),
-        config,
-        plugins: [],
-        hooksHubLifeCycle: [],
-        hooksRouteLifeCycle: [],
-        routeFunctionBuilders: [],
-        routes: [],
-        stepFunctionBuilders: [],
-        notfoundHandler: defaultNotfoundHandler,
-        defaultExtractContract,
-        classRequest: Request,
-        addHubHooks(hook) {
-            return {
-                ...this,
-                hooksHubLifeCycle: A.concat(this.hooksHubLifeCycle, A.coalescing(hook)),
-            };
-        },
-        addRouteFunctionBuilder(functionBuilder) {
-            return {
-                ...this,
-                routeFunctionBuilders: A.concat(this.routeFunctionBuilders, A.coalescing(functionBuilder)),
-            };
-        },
-        addRouteHooks(hook) {
-            return {
-                ...this,
-                hooksRouteLifeCycle: A.concat(this.hooksRouteLifeCycle, A.coalescing(hook)),
-            };
-        },
-        addStepFunctionBuilder(hook) {
-            return {
-                ...this,
-                stepFunctionBuilders: A.concat(this.stepFunctionBuilders, A.coalescing(hook)),
-            };
-        },
-        plug(plugin) {
-            return {
-                ...this,
-                plugins: A.push(this.plugins, typeof plugin === "function"
-                    ? plugin(this)
-                    : plugin),
-            };
-        },
-        register(route) {
-            return {
-                ...this,
-                routes: A.concat(this.routes, pipe(route, P.when(routeKind.has, A.coalescing), P.when(isType("iterable"), A.from), P.otherwise(O.values), A.filter((route) => !A.includes(this.routes, route)))),
-            };
-        },
-        setDefaultExtractContract(defaultExtractContract) {
-            return {
-                ...this,
-                defaultExtractContract,
-            };
-        },
-        setNotfoundHandler(responseContract, theFunction) {
-            return {
-                ...this,
-                notfoundHandler: createHandlerStep({
-                    responseContract,
-                    theFunction: (floor, params) => theFunction(params),
-                    metadata: [],
-                }),
-            };
-        },
-        aggregates() {
-            return A.reduce(this.plugins, A.reduceFrom({
-                hooksRouteLifeCycle: this.hooksRouteLifeCycle,
-                routeFunctionBuilders: this.routeFunctionBuilders,
-                stepFunctionBuilders: this.stepFunctionBuilders,
-                routes: this.routes,
-                hooksHubLifeCycle: this.hooksHubLifeCycle,
-            }), ({ lastValue, element: plugin, next, }) => next({
-                hooksRouteLifeCycle: plugin.hooksRouteLifeCycle
-                    ? A.concat(lastValue.hooksRouteLifeCycle, plugin.hooksRouteLifeCycle)
-                    : lastValue.hooksRouteLifeCycle,
-                routeFunctionBuilders: plugin.routeFunctionBuilders
-                    ? A.concat(lastValue.routeFunctionBuilders, plugin.routeFunctionBuilders)
-                    : lastValue.routeFunctionBuilders,
-                stepFunctionBuilders: plugin.stepFunctionBuilders
-                    ? A.concat(lastValue.stepFunctionBuilders, plugin.stepFunctionBuilders)
-                    : lastValue.stepFunctionBuilders,
-                routes: plugin.routes
-                    ? A.concat(lastValue.routes, plugin.routes)
-                    : lastValue.routes,
-                hooksHubLifeCycle: plugin.hooksHubLifeCycle
-                    ? A.concat(lastValue.hooksHubLifeCycle, plugin.hooksHubLifeCycle)
-                    : lastValue.hooksHubLifeCycle,
-            }));
-        },
-        aggregatesRoutes() {
-            return A.reduce(this.plugins, A.reduceFrom(this.routes), ({ lastValue, element: { routes }, next, }) => routes
-                ? next(A.concat(lastValue, routes))
-                : next(lastValue));
-        },
-        aggregatesRouteFunctionBuilders() {
-            return A.reduce(this.plugins, A.reduceFrom(this.routeFunctionBuilders), ({ lastValue, element: { routeFunctionBuilders }, next, }) => routeFunctionBuilders
-                ? next(A.concat(lastValue, routeFunctionBuilders))
-                : next(lastValue));
-        },
-        aggregatesStepFunctionBuilders() {
-            return A.reduce(this.plugins, A.reduceFrom(this.stepFunctionBuilders), ({ lastValue, element: { stepFunctionBuilders }, next, }) => stepFunctionBuilders
-                ? next(A.concat(lastValue, stepFunctionBuilders))
-                : next(lastValue));
-        },
-        aggregatesHooksHubLifeCycle(hookName) {
-            const hooks = A.flatMap(this.hooksHubLifeCycle, (hooks) => hooks[hookName] ?? []);
-            return A.reduce(this.plugins, A.reduceFrom(hooks), ({ lastValue, element: { hooksHubLifeCycle }, next, }) => {
-                if (!hooksHubLifeCycle) {
-                    return next(lastValue);
-                }
-                return next(A.concat(lastValue, A.flatMap(hooksHubLifeCycle, (hooks) => hooks[hookName] ?? [])));
-            });
-        },
-        aggregatesHooksRouteLifeCycle(hookName) {
-            const hooks = A.flatMap(this.hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? []);
-            return A.reduce(this.plugins, A.reduceFrom(hooks), ({ lastValue, element: { hooksRouteLifeCycle }, next, }) => {
-                if (!hooksRouteLifeCycle) {
-                    return next(lastValue);
-                }
-                return next(A.concat(lastValue, A.flatMap(hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? [])));
-            });
-        },
-    };
+    return Hub.new(config);
 }
 
-export { createHub, defaultExtractContract, defaultNotfoundHandler, hubKind };
+export { Hub, createHub, defaultBodyController, defaultExtractContract, defaultNotfoundHandler, hubKind };

package/dist/core/implementHttpServer.cjs

@@ -6,10 +6,10 @@ var utils = require('@duplojs/utils');
 var hooks = require('./hub/hooks.cjs');
 
 async function implementHttpServer(params, initHttpServer) {
-    const newHub1 = await hooks.launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeServerBuildRoutes"), params.hub, params.httpServerParams);
-    const router = await index.buildRouter(newHub1);
-    const newHub2 = await hooks.launchHookServer(newHub1.aggregatesHooksHubLifeCycle("beforeStartServer"), newHub1, params.httpServerParams);
-    const serverErrorHooks = newHub1.aggregatesHooksHubLifeCycle("serverError");
+    await hooks.launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeServerBuildRoutes"), params.hub, params.httpServerParams);
+    const router = await index.buildRouter(params.hub);
+    await hooks.launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeStartServer"), params.hub, params.httpServerParams);
+    const serverErrorHooks = params.hub.aggregatesHooksHubLifeCycle("serverError");
     function catchCriticalError(error) {
         console.error("Critical Error :", error);
     }
@@ -29,7 +29,7 @@ async function implementHttpServer(params, initHttpServer) {
         execRouteSystem: execRouteSystem,
         httpServerParams: params.httpServerParams,
     });
-    await hooks.launchHookServer(newHub2.aggregatesHooksHubLifeCycle("afterStartServer"), newHub2, params.httpServerParams);
+    await hooks.launchHookServer(params.hub.aggregatesHooksHubLifeCycle("afterStartServer"), params.hub, params.httpServerParams);
     return result;
 }
 

package/dist/core/implementHttpServer.d.ts

@@ -1,6 +1,7 @@
-import { type Hub, type HttpServerParams } from "./hub";
+import { type Hub } from "./hub";
 import { type RouterInitializationData } from "./router";
 import { type MaybePromise } from "@duplojs/utils";
+import { type HttpServerParams } from "./types";
 export interface ImplementHttpServerParams {
     readonly hub: Hub;
     readonly httpServerParams: HttpServerParams;

package/dist/core/implementHttpServer.mjs

@@ -4,10 +4,10 @@ import { forward } from '@duplojs/utils';
 import { launchHookServer, launchHookServerError, serverErrorNextHookFunction, serverErrorExitHookFunction } from './hub/hooks.mjs';
 
 async function implementHttpServer(params, initHttpServer) {
-    const newHub1 = await launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeServerBuildRoutes"), params.hub, params.httpServerParams);
-    const router = await buildRouter(newHub1);
-    const newHub2 = await launchHookServer(newHub1.aggregatesHooksHubLifeCycle("beforeStartServer"), newHub1, params.httpServerParams);
-    const serverErrorHooks = newHub1.aggregatesHooksHubLifeCycle("serverError");
+    await launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeServerBuildRoutes"), params.hub, params.httpServerParams);
+    const router = await buildRouter(params.hub);
+    await launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeStartServer"), params.hub, params.httpServerParams);
+    const serverErrorHooks = params.hub.aggregatesHooksHubLifeCycle("serverError");
     function catchCriticalError(error) {
         console.error("Critical Error :", error);
     }
@@ -27,7 +27,7 @@ async function implementHttpServer(params, initHttpServer) {
         execRouteSystem: execRouteSystem,
         httpServerParams: params.httpServerParams,
     });
-    await launchHookServer(newHub2.aggregatesHooksHubLifeCycle("afterStartServer"), newHub2, params.httpServerParams);
+    await launchHookServer(params.hub.aggregatesHooksHubLifeCycle("afterStartServer"), params.hub, params.httpServerParams);
     return result;
 }
 

package/dist/core/index.cjs

@@ -9,16 +9,18 @@ var checker$2 = require('./checker.cjs');
 require('./floor.cjs');
 var kind$1 = require('./kind.cjs');
 var index$1 = require('./process/index.cjs');
-var request = require('./request.cjs');
+var index$2 = require('./request/index.cjs');
 var presetChecker$1 = require('./presetChecker.cjs');
-var index$2 = require('./hub/index.cjs');
+var index$3 = require('./hub/index.cjs');
 require('./functionsBuilders/index.cjs');
-var index$3 = require('./router/index.cjs');
+var index$4 = require('./router/index.cjs');
 var stringIdentifier = require('./stringIdentifier.cjs');
 require('./metadata/index.cjs');
 var implementHttpServer = require('./implementHttpServer.cjs');
 var narrowingInput = require('./narrowingInput.cjs');
 require('./clean/index.cjs');
+var index$5 = require('./defaultHooks/index.cjs');
+require('./errors/index.cjs');
 var checker = require('./builders/checker.cjs');
 var builder = require('./builders/route/builder.cjs');
 var store = require('./builders/route/store.cjs');
@@ -37,9 +39,13 @@ var cut = require('./steps/cut.cjs');
 var handler = require('./steps/handler.cjs');
 var process = require('./steps/process.cjs');
 var presetChecker = require('./steps/presetChecker.cjs');
+var base$1 = require('./request/bodyController/base.cjs');
+var formData = require('./request/bodyController/formData.cjs');
+var text = require('./request/bodyController/text.cjs');
 var hooks$1 = require('./hub/hooks.cjs');
 var defaultNotfoundHandler = require('./hub/defaultNotfoundHandler.cjs');
 var defaultExtractContract = require('./hub/defaultExtractContract.cjs');
+var defaultBodyController = require('./hub/defaultBodyController.cjs');
 var build = require('./functionsBuilders/route/build.cjs');
 var create = require('./functionsBuilders/route/create.cjs');
 var _default = require('./functionsBuilders/route/default.cjs');
@@ -54,8 +60,13 @@ var build$1 = require('./functionsBuilders/steps/build.cjs');
 var pathToRegExp = require('./router/pathToRegExp.cjs');
 var buildError = require('./router/buildError.cjs');
 var decodeUrl = require('./router/decodeUrl.cjs');
-var base$1 = require('./metadata/base.cjs');
+var notFoundBodyReaderImplementationError = require('./router/notFoundBodyReaderImplementationError.cjs');
+var base$2 = require('./metadata/base.cjs');
 var ignoreByRouteStore = require('./metadata/ignoreByRouteStore.cjs');
+var wrongContentTypeError = require('./errors/wrongContentTypeError.cjs');
+var bodyParseWrongChunkReceived = require('./errors/bodyParseWrongChunkReceived.cjs');
+var bodySizeExceedsLimitError = require('./errors/bodySizeExceedsLimitError.cjs');
+var parseJsonError = require('./errors/parseJsonError.cjs');
 
 
 
@@ -67,15 +78,17 @@ exports.createChecker = checker$2.createChecker;
 exports.createCoreLibKind = kind$1.createCoreLibKind;
 exports.createProcess = index$1.createProcess;
 exports.processKind = index$1.processKind;
-exports.Request = request.Request;
+exports.Request = index$2.Request;
 exports.createPresetChecker = presetChecker$1.createPresetChecker;
 exports.presetCheckerKind = presetChecker$1.presetCheckerKind;
-exports.createHub = index$2.createHub;
-exports.hubKind = index$2.hubKind;
-exports.buildRouter = index$3.buildRouter;
+exports.Hub = index$3.Hub;
+exports.createHub = index$3.createHub;
+exports.hubKind = index$3.hubKind;
+exports.buildRouter = index$4.buildRouter;
 exports.createCoreLibStringIdentifier = stringIdentifier.createCoreLibStringIdentifier;
 exports.implementHttpServer = implementHttpServer.implementHttpServer;
 exports.createNarrowingInput = narrowingInput.createNarrowingInput;
+exports.initDefaultHook = index$5.initDefaultHook;
 exports.checkerBuilder = checker.checkerBuilder;
 exports.useCheckerBuilder = checker.useCheckerBuilder;
 exports.routeBuilderHandler = builder.routeBuilderHandler;
@@ -110,6 +123,11 @@ exports.createProcessStep = process.createProcessStep;
 exports.processStepKind = process.processStepKind;
 exports.createPresetCheckerStep = presetChecker.createPresetCheckerStep;
 exports.presetCheckerStepKind = presetChecker.presetCheckerStepKind;
+exports.createBodyController = base$1.createBodyController;
+exports.FormDataBodyController = formData.FormDataBodyController;
+exports.controlBodyAsFormData = formData.controlBodyAsFormData;
+exports.TextBodyController = text.TextBodyController;
+exports.controlBodyAsText = text.controlBodyAsText;
 exports.createHookHubLifeCycle = hooks$1.createHookHubLifeCycle;
 exports.hookServerExitKind = hooks$1.hookServerExitKind;
 exports.hookServerNextKind = hooks$1.hookServerNextKind;
@@ -120,6 +138,7 @@ exports.serverErrorExitHookFunction = hooks$1.serverErrorExitHookFunction;
 exports.serverErrorNextHookFunction = hooks$1.serverErrorNextHookFunction;
 exports.defaultNotfoundHandler = defaultNotfoundHandler.defaultNotfoundHandler;
 exports.defaultExtractContract = defaultExtractContract.defaultExtractContract;
+exports.defaultBodyController = defaultBodyController.defaultBodyController;
 exports.buildRouteFunction = build.buildRouteFunction;
 exports.createRouteFunctionBuilder = create.createRouteFunctionBuilder;
 exports.defaultRouteFunctionBuilder = _default.defaultRouteFunctionBuilder;
@@ -142,6 +161,11 @@ exports.RouterBuildError = buildError.RouterBuildError;
 exports.decodeUrl = decodeUrl.decodeUrl;
 exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
 exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
-exports.createMetadata = base$1.createMetadata;
-exports.metadataKind = base$1.metadataKind;
+exports.NotFoundBodyReaderImplementationError = notFoundBodyReaderImplementationError.NotFoundBodyReaderImplementationError;
+exports.createMetadata = base$2.createMetadata;
+exports.metadataKind = base$2.metadataKind;
 exports.IgnoreByRouteStoreMetadata = ignoreByRouteStore.IgnoreByRouteStoreMetadata;
+exports.WrongContentTypeError = wrongContentTypeError.WrongContentTypeError;
+exports.BodyParseWrongChunkReceived = bodyParseWrongChunkReceived.BodyParseWrongChunkReceived;
+exports.BodySizeExceedsLimitError = bodySizeExceedsLimitError.BodySizeExceedsLimitError;
+exports.ParseJsonError = parseJsonError.ParseJsonError;

package/dist/core/index.d.ts

@@ -17,3 +17,5 @@ export * from "./metadata";
 export * from "./implementHttpServer";
 export * from "./narrowingInput";
 export * from "./clean";
+export * from "./defaultHooks";
+export * from "./errors";

package/dist/core/index.mjs

@@ -7,9 +7,9 @@ export { checkerKind, checkerOutputKind, createChecker } from './checker.mjs';
 import './floor.mjs';
 export { createCoreLibKind } from './kind.mjs';
 export { createProcess, processKind } from './process/index.mjs';
-export { Request } from './request.mjs';
+export { Request } from './request/index.mjs';
 export { createPresetChecker, presetCheckerKind } from './presetChecker.mjs';
-export { createHub, hubKind } from './hub/index.mjs';
+export { Hub, createHub, hubKind } from './hub/index.mjs';
 import './functionsBuilders/index.mjs';
 export { buildRouter } from './router/index.mjs';
 export { createCoreLibStringIdentifier } from './stringIdentifier.mjs';
@@ -17,6 +17,8 @@ import './metadata/index.mjs';
 export { implementHttpServer } from './implementHttpServer.mjs';
 export { createNarrowingInput } from './narrowingInput.mjs';
 import './clean/index.mjs';
+export { initDefaultHook } from './defaultHooks/index.mjs';
+import './errors/index.mjs';
 export { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
 export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
 export { routeStore } from './builders/route/store.mjs';
@@ -35,9 +37,13 @@ export { createCutStep, cutStepKind, cutStepOutputKind } from './steps/cut.mjs';
 export { createHandlerStep, handlerStepKind } from './steps/handler.mjs';
 export { createProcessStep, processStepKind } from './steps/process.mjs';
 export { createPresetCheckerStep, presetCheckerStepKind } from './steps/presetChecker.mjs';
+export { createBodyController } from './request/bodyController/base.mjs';
+export { FormDataBodyController, controlBodyAsFormData } from './request/bodyController/formData.mjs';
+export { TextBodyController, controlBodyAsText } from './request/bodyController/text.mjs';
 export { createHookHubLifeCycle, hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hub/hooks.mjs';
 export { defaultNotfoundHandler } from './hub/defaultNotfoundHandler.mjs';
 export { defaultExtractContract } from './hub/defaultExtractContract.mjs';
+export { defaultBodyController } from './hub/defaultBodyController.mjs';
 export { buildRouteFunction } from './functionsBuilders/route/build.mjs';
 export { createRouteFunctionBuilder } from './functionsBuilders/route/create.mjs';
 export { defaultRouteFunctionBuilder } from './functionsBuilders/route/default.mjs';
@@ -52,5 +58,10 @@ export { buildStepFunction } from './functionsBuilders/steps/build.mjs';
 export { pathToRegExp } from './router/pathToRegExp.mjs';
 export { RouterBuildError } from './router/buildError.mjs';
 export { decodeUrl, regexQueryAnalyser, regexUrlAnalyser } from './router/decodeUrl.mjs';
+export { NotFoundBodyReaderImplementationError } from './router/notFoundBodyReaderImplementationError.mjs';
 export { createMetadata, metadataKind } from './metadata/base.mjs';
 export { IgnoreByRouteStoreMetadata } from './metadata/ignoreByRouteStore.mjs';
+export { WrongContentTypeError } from './errors/wrongContentTypeError.mjs';
+export { BodyParseWrongChunkReceived } from './errors/bodyParseWrongChunkReceived.mjs';
+export { BodySizeExceedsLimitError } from './errors/bodySizeExceedsLimitError.mjs';
+export { ParseJsonError } from './errors/parseJsonError.mjs';

package/dist/core/request/bodyController/base.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var kind = require('../../kind.cjs');
+var utils = require('@duplojs/utils');
+
+const bodyReaderKind = kind.createCoreLibKind("body-reader");
+const bodyReaderImplementationKind = kind.createCoreLibKind("body-reader-implementation");
+const bodyControllerKind = kind.createCoreLibKind("body-controller");
+const bodyControllerHandlerKind = kind.createCoreLibKind("body-controller-handler");
+function createBodyController(name) {
+    return bodyControllerHandlerKind.setTo({
+        name,
+        create(params) {
+            return bodyControllerKind.setTo({
+                name,
+                params,
+                tryToCreateReader(readerImplementation) {
+                    if (bodyReaderImplementationKind.getValue(readerImplementation) !== name) {
+                        return utils.E.fail();
+                    }
+                    return utils.E.success(bodyReaderKind.setTo({
+                        read: (request) => readerImplementation.read(request, params),
+                    }, name));
+                },
+            }, name);
+        },
+        createReaderImplementation(read) {
+            return bodyReaderImplementationKind.setTo({ read }, name);
+        },
+        is(input) {
+            return bodyControllerKind.has(input) && bodyControllerKind.getValue(input) === name;
+        },
+    });
+}
+
+exports.createBodyController = createBodyController;

package/dist/core/request/bodyController/base.d.ts

@@ -0,0 +1,28 @@
+import { type Request } from "../../request";
+import { E, type Kind } from "@duplojs/utils";
+export interface BodyControllerParams {
+    bodyMaxSize?: number;
+}
+declare const bodyReaderKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-reader", string>>;
+export interface BodyReader<GenericName extends string = string> extends Kind<typeof bodyReaderKind.definition, GenericName> {
+    read(request: Request): Promise<E.Success | E.Error<Error>>;
+}
+declare const bodyReaderImplementationKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-reader-implementation", string>>;
+export interface BodyReaderImplementation<GenericName extends string = string, GenericParams extends BodyControllerParams = BodyControllerParams> extends Kind<typeof bodyReaderImplementationKind.definition, GenericName> {
+    read(request: Request, params: GenericParams): Promise<E.Success | E.Error<Error>>;
+}
+declare const bodyControllerKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-controller", string>>;
+export interface BodyController<GenericName extends string = string, GenericParams extends BodyControllerParams = BodyControllerParams> extends Kind<typeof bodyControllerKind.definition, GenericName> {
+    readonly name: GenericName;
+    readonly params: GenericParams;
+    tryToCreateReader(readerImplementation: BodyReaderImplementation): E.Success<BodyReader<GenericName>> | E.Fail;
+}
+declare const bodyControllerHandlerKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-controller-handler", unknown>>;
+export interface BodyControllerHandler<GenericName extends string = string, GenericParams extends BodyControllerParams = BodyControllerParams> extends Kind<typeof bodyControllerHandlerKind.definition> {
+    readonly name: GenericName;
+    create(params: GenericParams): BodyController<GenericName, GenericParams>;
+    createReaderImplementation(read: BodyReaderImplementation<GenericName, GenericParams>["read"]): BodyReaderImplementation<GenericName, GenericParams>;
+    is(input: unknown): input is BodyController<GenericName, GenericParams>;
+}
+export declare function createBodyController<GenericName extends string, GenericParams extends BodyControllerParams>(name: GenericName): BodyControllerHandler<GenericName, GenericParams>;
+export {};

package/dist/core/request/bodyController/base.mjs

@@ -0,0 +1,34 @@
+import { createCoreLibKind } from '../../kind.mjs';
+import { E } from '@duplojs/utils';
+
+const bodyReaderKind = createCoreLibKind("body-reader");
+const bodyReaderImplementationKind = createCoreLibKind("body-reader-implementation");
+const bodyControllerKind = createCoreLibKind("body-controller");
+const bodyControllerHandlerKind = createCoreLibKind("body-controller-handler");
+function createBodyController(name) {
+    return bodyControllerHandlerKind.setTo({
+        name,
+        create(params) {
+            return bodyControllerKind.setTo({
+                name,
+                params,
+                tryToCreateReader(readerImplementation) {
+                    if (bodyReaderImplementationKind.getValue(readerImplementation) !== name) {
+                        return E.fail();
+                    }
+                    return E.success(bodyReaderKind.setTo({
+                        read: (request) => readerImplementation.read(request, params),
+                    }, name));
+                },
+            }, name);
+        },
+        createReaderImplementation(read) {
+            return bodyReaderImplementationKind.setTo({ read }, name);
+        },
+        is(input) {
+            return bodyControllerKind.has(input) && bodyControllerKind.getValue(input) === name;
+        },
+    });
+}
+
+export { createBodyController };

package/dist/core/request/bodyController/formData.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var base = require('./base.cjs');
+
+const FormDataBodyController = base.createBodyController("formData");
+function controlBodyAsFormData(params) {
+    return FormDataBodyController.create({
+        maxFileQuantity: params.maxFileQuantity,
+        bodyMaxSize: params.bodyMaxSize && utils.stringToBytes(params.bodyMaxSize),
+        fileMaxSize: params.fileMaxSize && utils.stringToBytes(params.fileMaxSize),
+        mimeType: params.mimeType !== undefined
+            ? utils.toRegExp(params.mimeType)
+            : undefined,
+        maxBufferSize: params.maxBufferSize !== undefined
+            ? utils.stringToBytes(params.maxBufferSize)
+            : utils.stringToBytes("128kb"),
+        maxIndexArray: params.maxIndexArray !== undefined
+            ? params.maxIndexArray
+            : 500,
+        maxKeyLength: params.maxKeyLength !== undefined
+            ? params.maxKeyLength
+            : 500,
+    });
+}
+
+exports.FormDataBodyController = FormDataBodyController;
+exports.controlBodyAsFormData = controlBodyAsFormData;

package/dist/core/request/bodyController/formData.d.ts

@@ -0,0 +1,22 @@
+import { type BytesInString } from "@duplojs/utils";
+import { type BodyControllerParams } from "./base";
+export interface FormDataBodyReaderParams extends BodyControllerParams {
+    maxFileQuantity: number;
+    mimeType?: RegExp;
+    fileMaxSize?: number;
+    maxBufferSize: number;
+    maxIndexArray: number;
+    maxKeyLength: number;
+}
+export declare const FormDataBodyController: import("./base").BodyControllerHandler<"formData", FormDataBodyReaderParams>;
+export type FormDataBodyController = typeof FormDataBodyController;
+export interface ControlBodyAsFormDataParams {
+    maxFileQuantity: number;
+    mimeType?: string | string[] | RegExp;
+    bodyMaxSize?: number | BytesInString;
+    fileMaxSize?: number | BytesInString;
+    maxBufferSize?: number | BytesInString;
+    maxIndexArray?: number;
+    maxKeyLength?: number;
+}
+export declare function controlBodyAsFormData(params: ControlBodyAsFormDataParams): import("./base").BodyController<"formData", FormDataBodyReaderParams>;

package/dist/core/request/bodyController/formData.mjs

@@ -0,0 +1,25 @@
+import { stringToBytes, toRegExp } from '@duplojs/utils';
+import { createBodyController } from './base.mjs';
+
+const FormDataBodyController = createBodyController("formData");
+function controlBodyAsFormData(params) {
+    return FormDataBodyController.create({
+        maxFileQuantity: params.maxFileQuantity,
+        bodyMaxSize: params.bodyMaxSize && stringToBytes(params.bodyMaxSize),
+        fileMaxSize: params.fileMaxSize && stringToBytes(params.fileMaxSize),
+        mimeType: params.mimeType !== undefined
+            ? toRegExp(params.mimeType)
+            : undefined,
+        maxBufferSize: params.maxBufferSize !== undefined
+            ? stringToBytes(params.maxBufferSize)
+            : stringToBytes("128kb"),
+        maxIndexArray: params.maxIndexArray !== undefined
+            ? params.maxIndexArray
+            : 500,
+        maxKeyLength: params.maxKeyLength !== undefined
+            ? params.maxKeyLength
+            : 500,
+    });
+}
+
+export { FormDataBodyController, controlBodyAsFormData };

package/dist/core/request/bodyController/index.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var base = require('./base.cjs');
+var formData = require('./formData.cjs');
+var text = require('./text.cjs');
+
+
+
+exports.createBodyController = base.createBodyController;
+exports.FormDataBodyController = formData.FormDataBodyController;
+exports.controlBodyAsFormData = formData.controlBodyAsFormData;
+exports.TextBodyController = text.TextBodyController;
+exports.controlBodyAsText = text.controlBodyAsText;