@duplojs/http 0.6.1 → 0.7.0

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

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