@duplojs/http 0.8.4 → 0.9.5

package/dist/core/functionsBuilders/route/{default.cjs → default/index.cjs}

@@ -1,15 +1,14 @@
 'use strict';
 
-var index = require('../../route/index.cjs');
+var index = require('../../../route/index.cjs');
 var utils = require('@duplojs/utils');
-require('../../response/index.cjs');
+require('../../../response/index.cjs');
 var hook = require('./hook.cjs');
-var create = require('./create.cjs');
-require('../steps/index.cjs');
-var processStep = require('../steps/defaults/processStep.cjs');
-var base = require('../../response/base.cjs');
-var hook$1 = require('../../response/hook.cjs');
-var hooks = require('../../route/hooks.cjs');
+var create = require('../create.cjs');
+require('../../steps/index.cjs');
+var processStep = require('../../steps/defaults/processStep.cjs');
+var base = require('../../../response/base.cjs');
+var hook$1 = require('../../../response/hook.cjs');
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {
@@ -33,31 +32,18 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
     const hookAfterSendResponse = utils.pipe(allHooks, utils.A.map(({ afterSendResponse }) => afterSendResponse), utils.A.filter(utils.isType("function")), utils.forward);
     const hookBeforeRouteExecution = utils.pipe(allHooks, utils.A.map(({ beforeRouteExecution }) => beforeRouteExecution), utils.A.filter(utils.isType("function")), utils.forward);
     const hookBeforeSendResponse = utils.pipe(allHooks, utils.A.map(({ beforeSendResponse }) => beforeSendResponse), utils.A.filter(utils.isType("function")), utils.forward);
-    const hookOnConstructRequest = utils.pipe(allHooks, utils.A.map(({ onConstructRequest }) => onConstructRequest), utils.A.filter(utils.isType("function")), utils.forward);
     const hookError = utils.pipe(allHooks, utils.A.map(({ error }) => error), utils.A.filter(utils.isType("function")), utils.forward);
     const hookSendResponse = utils.pipe(allHooks, utils.A.map(({ sendResponse }) => sendResponse), utils.A.filter(utils.isType("function")), utils.forward);
-    const hooks$1 = {
-        afterSendResponse: hook.buildHookAfter(hookAfterSendResponse),
+    const hooks = {
         beforeRouteExecution: hook.buildHookBefore(hookBeforeRouteExecution),
+        afterSendResponse: hook.buildHookAfter(hookAfterSendResponse),
         beforeSendResponse: hook.buildHookAfter(hookBeforeSendResponse),
-        onConstructRequest: hookOnConstructRequest.length
-            ? async (params) => {
-                let newRequest = params.request;
-                for (let index = 0; index < hookOnConstructRequest.length; index++) {
-                    newRequest = await hookOnConstructRequest[index]({
-                        ...params,
-                        request: newRequest,
-                    });
-                }
-                return newRequest;
-            }
-            : (params) => params.request,
         error: hook.buildHookErrorBefore(hookError),
         sendResponse: hook.buildHookAfter(hookSendResponse),
     };
     async function routeExecution(request) {
         try {
-            const beforeRouteExecutionResult = await hooks$1.beforeRouteExecution({
+            const beforeRouteExecutionResult = await hooks.beforeRouteExecution({
                 request,
                 exit: hook.exitHookFunction,
                 next: hook.nextHookFunction,
@@ -84,7 +70,7 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
             return new base.Response("500", "missing-response", undefined);
         }
         catch (error) {
-            const errorResult = await hooks$1.error({
+            const errorResult = await hooks.error({
                 request,
                 error,
                 exit: hook.exitHookFunction,
@@ -98,21 +84,23 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
         }
     }
     return success(async (request) => {
-        const currentRequest = await hooks$1.onConstructRequest({
-            request,
-            addRequestProperties: hooks.hookRouteLifeCycleAddRequestProperties(request),
-        });
-        const currentResponse = await routeExecution(currentRequest);
+        const currentResponse = await routeExecution(request);
         const afterHookParams = {
-            request: currentRequest,
+            request,
             currentResponse,
             exit: hook.exitHookFunction,
             next: hook.nextHookFunction,
         };
-        await hooks$1.beforeSendResponse(afterHookParams);
-        await hooks$1.sendResponse(afterHookParams);
-        await hooks$1.afterSendResponse(afterHookParams);
+        await hooks.beforeSendResponse(afterHookParams);
+        await hooks.sendResponse(afterHookParams);
+        await hooks.afterSendResponse(afterHookParams);
     });
 });
 
+exports.buildHookAfter = hook.buildHookAfter;
+exports.buildHookBefore = hook.buildHookBefore;
+exports.buildHookErrorBefore = hook.buildHookErrorBefore;
+exports.createHookResponse = hook.createHookResponse;
+exports.exitHookFunction = hook.exitHookFunction;
+exports.nextHookFunction = hook.nextHookFunction;
 exports.defaultRouteFunctionBuilder = defaultRouteFunctionBuilder;

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

@@ -0,0 +1,2 @@
+export * from "./hook";
+export declare const defaultRouteFunctionBuilder: (route: import("../../../route").Route, params: import("..").RouteFunctionBuilderParams) => import("@duplojs/utils").MaybePromise<import("..").BuildRouteNotSupportEither | import("..").BuildRouteSuccessEither | import("../..").BuildStepNotSupportEither>;

package/dist/core/functionsBuilders/route/{default.mjs → default/index.mjs}

@@ -1,13 +1,12 @@
-import { routeKind } from '../../route/index.mjs';
+import { routeKind } from '../../../route/index.mjs';
 import { E, A, pipe, isType, forward } from '@duplojs/utils';
-import '../../response/index.mjs';
+import '../../../response/index.mjs';
 import { buildHookAfter, buildHookErrorBefore, buildHookBefore, createHookResponse, nextHookFunction, exitHookFunction } from './hook.mjs';
-import { createRouteFunctionBuilder } from './create.mjs';
-import '../steps/index.mjs';
-import { buildStepsFunction } from '../steps/defaults/processStep.mjs';
-import { Response } from '../../response/base.mjs';
-import { HookResponse } from '../../response/hook.mjs';
-import { hookRouteLifeCycleAddRequestProperties } from '../../route/hooks.mjs';
+import { createRouteFunctionBuilder } from '../create.mjs';
+import '../../steps/index.mjs';
+import { buildStepsFunction } from '../../steps/defaults/processStep.mjs';
+import { Response } from '../../../response/base.mjs';
+import { HookResponse } from '../../../response/hook.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {
@@ -31,25 +30,12 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
     const hookAfterSendResponse = pipe(allHooks, A.map(({ afterSendResponse }) => afterSendResponse), A.filter(isType("function")), forward);
     const hookBeforeRouteExecution = pipe(allHooks, A.map(({ beforeRouteExecution }) => beforeRouteExecution), A.filter(isType("function")), forward);
     const hookBeforeSendResponse = pipe(allHooks, A.map(({ beforeSendResponse }) => beforeSendResponse), A.filter(isType("function")), forward);
-    const hookOnConstructRequest = pipe(allHooks, A.map(({ onConstructRequest }) => onConstructRequest), A.filter(isType("function")), forward);
     const hookError = pipe(allHooks, A.map(({ error }) => error), A.filter(isType("function")), forward);
     const hookSendResponse = pipe(allHooks, A.map(({ sendResponse }) => sendResponse), A.filter(isType("function")), forward);
     const hooks = {
-        afterSendResponse: buildHookAfter(hookAfterSendResponse),
         beforeRouteExecution: buildHookBefore(hookBeforeRouteExecution),
+        afterSendResponse: buildHookAfter(hookAfterSendResponse),
         beforeSendResponse: buildHookAfter(hookBeforeSendResponse),
-        onConstructRequest: hookOnConstructRequest.length
-            ? async (params) => {
-                let newRequest = params.request;
-                for (let index = 0; index < hookOnConstructRequest.length; index++) {
-                    newRequest = await hookOnConstructRequest[index]({
-                        ...params,
-                        request: newRequest,
-                    });
-                }
-                return newRequest;
-            }
-            : (params) => params.request,
         error: buildHookErrorBefore(hookError),
         sendResponse: buildHookAfter(hookSendResponse),
     };
@@ -96,13 +82,9 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
         }
     }
     return success(async (request) => {
-        const currentRequest = await hooks.onConstructRequest({
-            request,
-            addRequestProperties: hookRouteLifeCycleAddRequestProperties(request),
-        });
-        const currentResponse = await routeExecution(currentRequest);
+        const currentResponse = await routeExecution(request);
         const afterHookParams = {
-            request: currentRequest,
+            request,
             currentResponse,
             exit: exitHookFunction,
             next: nextHookFunction,
@@ -113,4 +95,4 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
     });
 });
 
-export { defaultRouteFunctionBuilder };
+export { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, defaultRouteFunctionBuilder, exitHookFunction, nextHookFunction };

package/dist/core/functionsBuilders/route/index.cjs

@@ -2,17 +2,10 @@
 
 var build = require('./build.cjs');
 var create = require('./create.cjs');
-var _default = require('./default.cjs');
-var hook = require('./hook.cjs');
+var index = require('./default/index.cjs');
 
 
 
 exports.buildRouteFunction = build.buildRouteFunction;
 exports.createRouteFunctionBuilder = create.createRouteFunctionBuilder;
-exports.defaultRouteFunctionBuilder = _default.defaultRouteFunctionBuilder;
-exports.buildHookAfter = hook.buildHookAfter;
-exports.buildHookBefore = hook.buildHookBefore;
-exports.buildHookErrorBefore = hook.buildHookErrorBefore;
-exports.createHookResponse = hook.createHookResponse;
-exports.exitHookFunction = hook.exitHookFunction;
-exports.nextHookFunction = hook.nextHookFunction;
+exports.defaultRouteFunctionBuilder = index.defaultRouteFunctionBuilder;

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

@@ -1,4 +1,3 @@
 export * from "./build";
 export * from "./create";
 export * from "./default";
-export * from "./hook";

package/dist/core/functionsBuilders/route/index.mjs

@@ -1,4 +1,3 @@
 export { buildRouteFunction } from './build.mjs';
 export { createRouteFunctionBuilder } from './create.mjs';
-export { defaultRouteFunctionBuilder } from './default.mjs';
-export { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, exitHookFunction, nextHookFunction } from './hook.mjs';
+export { defaultRouteFunctionBuilder } from './default/index.mjs';

package/dist/core/functionsBuilders/router/build.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+async function buildRouterFunction({ routerFunctionBuilder, ...params }) {
+    return routerFunctionBuilder(params);
+}
+
+exports.buildRouterFunction = buildRouterFunction;

package/dist/core/functionsBuilders/router/build.d.ts

@@ -0,0 +1,14 @@
+import { type Environment } from "../../types";
+import { type createRouterFunctionBuilder } from "./create";
+import { type Request } from "../../request";
+import { type RouterElementWrapper } from "../../router/types/routerElementWrapper";
+import { type RouterElementSystem } from "../../router/types/routerElementSystem";
+export interface BuildRouterFunctionParams {
+    readonly routerFunctionBuilder: ReturnType<typeof createRouterFunctionBuilder>;
+    readonly environment: Environment;
+    readonly routerElementWrapper: RouterElementWrapper;
+    readonly classRequest: typeof Request;
+    readonly notfoundRouterElement: RouterElementSystem;
+    readonly malformedUrlRouterElement: RouterElementSystem;
+}
+export declare function buildRouterFunction({ routerFunctionBuilder, ...params }: BuildRouterFunctionParams): Promise<import("../..").BuildedRouter>;

package/dist/core/functionsBuilders/router/build.mjs

@@ -0,0 +1,5 @@
+async function buildRouterFunction({ routerFunctionBuilder, ...params }) {
+    return routerFunctionBuilder(params);
+}
+
+export { buildRouterFunction };

package/dist/core/functionsBuilders/router/create.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function createRouterFunctionBuilder(theFunction) {
+    return theFunction;
+}
+
+exports.createRouterFunctionBuilder = createRouterFunctionBuilder;

package/dist/core/functionsBuilders/router/create.d.ts

@@ -0,0 +1,15 @@
+import { type Request } from "../../request";
+import { type BuildedRouter } from "../../router";
+import { type RouterElementSystem } from "../../router/types/routerElementSystem";
+import { type RouterElementWrapper } from "../../router/types/routerElementWrapper";
+import { type Environment } from "../../types";
+import { type MaybePromise } from "@duplojs/utils";
+export interface RouterFunctionBuilderParams {
+    readonly environment: Environment;
+    readonly routerElementWrapper: RouterElementWrapper;
+    readonly classRequest: typeof Request;
+    readonly notfoundRouterElement: RouterElementSystem;
+    readonly malformedUrlRouterElement: RouterElementSystem;
+}
+export type RouterFunctionBuilder = (params: RouterFunctionBuilderParams) => MaybePromise<BuildedRouter>;
+export declare function createRouterFunctionBuilder(theFunction: RouterFunctionBuilder): RouterFunctionBuilder;

package/dist/core/functionsBuilders/router/create.mjs

@@ -0,0 +1,5 @@
+function createRouterFunctionBuilder(theFunction) {
+    return theFunction;
+}
+
+export { createRouterFunctionBuilder };

package/dist/core/functionsBuilders/router/default/index.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var decodeUrl = require('../../../decodeUrl.cjs');
+var create = require('../create.cjs');
+
+const defaultRouterFunctionBuilder = create.createRouterFunctionBuilder(({ routerElementWrapper, malformedUrlRouterElement, notfoundRouterElement, classRequest, }) => (initializationData) => {
+    const routerElements = routerElementWrapper[initializationData.method];
+    const decodedUrl = decodeUrl.decodeUrl(initializationData.url);
+    if (!decodedUrl) {
+        return malformedUrlRouterElement.buildedRoute(new classRequest({
+            ...initializationData,
+            params: {},
+            path: "",
+            query: {},
+            matchedPath: null,
+            bodyReader: malformedUrlRouterElement.bodyReader,
+        }));
+    }
+    if (!routerElements) {
+        return notfoundRouterElement.buildedRoute(new classRequest({
+            ...initializationData,
+            ...decodedUrl,
+            params: {},
+            matchedPath: null,
+            bodyReader: notfoundRouterElement.bodyReader,
+        }));
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let index = 0; index < routerElements.length; index++) {
+        const routerElement = routerElements[index];
+        const result = routerElement.pattern.exec(decodedUrl.path);
+        if (!result) {
+            continue;
+        }
+        return routerElement.buildedRoute(new classRequest({
+            ...initializationData,
+            ...decodedUrl,
+            params: result.groups ?? {},
+            matchedPath: routerElement.matchedPath,
+            bodyReader: routerElement.bodyReader,
+        }));
+    }
+    return notfoundRouterElement.buildedRoute(new classRequest({
+        ...initializationData,
+        ...decodedUrl,
+        params: {},
+        matchedPath: null,
+        bodyReader: notfoundRouterElement.bodyReader,
+    }));
+});
+
+exports.defaultRouterFunctionBuilder = defaultRouterFunctionBuilder;

package/dist/core/functionsBuilders/router/default/index.d.ts

@@ -0,0 +1 @@
+export declare const defaultRouterFunctionBuilder: import("..").RouterFunctionBuilder;

package/dist/core/functionsBuilders/router/default/index.mjs

@@ -0,0 +1,50 @@
+import { decodeUrl } from '../../../decodeUrl.mjs';
+import { createRouterFunctionBuilder } from '../create.mjs';
+
+const defaultRouterFunctionBuilder = createRouterFunctionBuilder(({ routerElementWrapper, malformedUrlRouterElement, notfoundRouterElement, classRequest, }) => (initializationData) => {
+    const routerElements = routerElementWrapper[initializationData.method];
+    const decodedUrl = decodeUrl(initializationData.url);
+    if (!decodedUrl) {
+        return malformedUrlRouterElement.buildedRoute(new classRequest({
+            ...initializationData,
+            params: {},
+            path: "",
+            query: {},
+            matchedPath: null,
+            bodyReader: malformedUrlRouterElement.bodyReader,
+        }));
+    }
+    if (!routerElements) {
+        return notfoundRouterElement.buildedRoute(new classRequest({
+            ...initializationData,
+            ...decodedUrl,
+            params: {},
+            matchedPath: null,
+            bodyReader: notfoundRouterElement.bodyReader,
+        }));
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let index = 0; index < routerElements.length; index++) {
+        const routerElement = routerElements[index];
+        const result = routerElement.pattern.exec(decodedUrl.path);
+        if (!result) {
+            continue;
+        }
+        return routerElement.buildedRoute(new classRequest({
+            ...initializationData,
+            ...decodedUrl,
+            params: result.groups ?? {},
+            matchedPath: routerElement.matchedPath,
+            bodyReader: routerElement.bodyReader,
+        }));
+    }
+    return notfoundRouterElement.buildedRoute(new classRequest({
+        ...initializationData,
+        ...decodedUrl,
+        params: {},
+        matchedPath: null,
+        bodyReader: notfoundRouterElement.bodyReader,
+    }));
+});
+
+export { defaultRouterFunctionBuilder };

package/dist/core/functionsBuilders/router/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var create = require('./create.cjs');
+var index = require('./default/index.cjs');
+var build = require('./build.cjs');
+
+
+
+exports.createRouterFunctionBuilder = create.createRouterFunctionBuilder;
+exports.defaultRouterFunctionBuilder = index.defaultRouterFunctionBuilder;
+exports.buildRouterFunction = build.buildRouterFunction;

package/dist/core/functionsBuilders/router/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./create";
+export * from "./default";
+export * from "./build";

package/dist/core/functionsBuilders/router/index.mjs

@@ -0,0 +1,3 @@
+export { createRouterFunctionBuilder } from './create.mjs';
+export { defaultRouterFunctionBuilder } from './default/index.mjs';
+export { buildRouterFunction } from './build.mjs';

package/dist/core/functionsBuilders/steps/create.d.ts

@@ -1,13 +1,10 @@
 import { E, type MaybePromise } from "@duplojs/utils";
-import { type Steps } from "../../steps/types";
-import { type Floor } from "../../floor";
+import { type BuildedStep, type Steps } from "../../steps/types";
 import { type HookRouteLifeCycle } from "../../route";
-import { type Request } from "../../request";
-import { type ResponseContract, type Response } from "../../response";
+import { type ResponseContract } from "../../response";
 import { type Environment } from "../../types";
-export type BuildedStepFunction = (request: Request, floor: Floor) => MaybePromise<Floor | Response>;
 export interface BuildStepResult {
-    readonly buildedFunction: BuildedStepFunction;
+    readonly buildedFunction: BuildedStep;
     readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
 }
 export type BuildStepSuccessEither = E.Right<"buildSuccess", BuildStepResult>;

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

@@ -5,6 +5,6 @@ export declare const defaultMalformedUrlHandler: import("../steps").HandlerStep<
         readonly coerce: boolean;
         readonly checkers: readonly [];
     }>>>;
-    theFunction: (__: import("..").Floor, { response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").ServerSentEventsPredictedResponse<"200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299", string, import("..").ServerSentEvents.DefinitionShape> | import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
+    theFunction: (__: import("..").Floor, { response }: import("../steps").HandlerStepFunctionParams<import("../response").ServerSentEventsPredictedResponse<"200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299", string, import("..").ServerSentEvents.DefinitionShape> | import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
     metadata: never[];
 }>;

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

@@ -6,6 +6,6 @@ export declare const defaultNotfoundHandler: import("../steps").HandlerStep<{
         readonly coerce: boolean;
         readonly checkers: readonly [];
     }>>>;
-    theFunction: (floor: import("..").Floor, { request, response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").ServerSentEventsPredictedResponse<"200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299", string, import("..").ServerSentEvents.DefinitionShape> | import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
+    theFunction: (floor: import("..").Floor, { request, response }: import("../steps").HandlerStepFunctionParams<import("../response").ServerSentEventsPredictedResponse<"200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299", string, import("..").ServerSentEvents.DefinitionShape> | import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
     metadata: never[];
 }>;

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

@@ -1,7 +1,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 RouterParams } 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> {
@@ -19,7 +19,7 @@ export interface HttpServerErrorParams {
     readonly error: unknown;
     next(): ServerHookNext;
     exit(): ServerHookExit;
-    routerInitializationData: RouterInitializationData;
+    routerInitializationData: RouterParams;
 }
 export type HookServerError = (httpServerErrorParams: HttpServerErrorParams) => MaybePromise<ServerHookExit | ServerHookNext>;
 export declare function serverErrorExitHookFunction(): Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-hook-exit", unknown>, unknown>;

package/dist/core/hub/index.cjs

@@ -20,6 +20,7 @@ class Hub extends utils.kindHeritage("hub", kind.createCoreLibKind("hub")) {
     hooksRouteLifeCycle = [];
     hooksHubLifeCycle = [];
     routes = new Set();
+    routerFunctionBuilder = undefined;
     routeFunctionBuilders = [];
     stepFunctionBuilders = [];
     bodyReaderImplementations = [defaultEmptyReaderImplementation.defaultEmptyReaderImplementation];
@@ -36,6 +37,10 @@ class Hub extends utils.kindHeritage("hub", kind.createCoreLibKind("hub")) {
         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;
     }
+    setRouterFunctionBuilder(functionBuilder) {
+        this.routerFunctionBuilder = functionBuilder;
+        return this;
+    }
     addRouteFunctionBuilder(functionBuilder) {
         this.routeFunctionBuilders.push(...utils.A.coalescing(functionBuilder));
         return this;

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

@@ -7,6 +7,7 @@ import { type ClientErrorResponseCode, type ResponseContract } from "../response
 import { type Environment } from "../types";
 import { type createStepFunctionBuilder } from "../functionsBuilders/steps";
 import { type createRouteFunctionBuilder } from "../functionsBuilders/route";
+import { type createRouterFunctionBuilder } from "../functionsBuilders/router";
 export * from "./hooks";
 export * from "./defaultNotfoundHandler";
 export * from "./defaultExtractContract";
@@ -35,6 +36,7 @@ export declare class Hub<GenericConfig extends HubConfig = HubConfig> extends Hu
     hooksRouteLifeCycle: HookRouteLifeCycle[];
     hooksHubLifeCycle: HookHubLifeCycle[];
     routes: Set<Route<import("../route").RouteDefinition>>;
+    routerFunctionBuilder: ReturnType<typeof createRouterFunctionBuilder> | undefined;
     routeFunctionBuilders: ReturnType<typeof createRouteFunctionBuilder>[];
     stepFunctionBuilders: ReturnType<typeof createStepFunctionBuilder>[];
     bodyReaderImplementations: BodyReaderImplementation[];
@@ -45,17 +47,18 @@ export declare class Hub<GenericConfig extends HubConfig = HubConfig> extends Hu
     malformedUrlHandler: HandlerStep;
     private constructor();
     register(routes: Route | Iterable<Route> | Record<string, Route>): this;
+    setRouterFunctionBuilder(functionBuilder: ReturnType<typeof createRouterFunctionBuilder>): 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;
+    setNotfoundHandler<GenericResponseContract extends ResponseContract.Contract, GenericResponse extends ResponseContract.Convert<GenericResponseContract>>(responseContract: GenericResponseContract, theFunction: (param: HandlerStepFunctionParams<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)[];
-    setMalformedUrlHandler<GenericResponseContract extends ResponseContract.Contract, GenericResponse extends ResponseContract.Convert<GenericResponseContract>>(responseContract: GenericResponseContract, theFunction: (param: HandlerStepFunctionParams<Request, GenericResponse>) => MaybePromise<GenericResponse>): this;
+    aggregatesHooksRouteLifeCycle<GenericHookName extends keyof HookRouteLifeCycle>(hookName: GenericHookName): (NonNullable<HookRouteLifeCycle[GenericHookName]> extends infer T ? T extends NonNullable<HookRouteLifeCycle[GenericHookName]> ? T extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr : InnerArr : T : never : never)[];
+    setMalformedUrlHandler<GenericResponseContract extends ResponseContract.Contract, GenericResponse extends ResponseContract.Convert<GenericResponseContract>>(responseContract: GenericResponseContract, theFunction: (param: HandlerStepFunctionParams<GenericResponse>) => MaybePromise<GenericResponse>): this;
 }
 export declare function createHub<const GenericConfig extends HubConfig>(config: GenericConfig): Hub<GenericConfig>;

package/dist/core/hub/index.mjs

@@ -18,6 +18,7 @@ class Hub extends kindHeritage("hub", createCoreLibKind("hub")) {
     hooksRouteLifeCycle = [];
     hooksHubLifeCycle = [];
     routes = new Set();
+    routerFunctionBuilder = undefined;
     routeFunctionBuilders = [];
     stepFunctionBuilders = [];
     bodyReaderImplementations = [defaultEmptyReaderImplementation];
@@ -34,6 +35,10 @@ class Hub extends kindHeritage("hub", createCoreLibKind("hub")) {
         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;
     }
+    setRouterFunctionBuilder(functionBuilder) {
+        this.routerFunctionBuilder = functionBuilder;
+        return this;
+    }
     addRouteFunctionBuilder(functionBuilder) {
         this.routeFunctionBuilders.push(...A.coalescing(functionBuilder));
         return this;

package/dist/core/implementHttpServer.cjs

@@ -12,7 +12,7 @@ async function implementHttpServer(params, initHttpServer) {
         index.initDefaultHook(params.hub, params.httpServerParams),
         ...params.getInterfaceHooks(params),
     ]);
-    const router = await index$1.buildRouter(params.hub);
+    const router = await index$1.createRouter(params.hub);
     await hooks.launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeStartServer"), params.hub, params.httpServerParams);
     const serverErrorHooks = params.hub.aggregatesHooksHubLifeCycle("serverError");
     function catchCriticalError(error) {

package/dist/core/implementHttpServer.d.ts

@@ -1,5 +1,5 @@
 import { type Hub } from "./hub";
-import { type RouterInitializationData } from "./router";
+import { type RouterParams } from "./router";
 import { type AnyTuple, type MaybePromise } from "@duplojs/utils";
 import { type HttpServerParams } from "./types";
 import { type HookRouteLifeCycle } from "./route";
@@ -12,7 +12,7 @@ export interface ImplementHttpServerParams {
     readonly httpServerParams: HttpServerParams;
     getInterfaceHooks(params: GetInterfaceHooksParams): AnyTuple<HookRouteLifeCycle>;
 }
-export type ExecRouteSystem = (routerInitializationData: RouterInitializationData, whenUncaughtError: (error: unknown, routerInitializationData: RouterInitializationData) => MaybePromise<void>) => Promise<void>;
+export type ExecRouteSystem = (routerInitializationData: RouterParams, whenUncaughtError: (error: unknown, routerInitializationData: RouterParams) => MaybePromise<void>) => Promise<void>;
 export interface InitHttpServerParams {
     readonly execRouteSystem: ExecRouteSystem;
     readonly httpServerParams: HttpServerParams;

package/dist/core/implementHttpServer.mjs

@@ -1,5 +1,5 @@
 import './hub/index.mjs';
-import { buildRouter } from './router/index.mjs';
+import { createRouter } from './router/index.mjs';
 import { forward } from '@duplojs/utils';
 import { initDefaultHook } from './defaultHooks/index.mjs';
 import { launchHookServer, launchHookServerError, serverErrorNextHookFunction, serverErrorExitHookFunction } from './hub/hooks.mjs';
@@ -10,7 +10,7 @@ async function implementHttpServer(params, initHttpServer) {
         initDefaultHook(params.hub, params.httpServerParams),
         ...params.getInterfaceHooks(params),
     ]);
-    const router = await buildRouter(params.hub);
+    const router = await createRouter(params.hub);
     await launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeStartServer"), params.hub, params.httpServerParams);
     const serverErrorHooks = params.hub.aggregatesHooksHubLifeCycle("serverError");
     function catchCriticalError(error) {