@duplojs/http 0.6.2 → 0.7.1

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> {

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