@duplojs/http 0.6.1 → 0.7.0

package/dist/core/index.cjs

@@ -9,15 +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');
@@ -36,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');
@@ -53,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');
 
 
 
@@ -66,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;
@@ -109,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;
@@ -119,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;
@@ -141,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

@@ -16,3 +16,6 @@ export * from "./stringIdentifier";
 export * from "./metadata";
 export * from "./implementHttpServer";
 export * from "./narrowingInput";
+export * from "./clean";
+export * from "./defaultHooks";
+export * from "./errors";

package/dist/core/index.mjs

@@ -7,15 +7,18 @@ 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';
 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';
@@ -34,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';
@@ -51,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;

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

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

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

@@ -0,0 +1,3 @@
+export { createBodyController } from './base.mjs';
+export { FormDataBodyController, controlBodyAsFormData } from './formData.mjs';
+export { TextBodyController, controlBodyAsText } from './text.mjs';

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

@@ -0,0 +1,14 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var base = require('./base.cjs');
+
+const TextBodyController = base.createBodyController("text");
+function controlBodyAsText(params) {
+    return TextBodyController.create({
+        bodyMaxSize: params?.bodyMaxSize && utils.stringToBytes(params.bodyMaxSize),
+    });
+}
+
+exports.TextBodyController = TextBodyController;
+exports.controlBodyAsText = controlBodyAsText;

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

@@ -0,0 +1,10 @@
+import { type BytesInString } from "@duplojs/utils";
+import { type BodyControllerParams } from "./base";
+export interface TextBodyReaderParams extends BodyControllerParams {
+}
+export declare const TextBodyController: import("./base").BodyControllerHandler<"text", TextBodyReaderParams>;
+export type TextBodyController = typeof TextBodyController;
+export interface ControlBodyAsTextParams {
+    bodyMaxSize?: number | BytesInString;
+}
+export declare function controlBodyAsText(params?: ControlBodyAsTextParams): import("./base").BodyController<"text", TextBodyReaderParams>;

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

@@ -0,0 +1,11 @@
+import { stringToBytes } from '@duplojs/utils';
+import { createBodyController } from './base.mjs';
+
+const TextBodyController = createBodyController("text");
+function controlBodyAsText(params) {
+    return TextBodyController.create({
+        bodyMaxSize: params?.bodyMaxSize && stringToBytes(params.bodyMaxSize),
+    });
+}
+
+export { TextBodyController, controlBodyAsText };

package/dist/core/{request.cjs → request/index.cjs}

@@ -1,7 +1,8 @@
 'use strict';
 
 var utils = require('@duplojs/utils');
-var kind = require('./kind.cjs');
+var kind = require('../kind.cjs');
+require('./bodyController/index.cjs');
 
 class Request extends utils.kindHeritage("request", kind.createCoreLibKind("request")) {
     method;
@@ -13,8 +14,10 @@ class Request extends utils.kindHeritage("request", kind.createCoreLibKind("requ
     params;
     query;
     matchedPath;
-    body = undefined;
-    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, ...rest }) {
+    bodyReader;
+    bodyResult = undefined;
+    filesAttache = undefined;
+    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, bodyReader, ...rest }) {
         super();
         this.method = method;
         this.headers = headers;
@@ -25,10 +28,25 @@ class Request extends utils.kindHeritage("request", kind.createCoreLibKind("requ
         this.params = params;
         this.query = query;
         this.matchedPath = matchedPath;
+        this.bodyReader = bodyReader;
         for (const key in rest) {
             this[key] = rest[key];
         }
     }
+    getBody() {
+        if (this.bodyResult !== undefined) {
+            return this.bodyResult;
+        }
+        const externalPromise = utils.createExternalPromise();
+        this.bodyResult = externalPromise.promise;
+        return this.bodyReader
+            .read(this)
+            .then((result) => {
+            externalPromise.resolve(result);
+            this.bodyResult = result;
+            return result;
+        });
+    }
 }
 
 exports.Request = Request;

package/dist/core/{request.d.ts → request/index.d.ts}

@@ -1,8 +1,12 @@
+import { type E, type MaybePromise } from "@duplojs/utils";
 import { type GetPropsWithValue } from "@duplojs/utils/object";
+import { type BodyReader } from "./bodyController";
+export * from "./bodyController";
 export interface RequestMethodsWrapper {
     GET: true;
     POST: true;
     PUT: true;
+    PATCH: true;
     DELETE: true;
     HEAD: true;
     OPTIONS: true;
@@ -20,6 +24,7 @@ export interface RequestInitializationData {
     readonly path: string;
     readonly query: Record<string, string | string[]>;
     readonly url: string;
+    readonly bodyReader: BodyReader;
 }
 declare const Request_base: new (params?: {
     "@DuplojsHttpCore/request"?: unknown;
@@ -34,7 +39,9 @@ export declare class Request extends Request_base implements RequestInitializati
     params: Record<string, string>;
     query: Record<string, string | string[]>;
     matchedPath: string | null;
-    body: unknown;
-    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, ...rest }: RequestInitializationData);
+    bodyReader: BodyReader;
+    private bodyResult?;
+    filesAttache: string[] | undefined;
+    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, bodyReader, ...rest }: RequestInitializationData);
+    getBody(): MaybePromise<E.Success | E.Error>;
 }
