@duplojs/http 0.6.2 → 0.7.1

package/dist/core/functionsBuilders/steps/defaults/extractStep.mjs

@@ -1,5 +1,5 @@
 import '../../../steps/index.mjs';
-import { unwrap, E, A, O, DP, pipe, P, isType, justReturn, innerPipe } from '@duplojs/utils';
+import { unwrap, E, forward, A, O, pipe, P, DP, isType, justReturn, innerPipe } from '@duplojs/utils';
 import '../../../response/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import { extractStepKind } from '../../../steps/extract.mjs';
@@ -8,32 +8,56 @@ import { PredictedResponse } from '../../../response/predicted.mjs';
 const defaultExtractStepFunctionBuilder = createStepFunctionBuilder(extractStepKind.has, (step, { success, environment, defaultExtractContract }) => {
     const { shape, responseContract: stepResponseContract, } = step.definition;
     const responseContract = stepResponseContract ?? defaultExtractContract;
-    function getResponse(result, key, subKey) {
-        const response = new PredictedResponse(responseContract.code, responseContract.information, environment === "DEV"
-            ? unwrap(result)
-            : undefined);
-        return subKey === undefined
-            ? response.setHeader("extract-key", `request.${key}`)
-            : response.setHeader("extract-key", `request.${key}.${subKey}`);
-    }
-    function treatResult(result, floor, key, subKey) {
-        if (E.isLeft(result)) {
-            return getResponse(result, key, subKey);
+    function createExtractor(parser, key, subKey) {
+        const createResponse = environment === "DEV"
+            ? (result) => new PredictedResponse(responseContract.code, responseContract.information, result)
+            : () => new PredictedResponse(responseContract.code, responseContract.information, undefined);
+        const setHeader = subKey === undefined || key === "body"
+            ? (response) => response.setHeader("extract-key", `request.${key}`)
+            : (response) => response.setHeader("extract-key", `request.${key}.${subKey}`);
+        const getResponse = (result) => setHeader(createResponse(result));
+        const treatResult = (result, floor) => E.isLeft(result)
+            ? getResponse(unwrap(result))
+            : {
+                ...floor,
+                [subKey ?? key]: unwrap(result),
+            };
+        const getValue = typeof subKey === "string"
+            ? (value) => value?.[subKey]
+            : forward;
+        if (key === "body") {
+            const parseFunction = parser.isAsynchronous()
+                ? parser.asyncParse
+                : parser.parse;
+            return async (request, floor) => {
+                const bodyResult = await request.getBody();
+                if (E.isLeft(bodyResult)) {
+                    return treatResult(bodyResult, floor);
+                }
+                const result = await parseFunction(getValue(unwrap(bodyResult)));
+                return treatResult(result, floor);
+            };
+        }
+        if (parser.isAsynchronous()) {
+            const parseFunction = parser.asyncParse;
+            return async (request, floor) => {
+                const result = await parseFunction(getValue(request[key]));
+                return treatResult(result, floor);
+            };
         }
-        return {
-            ...floor,
-            [subKey ?? key]: unwrap(result),
+        const parseFunction = parser.parse;
+        return (request, floor) => {
+            const result = parseFunction(getValue(request[key]));
+            return treatResult(result, floor);
         };
     }
-    const extractors = A.reduce(O.entries(shape), A.reduceFrom([]), ({ lastValue, element: [key, value], next }) => next(DP.dataParserKind.has(value)
-        ? A.push(lastValue, (request, floor) => treatResult(value.parse(request[key]), floor, key))
-        : pipe(value, P.when(isType("undefined"), justReturn(lastValue)), P.otherwise(innerPipe(O.entries, A.map(([subKey, subValue]) => ((request, floor) => treatResult(subValue.parse(request[key]?.[subKey]), floor, key, subKey))), (subExtractor) => A.concat(lastValue, subExtractor))))));
+    const extractors = A.reduce(O.entries(shape), A.reduceFrom([]), ({ lastValue, element: [key, value], next, }) => pipe(value, P.when(DP.dataParserKind.has, (value) => A.push(lastValue, createExtractor(value, key, undefined))), P.otherwise((value) => pipe(value, P.when(isType("undefined"), justReturn(lastValue)), P.otherwise(innerPipe(O.entries, A.map(([subKey, subValue]) => createExtractor(subValue, key, subKey)), (subExtractor) => A.concat(lastValue, subExtractor))))), next));
     return success({
-        buildedFunction: (request, floor) => {
+        buildedFunction: async (request, floor) => {
             let newFloor = floor;
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let index = 0; index < extractors.length; index++) {
-                const result = extractors[index](request, newFloor);
+                const result = await extractors[index](request, newFloor);
                 if (result instanceof PredictedResponse) {
                     return result;
                 }

package/dist/core/functionsBuilders/steps/defaults/handlerStep.cjs

@@ -18,17 +18,23 @@ const defaultHandlerStepFunctionBuilder = create.createStepFunctionBuilder(handl
         if (!currentContract) {
             throw new contract.ResponseContract.Error(information);
         }
-        const result = currentContract.body.parse(body);
-        if (utils.E.isLeft(result)) {
-            throw new contract.ResponseContract.Error(information, utils.unwrap(result));
-        }
         return new predicted.PredictedResponse(currentContract.code, currentContract.information, body);
     };
     return success({
-        buildedFunction: (request, floor) => handlerFunction(floor, {
-            request,
-            response,
-        }),
+        buildedFunction: async (request, floor) => {
+            const predictedResponse = await handlerFunction(floor, {
+                request,
+                response,
+            });
+            const currentContract = preparedContractResponse[predictedResponse.information];
+            const result = currentContract.body.isAsynchronous()
+                ? await currentContract.body.asyncParse(predictedResponse.body)
+                : currentContract.body.parse(predictedResponse.body);
+            if (utils.E.isLeft(result)) {
+                throw new contract.ResponseContract.Error(predictedResponse.information, utils.unwrap(result));
+            }
+            return predictedResponse;
+        },
         hooksRouteLifeCycle: [],
     });
 });

package/dist/core/functionsBuilders/steps/defaults/handlerStep.mjs

@@ -16,17 +16,23 @@ const defaultHandlerStepFunctionBuilder = createStepFunctionBuilder(handlerStepK
         if (!currentContract) {
             throw new ResponseContract.Error(information);
         }
-        const result = currentContract.body.parse(body);
-        if (E.isLeft(result)) {
-            throw new ResponseContract.Error(information, unwrap(result));
-        }
         return new PredictedResponse(currentContract.code, currentContract.information, body);
     };
     return success({
-        buildedFunction: (request, floor) => handlerFunction(floor, {
-            request,
-            response,
-        }),
+        buildedFunction: async (request, floor) => {
+            const predictedResponse = await handlerFunction(floor, {
+                request,
+                response,
+            });
+            const currentContract = preparedContractResponse[predictedResponse.information];
+            const result = currentContract.body.isAsynchronous()
+                ? await currentContract.body.asyncParse(predictedResponse.body)
+                : currentContract.body.parse(predictedResponse.body);
+            if (E.isLeft(result)) {
+                throw new ResponseContract.Error(predictedResponse.information, unwrap(result));
+            }
+            return predictedResponse;
+        },
         hooksRouteLifeCycle: [],
     });
 });

package/dist/core/hub/defaultBodyController.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('../request/index.cjs');
+var text = require('../request/bodyController/text.cjs');
+
+const defaultBodyController = text.controlBodyAsText();
+
+exports.defaultBodyController = defaultBodyController;

package/dist/core/hub/defaultBodyController.d.ts

@@ -0,0 +1 @@
+export declare const defaultBodyController: import("../request").BodyController<"text", import("../request").TextBodyReaderParams>;

package/dist/core/hub/defaultBodyController.mjs

@@ -0,0 +1,6 @@
+import '../request/index.mjs';
+import { controlBodyAsText } from '../request/bodyController/text.mjs';
+
+const defaultBodyController = controlBodyAsText();
+
+export { defaultBodyController };

package/dist/core/hub/hooks.cjs

@@ -9,7 +9,9 @@ async function launchHookBeforeBuildRoute(hooks, route) {
     return utils.G.asyncReduce(hooks, utils.G.reduceFrom(route), async ({ element: hook, lastValue, next, }) => next(await hook(lastValue)));
 }
 async function launchHookServer(hooks, hub, httpServerParams) {
-    return utils.G.asyncReduce(hooks, utils.G.reduceFrom(hub), async ({ element: hook, lastValue, next, }) => next((await hook(lastValue, httpServerParams)) ?? lastValue));
+    for (const hook of hooks) {
+        await hook(hub, httpServerParams);
+    }
 }
 const hookExit = hookServerExitKind.setTo({});
 const hookNext = hookServerNextKind.setTo({});

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

@@ -2,6 +2,7 @@ import { type Route } from "../route";
 import { type EscapeVoid, type Kind, type MaybePromise } from "@duplojs/utils";
 import { type Hub } from ".";
 import { type RouterInitializationData } from "../router";
+import { type HttpServerParams } from "../types";
 export declare const hookServerExitKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-hook-exit", unknown>>;
 export interface ServerHookExit extends Kind<typeof hookServerExitKind.definition> {
 }
@@ -10,12 +11,10 @@ export interface ServerHookNext extends Kind<typeof hookServerNextKind.definitio
 }
 export type HookBeforeBuildRoute = (route: Route) => MaybePromise<Route>;
 export declare function launchHookBeforeBuildRoute(hooks: Iterable<HookBeforeBuildRoute>, route: Route): Promise<Route<import("../route").RouteDefinition>>;
-export interface HttpServerParams {
-}
 export type HookBeforeServerBuildRoutes = (hub: Hub, httpServerParams: HttpServerParams) => MaybePromise<Hub | EscapeVoid>;
 export type HookBeforeStartServer = (hub: Hub, httpServerParams: HttpServerParams) => MaybePromise<Hub | EscapeVoid>;
 export type HookAfterStartServer = (hub: Hub, httpServerParams: HttpServerParams) => MaybePromise<Hub | EscapeVoid>;
-export declare function launchHookServer(hooks: Iterable<HookBeforeStartServer | HookAfterStartServer | HookBeforeServerBuildRoutes>, hub: Hub, httpServerParams: HttpServerParams): Promise<Hub<import(".").HubConfig>>;
+export declare function launchHookServer(hooks: Iterable<HookBeforeStartServer | HookAfterStartServer | HookBeforeServerBuildRoutes>, hub: Hub, httpServerParams: HttpServerParams): Promise<void>;
 export interface HttpServerErrorParams {
     readonly error: unknown;
     next(): ServerHookNext;

package/dist/core/hub/hooks.mjs

@@ -7,7 +7,9 @@ async function launchHookBeforeBuildRoute(hooks, route) {
     return G.asyncReduce(hooks, G.reduceFrom(route), async ({ element: hook, lastValue, next, }) => next(await hook(lastValue)));
 }
 async function launchHookServer(hooks, hub, httpServerParams) {
-    return G.asyncReduce(hooks, G.reduceFrom(hub), async ({ element: hook, lastValue, next, }) => next((await hook(lastValue, httpServerParams)) ?? lastValue));
+    for (const hook of hooks) {
+        await hook(hub, httpServerParams);
+    }
 }
 const hookExit = hookServerExitKind.setTo({});
 const hookNext = hookServerNextKind.setTo({});

package/dist/core/hub/index.cjs

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

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

@@ -1,8 +1,8 @@
 import { type Route, type HookRouteLifeCycle } from "../route";
-import { type Kind, type MaybeArray, type MaybePromise, type DP } from "@duplojs/utils";
+import { type MaybeArray, type MaybePromise, type DP } from "@duplojs/utils";
 import { type HookHubLifeCycle } from "./hooks";
 import { type HandlerStepFunctionParams, type HandlerStep } from "../steps";
-import { Request } from "../request";
+import { type BodyController, type BodyReaderImplementation, Request } from "../request";
 import { type ClientErrorResponseCode, type ResponseContract } from "../response";
 import { type Environment } from "../types";
 import { type createStepFunctionBuilder } from "../functionsBuilders/steps";
@@ -10,6 +10,7 @@ import { type createRouteFunctionBuilder } from "../functionsBuilders/route";
 export * from "./hooks";
 export * from "./defaultNotfoundHandler";
 export * from "./defaultExtractContract";
+export * from "./defaultBodyController";
 export declare const hubKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hub", unknown>>;
 export interface HubConfig {
     readonly environment: Environment;
@@ -21,38 +22,36 @@ export interface HubPlugin {
     readonly routes?: readonly Route[];
     readonly routeFunctionBuilders?: readonly ReturnType<typeof createRouteFunctionBuilder>[];
     readonly stepFunctionBuilders?: readonly ReturnType<typeof createStepFunctionBuilder>[];
+    readonly bodyReaderImplementations?: readonly BodyReaderImplementation[];
 }
-export interface HubAggregates {
-    readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
-    readonly hooksHubLifeCycle: readonly HookHubLifeCycle[];
-    readonly routes: readonly Route[];
-    readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
-    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
-}
-export interface Hub<GenericConfig extends HubConfig = HubConfig> extends Kind<typeof hubKind.definition> {
-    readonly config: GenericConfig;
-    readonly plugins: readonly HubPlugin[];
-    readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
-    readonly hooksHubLifeCycle: readonly HookHubLifeCycle[];
-    readonly routes: readonly Route[];
-    readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
-    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
-    readonly classRequest: typeof Request;
-    readonly notfoundHandler: HandlerStep;
-    readonly defaultExtractContract: ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>;
-    register(routes: Route | Iterable<Route> | Record<string, Route>): Hub<GenericConfig>;
-    addRouteFunctionBuilder(functionBuilder: MaybeArray<ReturnType<typeof createRouteFunctionBuilder>>): Hub<GenericConfig>;
-    addStepFunctionBuilder(functionBuilder: MaybeArray<ReturnType<typeof createStepFunctionBuilder>>): Hub<GenericConfig>;
-    addRouteHooks(hook: MaybeArray<HookRouteLifeCycle>): Hub<GenericConfig>;
-    addHubHooks(hook: MaybeArray<HookHubLifeCycle>): Hub<GenericConfig>;
-    plug(plugin: HubPlugin | ((self: this) => HubPlugin)): Hub<GenericConfig>;
-    setNotfoundHandler<GenericResponseContract extends ResponseContract.Contract, GenericResponse extends ResponseContract.Convert<GenericResponseContract>>(responseContract: GenericResponseContract, theFunction: (param: HandlerStepFunctionParams<Request, GenericResponse>) => MaybePromise<GenericResponse>): Hub<GenericConfig>;
-    setDefaultExtractContract(responseContract: this["defaultExtractContract"]): Hub<GenericConfig>;
-    aggregates(): HubAggregates;
-    aggregatesRoutes(): readonly Route[];
-    aggregatesRouteFunctionBuilders(): readonly ReturnType<typeof createRouteFunctionBuilder>[];
-    aggregatesStepFunctionBuilders(): readonly ReturnType<typeof createStepFunctionBuilder>[];
-    aggregatesHooksHubLifeCycle<GenericHookName extends keyof HookHubLifeCycle>(hookName: GenericHookName): readonly Exclude<HookHubLifeCycle[GenericHookName], undefined>[];
-    aggregatesHooksRouteLifeCycle<GenericHookName extends keyof HookRouteLifeCycle>(hookName: GenericHookName): readonly Exclude<HookRouteLifeCycle[GenericHookName], undefined>[];
+declare const Hub_base: new (params?: {
+    "@DuplojsHttpCore/hub"?: unknown;
+} | undefined) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hub", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hub", unknown>, unknown>;
+export declare class Hub<GenericConfig extends HubConfig = HubConfig> extends Hub_base {
+    config: GenericConfig;
+    plugins: HubPlugin[];
+    hooksRouteLifeCycle: HookRouteLifeCycle[];
+    hooksHubLifeCycle: HookHubLifeCycle[];
+    routes: Set<Route<import("../route").RouteDefinition>>;
+    routeFunctionBuilders: ReturnType<typeof createRouteFunctionBuilder>[];
+    stepFunctionBuilders: ReturnType<typeof createStepFunctionBuilder>[];
+    bodyReaderImplementations: BodyReaderImplementation[];
+    classRequest: typeof Request;
+    notfoundHandler: HandlerStep;
+    defaultExtractContract: ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>;
+    defaultBodyController: BodyController;
+    private constructor();
+    register(routes: Route | Iterable<Route> | Record<string, Route>): this;
+    addRouteFunctionBuilder(functionBuilder: MaybeArray<ReturnType<typeof createRouteFunctionBuilder>>): this;
+    addStepFunctionBuilder(functionBuilder: MaybeArray<ReturnType<typeof createStepFunctionBuilder>>): this;
+    addRouteHooks(hook: MaybeArray<HookRouteLifeCycle>): this;
+    addHubHooks(hook: MaybeArray<HookHubLifeCycle>): this;
+    addBodyReaderImplementation(bodyReaderImplementation: MaybeArray<BodyReaderImplementation>): this;
+    plug(plugin: HubPlugin | ((self: this) => HubPlugin)): this;
+    setNotfoundHandler<GenericResponseContract extends ResponseContract.Contract, GenericResponse extends ResponseContract.Convert<GenericResponseContract>>(responseContract: GenericResponseContract, theFunction: (param: HandlerStepFunctionParams<Request, GenericResponse>) => MaybePromise<GenericResponse>): this;
+    setDefaultExtractContract(responseContract: this["defaultExtractContract"]): this;
+    aggregatesHooksHubLifeCycle<GenericHookName extends keyof HookHubLifeCycle>(hookName: GenericHookName): (NonNullable<HookHubLifeCycle[GenericHookName]> extends infer T ? T extends NonNullable<HookHubLifeCycle[GenericHookName]> ? T extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr : InnerArr : T : never : never)[];
+    setDefaultBodyController(bodyController: BodyController): this;
+    aggregatesHooksRouteLifeCycle<GenericHookName extends keyof HookRouteLifeCycle>(hookName: GenericHookName): (NonNullable<HookRouteLifeCycle<Request>[GenericHookName]> extends infer T ? T extends NonNullable<HookRouteLifeCycle<Request>[GenericHookName]> ? T extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr : InnerArr : T : never : never)[];
 }
 export declare function createHub<const GenericConfig extends HubConfig>(config: GenericConfig): Hub<GenericConfig>;