-export {};

package/dist/core/request/index.mjs

@@ -0,0 +1,50 @@
+import { kindHeritage, createExternalPromise } from '@duplojs/utils';
+import { createCoreLibKind } from '../kind.mjs';
+import './bodyController/index.mjs';
+
+class Request extends kindHeritage("request", createCoreLibKind("request")) {
+    method;
+    headers;
+    url;
+    host;
+    origin;
+    path;
+    params;
+    query;
+    matchedPath;
+    bodyReader;
+    bodyResult = undefined;
+    filesAttache = undefined;
+    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, bodyReader, ...rest }) {
+        super();
+        this.method = method;
+        this.headers = headers;
+        this.url = url;
+        this.host = host;
+        this.origin = origin;
+        this.path = path;
+        this.params = params;
+        this.query = query;
+        this.matchedPath = matchedPath;
+        this.bodyReader = bodyReader;
+        for (const key in rest) {
+            this[key] = rest[key];
+        }
+    }
+    getBody() {
+        if (this.bodyResult !== undefined) {
+            return this.bodyResult;
+        }
+        const externalPromise = createExternalPromise();
+        this.bodyResult = externalPromise.promise;
+        return this.bodyReader
+            .read(this)
+            .then((result) => {
+            externalPromise.resolve(result);
+            this.bodyResult = result;
+            return result;
+        });
+    }
+}
+
+export { Request };

package/dist/core/response/contract.d.ts

@@ -283,7 +283,7 @@ export declare namespace ResponseContract {
     }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"511", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
     const Error_base: new (params: {
         "@DuplojsHttpCore/contract-error"?: unknown;
-    }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown> & globalThis.Error;
+    }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => globalThis.Error & Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown>;
     export class Error extends Error_base {
         information: string;
         dataParserError?: DP.DataParserError | undefined;

package/dist/core/route/hooks.d.ts

@@ -20,7 +20,6 @@ export interface RouteHookParams<GenericRequest extends Request = Request> {
     response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown>(code: GenericCode, information: GenericInformation, body?: GenericBody): HookResponse<GenericCode, GenericInformation, GenericBody | undefined>;
 }
 export type HookBeforeRouteExecution<GenericRequest extends Request = Request> = (params: RouteHookParams<GenericRequest>) => MaybePromise<HookResponse | RouteHookExit | RouteHookNext>;
-export type HookParseBody<GenericRequest extends Request = Request> = (params: RouteHookParams<GenericRequest>) => MaybePromise<HookResponse | RouteHookExit | RouteHookNext>;
 export interface RouteHookErrorParams<GenericRequest extends Request = Request> {
     readonly request: GenericRequest;
     readonly error: unknown;
@@ -41,7 +40,6 @@ export type HookAfterSendResponse<GenericRequest extends Request = Request> = (p
 export interface HookRouteLifeCycle<GenericRequest extends Request = Request> {
     onConstructRequest?: HookOnConstructRequest<GenericRequest>;
     beforeRouteExecution?: HookBeforeRouteExecution<GenericRequest>;
-    parseBody?: HookParseBody<GenericRequest>;
     error?: HookError;
     beforeSendResponse?: HookBeforeSendResponse<GenericRequest>;
     sendResponse?: HookSendResponse<GenericRequest>;

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

@@ -1,5 +1,5 @@
 import { type O, type Kind } from "@duplojs/utils";
-import { type RequestMethods } from "../request";
+import { type BodyController, type RequestMethods } from "../request";
 import { type ExtractStep, type CheckerStep, type CutStep, type HandlerStep, type ProcessStep, type stepKind, type PresetCheckerStep } from "../steps";
 import { type HookRouteLifeCycle } from "./hooks";
 import { type Metadata } from "../metadata";
@@ -19,6 +19,7 @@ export interface RouteDefinition {
     readonly steps: readonly RouteSteps[];
     readonly hooks: readonly HookRouteLifeCycle[];
     readonly metadata: readonly Metadata[];
+    readonly bodyController: BodyController | null;
 }
 export declare const routeKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route", unknown>>;
 export interface Route<GenericDefinition extends RouteDefinition = RouteDefinition> extends Kind<typeof routeKind.definition> {