@duplojs/http 0.5.0 → 0.6.1

package/dist/client/httpClient.cjs

@@ -140,6 +140,11 @@ function createHttpClient(clientParams) {
             path,
             ...params,
         })),
+        patch: ((path, params) => self.request({
+            method: "PATCH",
+            path,
+            ...params,
+        })),
         delete: ((path, params) => self.request({
             method: "DELETE",
             path,

package/dist/client/httpClient.d.ts

@@ -45,6 +45,7 @@ export interface HttpClient<GenericServerRoute extends ServerRoute = ServerRoute
     get: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "GET">;
     post: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "POST">;
     put: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "PUT">;
+    patch: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "PATCH">;
     delete: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "DELETE">;
 }
 export interface CreateHttpClientParams {

package/dist/client/httpClient.mjs

@@ -118,6 +118,11 @@ function createHttpClient(clientParams) {
             path,
             ...params,
         })),
+        patch: ((path, params) => self.request({
+            method: "PATCH",
+            path,
+            ...params,
+        })),
         delete: ((path, params) => self.request({
             method: "DELETE",
             path,

package/dist/client/queryToString.cjs

@@ -9,7 +9,7 @@ function queryToString(query) {
         if (!value) {
             return pv;
         }
-        if (Array.isArray(value)) {
+        if (value instanceof Array) {
             value.forEach((subValue) => {
                 pv.push(`${key}=${subValue}`);
             });

package/dist/client/queryToString.mjs

@@ -7,7 +7,7 @@ function queryToString(query) {
         if (!value) {
             return pv;
         }
-        if (Array.isArray(value)) {
+        if (value instanceof Array) {
             value.forEach((subValue) => {
                 pv.push(`${key}=${subValue}`);
             });

package/dist/client/unexpectedResponseError.d.ts

@@ -6,7 +6,7 @@ export interface RequestErrorContent {
 }
 declare const UnexpectedInformationResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-information-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-information-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-information-response-error", unknown>, unknown> & Error;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-information-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-information-response-error", unknown>, unknown> & Error;
 export declare class UnexpectedInformationResponseError extends UnexpectedInformationResponseError_base {
     information: string | string[];
     response: RequestErrorContent | ClientResponse;
@@ -14,7 +14,7 @@ export declare class UnexpectedInformationResponseError extends UnexpectedInform
 }
 declare const UnexpectedCodeResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-code-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-code-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-code-response-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-code-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-code-response-error", unknown>, unknown>;
 export declare class UnexpectedCodeResponseError extends UnexpectedCodeResponseError_base {
     code: string | string[];
     response: RequestErrorContent | ClientResponse;
@@ -22,7 +22,7 @@ export declare class UnexpectedCodeResponseError extends UnexpectedCodeResponseE
 }
 declare const UnexpectedResponseTypeError_base: new (params: {
     "@DuplojsHttpClient/unexpected-response-type-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-type-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-type-error", unknown>, unknown>;
 export declare class UnexpectedResponseTypeError extends UnexpectedResponseTypeError_base {
     expectType: "informational" | "successful" | "redirection" | "clientError" | "serverError";
     response: RequestErrorContent | ClientResponse;
@@ -30,7 +30,7 @@ export declare class UnexpectedResponseTypeError extends UnexpectedResponseTypeE
 }
 declare const UnexpectedResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-error", unknown>, unknown>;
 export declare class UnexpectedResponseError extends UnexpectedResponseError_base {
     response: RequestErrorContent | ClientResponse;
     constructor(response: RequestErrorContent | ClientResponse);

package/dist/core/builders/preflight/route.d.ts

@@ -15,12 +15,12 @@ declare module "./builder" {
             readonly preflightSteps: GenericDefinition["preflightSteps"];
             readonly steps: readonly [];
             readonly hooks: readonly [
-                ...GenericDefinition["hooks"],
-                ...GenericHooks
+                ...GenericHooks,
+                ...GenericDefinition["hooks"]
             ];
             readonly metadata: readonly [
-                ...GenericDefinition["metadata"],
-                ...GenericMetadata
+                ...GenericMetadata,
+                ...GenericDefinition["metadata"]
             ];
         }, GenericFloor, (GenericRequest & NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>)>;
     }

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

@@ -7,4 +7,4 @@ export interface BuildRouteFunctionParams extends BuildStepFunctionParams {
     readonly globalHooksRouteLifeCycle: readonly HookRouteLifeCycle[];
     readonly defaultExtractContract: ResponseContract.Contract;
 }
-export declare function buildRouteFunction(route: Route, params: BuildRouteFunctionParams): Promise<BuildRouteNotSupportEither | import("./create").BuildRouteSuccessEither | import("..").BuildStepNotSupportEither>;
+export declare function buildRouteFunction(route: Route, params: BuildRouteFunctionParams): Promise<import("..").BuildStepNotSupportEither | import("./create").BuildRouteSuccessEither | BuildRouteNotSupportEither>;

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

@@ -1,5 +1,6 @@
 'use strict';
 
+require('../../response/index.cjs');
 require('../../route/index.cjs');
 var hooks = require('../../route/hooks.cjs');
 var hook = require('../../response/hook.cjs');

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

@@ -1,7 +1,8 @@
-import { type HookAfterSendResponse, type HookBeforeRouteExecution, type HookBeforeSendResponse, type HookError, type HookParseBody, HookResponse, type HookRouteLifeCycle, type HookSendResponse, type RouteHookErrorParams, type RouteHookParams, type RouteHookParamsAfter } from "../../route";
+import { HookResponse } from "../../response";
+import { type HookAfterSendResponse, type HookBeforeRouteExecution, type HookBeforeSendResponse, type HookError, type HookParseBody, type HookRouteLifeCycle, type HookSendResponse, type RouteHookErrorParams, type RouteHookParams, type RouteHookParamsAfter } from "../../route";
 export declare function exitHookFunction(): import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-exit", unknown>, unknown>;
 export declare function nextHookFunction(): import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown>;
-export declare function buildHookBefore(hooks: (HookBeforeRouteExecution | HookParseBody)[]): typeof exitHookFunction | ((params: RouteHookParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../route").ResponseCode, string, unknown>>);
-export declare function buildHookErrorBefore(hooks: HookError[]): typeof exitHookFunction | ((params: RouteHookErrorParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../route").ResponseCode, string, unknown>>);
+export declare function buildHookBefore(hooks: (HookBeforeRouteExecution | HookParseBody)[]): typeof exitHookFunction | ((params: RouteHookParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../response").ResponseCode, string, unknown>>);
+export declare function buildHookErrorBefore(hooks: HookError[]): typeof exitHookFunction | ((params: RouteHookErrorParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../response").ResponseCode, string, unknown>>);
 export declare function buildHookAfter(hooks: (HookBeforeSendResponse | HookSendResponse | HookAfterSendResponse)[]): typeof exitHookFunction | ((params: RouteHookParamsAfter) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown>>);
 export declare function createHookResponse(from: keyof HookRouteLifeCycle): RouteHookParams["response"];

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

@@ -1,3 +1,4 @@
+import '../../response/index.mjs';
 import '../../route/index.mjs';
 import { hookRouteExitKind, hookRouteNextKind } from '../../route/hooks.mjs';
 import { HookResponse } from '../../response/hook.mjs';

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

@@ -7,4 +7,4 @@ export interface BuildStepFunctionParams {
     readonly environment: Environment;
     readonly defaultExtractContract: ResponseContract.Contract;
 }
-export declare function buildStepFunction(step: Steps, params: BuildStepFunctionParams): Promise<BuildStepNotSupportEither | import("./create").BuildStepSuccessEither>;
+export declare function buildStepFunction(step: Steps, params: BuildStepFunctionParams): Promise<import("./create").BuildStepSuccessEither | BuildStepNotSupportEither>;

package/dist/core/hub/hooks.cjs

@@ -28,7 +28,11 @@ async function launchHookServerError(hooks, params) {
         }
     }
 }
+function createHookHubLifeCycle(hookHubLifeCycle) {
+    return hookHubLifeCycle;
+}
 
+exports.createHookHubLifeCycle = createHookHubLifeCycle;
 exports.hookServerExitKind = hookServerExitKind;
 exports.hookServerNextKind = hookServerNextKind;
 exports.launchHookBeforeBuildRoute = launchHookBeforeBuildRoute;

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

@@ -1,6 +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";
 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,6 +20,7 @@ export interface HttpServerErrorParams {
     readonly error: unknown;
     next(): ServerHookNext;
     exit(): ServerHookExit;
+    routerInitializationData: RouterInitializationData;
 }
 export type HookServerError = (httpServerErrorParams: HttpServerErrorParams) => MaybePromise<ServerHookExit | ServerHookNext>;
 export declare function serverErrorExitHookFunction(): Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-hook-exit", unknown>, unknown>;
@@ -31,3 +33,4 @@ export interface HookHubLifeCycle {
     beforeServerBuildRoutes?: HookBeforeServerBuildRoutes;
     serverError?: HookServerError;
 }
+export declare function createHookHubLifeCycle(hookHubLifeCycle: HookHubLifeCycle): HookHubLifeCycle;

package/dist/core/hub/hooks.mjs

@@ -26,5 +26,8 @@ async function launchHookServerError(hooks, params) {
         }
     }
 }
+function createHookHubLifeCycle(hookHubLifeCycle) {
+    return hookHubLifeCycle;
+}
 
-export { hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction };
+export { createHookHubLifeCycle, hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction };

package/dist/core/hub/index.cjs

@@ -141,6 +141,7 @@ function createHub(config) {
 
 exports.defaultNotfoundHandler = defaultNotfoundHandler.defaultNotfoundHandler;
 exports.defaultExtractContract = defaultExtractContract.defaultExtractContract;
+exports.createHookHubLifeCycle = hooks.createHookHubLifeCycle;
 exports.hookServerExitKind = hooks.hookServerExitKind;
 exports.hookServerNextKind = hooks.hookServerNextKind;
 exports.launchHookBeforeBuildRoute = hooks.launchHookBeforeBuildRoute;

package/dist/core/hub/index.mjs

@@ -5,7 +5,7 @@ import '../steps/index.mjs';
 import { Request } from '../request.mjs';
 import { defaultNotfoundHandler } from './defaultNotfoundHandler.mjs';
 import { defaultExtractContract } from './defaultExtractContract.mjs';
-export { hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hooks.mjs';
+export { createHookHubLifeCycle, hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hooks.mjs';
 import { createHandlerStep } from '../steps/handler.mjs';
 
 const hubKind = createCoreLibKind("hub");

package/dist/core/implementHttpServer.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+require('./hub/index.cjs');
+var index = require('./router/index.cjs');
+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");
+    function catchCriticalError(error) {
+        console.error("Critical Error :", error);
+    }
+    const execRouteSystem = (routerInitializationData, whenUncaughtError) => router
+        .exec(routerInitializationData)
+        .catch(async (error) => {
+        await hooks.launchHookServerError(serverErrorHooks, {
+            error,
+            exit: hooks.serverErrorExitHookFunction,
+            next: hooks.serverErrorNextHookFunction,
+            routerInitializationData: routerInitializationData,
+        }).catch(utils.forward);
+        await whenUncaughtError(error, routerInitializationData);
+    })
+        .catch(catchCriticalError);
+    const result = await initHttpServer({
+        execRouteSystem: execRouteSystem,
+        httpServerParams: params.httpServerParams,
+    });
+    await hooks.launchHookServer(newHub2.aggregatesHooksHubLifeCycle("afterStartServer"), newHub2, params.httpServerParams);
+    return result;
+}
+
+exports.implementHttpServer = implementHttpServer;

package/dist/core/implementHttpServer.d.ts

@@ -0,0 +1,13 @@
+import { type Hub, type HttpServerParams } from "./hub";
+import { type RouterInitializationData } from "./router";
+import { type MaybePromise } from "@duplojs/utils";
+export interface ImplementHttpServerParams {
+    readonly hub: Hub;
+    readonly httpServerParams: HttpServerParams;
+}
+export type ExecRouteSystem = (routerInitializationData: RouterInitializationData, whenUncaughtError: (error: unknown, routerInitializationData: RouterInitializationData) => MaybePromise<void>) => Promise<void>;
+export interface InitHttpServerParams {
+    readonly execRouteSystem: ExecRouteSystem;
+    readonly httpServerParams: HttpServerParams;
+}
+export declare function implementHttpServer<GenericServer extends unknown>(params: ImplementHttpServerParams, initHttpServer: (params: InitHttpServerParams) => MaybePromise<GenericServer>): Promise<GenericServer>;

package/dist/core/implementHttpServer.mjs

@@ -0,0 +1,34 @@
+import './hub/index.mjs';
+import { buildRouter } from './router/index.mjs';
+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");
+    function catchCriticalError(error) {
+        console.error("Critical Error :", error);
+    }
+    const execRouteSystem = (routerInitializationData, whenUncaughtError) => router
+        .exec(routerInitializationData)
+        .catch(async (error) => {
+        await launchHookServerError(serverErrorHooks, {
+            error,
+            exit: serverErrorExitHookFunction,
+            next: serverErrorNextHookFunction,
+            routerInitializationData: routerInitializationData,
+        }).catch(forward);
+        await whenUncaughtError(error, routerInitializationData);
+    })
+        .catch(catchCriticalError);
+    const result = await initHttpServer({
+        execRouteSystem: execRouteSystem,
+        httpServerParams: params.httpServerParams,
+    });
+    await launchHookServer(newHub2.aggregatesHooksHubLifeCycle("afterStartServer"), newHub2, params.httpServerParams);
+    return result;
+}
+
+export { implementHttpServer };

package/dist/core/index.cjs

@@ -16,6 +16,8 @@ require('./functionsBuilders/index.cjs');
 var index$3 = require('./router/index.cjs');
 var stringIdentifier = require('./stringIdentifier.cjs');
 require('./metadata/index.cjs');
+var implementHttpServer = require('./implementHttpServer.cjs');
+var narrowingInput = require('./narrowingInput.cjs');
 var checker = require('./builders/checker.cjs');
 var builder = require('./builders/route/builder.cjs');
 var store = require('./builders/route/store.cjs');
@@ -71,6 +73,8 @@ exports.createHub = index$2.createHub;
 exports.hubKind = index$2.hubKind;
 exports.buildRouter = index$3.buildRouter;
 exports.createCoreLibStringIdentifier = stringIdentifier.createCoreLibStringIdentifier;
+exports.implementHttpServer = implementHttpServer.implementHttpServer;
+exports.createNarrowingInput = narrowingInput.createNarrowingInput;
 exports.checkerBuilder = checker.checkerBuilder;
 exports.useCheckerBuilder = checker.useCheckerBuilder;
 exports.routeBuilderHandler = builder.routeBuilderHandler;
@@ -105,6 +109,7 @@ exports.createProcessStep = process.createProcessStep;
 exports.processStepKind = process.processStepKind;
 exports.createPresetCheckerStep = presetChecker.createPresetCheckerStep;
 exports.presetCheckerStepKind = presetChecker.presetCheckerStepKind;
+exports.createHookHubLifeCycle = hooks$1.createHookHubLifeCycle;
 exports.hookServerExitKind = hooks$1.hookServerExitKind;
 exports.hookServerNextKind = hooks$1.hookServerNextKind;
 exports.launchHookBeforeBuildRoute = hooks$1.launchHookBeforeBuildRoute;

package/dist/core/index.d.ts

@@ -14,3 +14,5 @@ export * from "./functionsBuilders";
 export * from "./router";
 export * from "./stringIdentifier";
 export * from "./metadata";
+export * from "./implementHttpServer";
+export * from "./narrowingInput";

package/dist/core/index.mjs

@@ -14,6 +14,8 @@ import './functionsBuilders/index.mjs';
 export { buildRouter } from './router/index.mjs';
 export { createCoreLibStringIdentifier } from './stringIdentifier.mjs';
 import './metadata/index.mjs';
+export { implementHttpServer } from './implementHttpServer.mjs';
+export { createNarrowingInput } from './narrowingInput.mjs';
 export { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
 export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
 export { routeStore } from './builders/route/store.mjs';
@@ -32,7 +34,7 @@ export { createCutStep, cutStepKind, cutStepOutputKind } from './steps/cut.mjs';
 export { createHandlerStep, handlerStepKind } from './steps/handler.mjs';
 export { createProcessStep, processStepKind } from './steps/process.mjs';
 export { createPresetCheckerStep, presetCheckerStepKind } from './steps/presetChecker.mjs';
-export { hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hub/hooks.mjs';
+export { createHookHubLifeCycle, hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hub/hooks.mjs';
 export { defaultNotfoundHandler } from './hub/defaultNotfoundHandler.mjs';
 export { defaultExtractContract } from './hub/defaultExtractContract.mjs';
 export { buildRouteFunction } from './functionsBuilders/route/build.mjs';

package/dist/core/narrowingInput.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function createNarrowingInput() {
+    return new Proxy({}, {
+        get(target, name) {
+            return (target[name] ||= (value) => ({
+                inputName: name,
+                value,
+            }));
+        },
+    });
+}
+
+exports.createNarrowingInput = createNarrowingInput;

package/dist/core/narrowingInput.d.ts

@@ -0,0 +1,10 @@
+import { type SimplifyTopLevel, type AnyFunction, type ObjectKey } from "@duplojs/utils";
+export interface NarrowingInput<N extends ObjectKey = ObjectKey, V extends unknown = unknown> {
+    inputName: N;
+    value: V;
+}
+export type ShrinkerInput<T extends object = object> = SimplifyTopLevel<{
+    [P in keyof T]: (value: T[P]) => NarrowingInput<P, T[P]>;
+}>;
+export type GetNarrowingInput<I extends ShrinkerInput, N extends keyof I = keyof I> = ReturnType<I[N] extends AnyFunction ? I[N] : never>;
+export declare function createNarrowingInput<T extends object>(): ShrinkerInput<T>;

package/dist/core/narrowingInput.mjs

@@ -0,0 +1,12 @@
+function createNarrowingInput() {
+    return new Proxy({}, {
+        get(target, name) {
+            return (target[name] ||= (value) => ({
+                inputName: name,
+                value,
+            }));
+        },
+    });
+}
+
+export { createNarrowingInput };

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

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

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

@@ -2,7 +2,7 @@ import { type ResponseCode, Response } from "../response";
 import { type HookRouteLifeCycle } from "../route/hooks";
 declare const HookResponse_base: new (params: {
     "@DuplojsHttpCore/hook-response"?: unknown;
-}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hook-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hook-response", unknown>, unknown>;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hook-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hook-response", unknown>, unknown>;
 export declare class HookResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends HookResponse_base {
     code: GenericCode;
     information: GenericInformation;

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

@@ -1,7 +1,7 @@
 import { type ResponseCode, Response } from "../response";
 declare const PredictedResponse_base: new (params: {
     "@DuplojsHttpCore/predicted-response"?: unknown;
-}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
 export declare class PredictedResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends PredictedResponse_base {
     code: GenericCode;
     information: GenericInformation;

package/dist/core/route/hooks.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
 var kind = require('../kind.cjs');
-require('../response/index.cjs');
 
 const hookRouteExitKind = kind.createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = kind.createCoreLibKind("route-hook-next");

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

@@ -2,7 +2,6 @@ import { type Request } from "../request";
 import { type UnionToIntersection, type AnyFunction, type Kind, type MaybePromise, type SimplifyTopLevel, type IsEqual } from "@duplojs/utils";
 import { type HookResponse } from "../response";
 import { type ResponseCode, type Response } from "../response";
-export * from "../response";
 export interface HookParamsOnConstructRequest {
     request: Request;
     addRequestProperties<GenericNewProperties extends Record<string, unknown>>(newProperties: GenericNewProperties): Request & GenericNewProperties;

package/dist/core/route/hooks.mjs

@@ -1,5 +1,4 @@
 import { createCoreLibKind } from '../kind.mjs';
-import '../response/index.mjs';
 
 const hookRouteExitKind = createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = createCoreLibKind("route-hook-next");

package/dist/core/router/buildError.d.ts

@@ -2,7 +2,7 @@ import { type Route } from "../route";
 import { type Steps } from "../steps";
 declare const RouterBuildError_base: new (params: {
     "@DuplojsHttpCore/router-build-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/router-build-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"router-build-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/router-build-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"router-build-error", unknown>, unknown>;
 export declare class RouterBuildError extends RouterBuildError_base {
     route: Route;
     element: Route | Steps;

package/dist/core/router/types/buildedRouter.d.ts

@@ -2,8 +2,9 @@ import { type createStepFunctionBuilder, type createRouteFunctionBuilder } from
 import { type HookHubLifeCycle } from "../../hub";
 import { type RequestInitializationData } from "../../request";
 import { type HookRouteLifeCycle, type Route, type RouteDefinition } from "../../route";
+export type RouterInitializationData = Omit<RequestInitializationData, "matchedPath" | "params" | "path" | "query">;
 export interface BuildedRouter {
-    exec(initializationData: Omit<RequestInitializationData, "matchedPath" | "params" | "path" | "query">): Promise<void>;
+    exec(initializationData: RouterInitializationData): Promise<void>;
     readonly routes: readonly Route<RouteDefinition>[];
     readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
     readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];

package/dist/interfaces/node/createHttpServer.cjs

@@ -1,52 +1,25 @@
 'use strict';
 
-require('../../core/hub/index.cjs');
-var index = require('../../core/router/index.cjs');
 var utils = require('@duplojs/utils');
 var http = require('http');
 var https = require('https');
-var hooks$1 = require('./hooks.cjs');
-var hooks = require('../../core/hub/hooks.cjs');
+var hooks = require('./hooks.cjs');
+var implementHttpServer = require('../../core/implementHttpServer.cjs');
 
-async function createHttpServer(inputHub, params) {
-    const httpServerParams = {
-        ...params,
+function createHttpServer(inputHub, params) {
+    const httpServerParams = utils.O.override({
+        host: "localhost",
+        port: 80,
         maxBodySize: "50mb",
         informationHeaderKey: "information",
         predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
-    };
-    const newHub1 = await hooks.launchHookServer(inputHub.aggregatesHooksHubLifeCycle("beforeServerBuildRoutes"), inputHub, httpServerParams);
-    const router = await index.buildRouter(newHub1.addRouteHooks(hooks$1.makeNodeHook(newHub1, httpServerParams)));
-    const newHub2 = await hooks.launchHookServer(newHub1.aggregatesHooksHubLifeCycle("beforeStartServer"), newHub1, httpServerParams);
-    if (inputHub.config.environment === "BUILD") {
-        process.exit(0);
-    }
-    const server = params.https
-        ? https.createServer(params.https)
-        : http.createServer(params.http ?? {});
-    const serverErrorHooks = newHub1.aggregatesHooksHubLifeCycle("serverError");
-    server.addListener("request", (serverRequest, serverResponse) => router
-        .exec({
-        method: serverRequest.method ?? "",
-        headers: serverRequest.headers,
-        host: serverRequest.headers.host ?? "",
-        origin: serverRequest.headers.origin ?? "",
-        url: serverRequest.url ?? "",
-        raw: {
-            request: serverRequest,
-            response: serverResponse,
-        },
-    })
-        .catch(async (error) => {
-        await hooks.launchHookServerError(serverErrorHooks, {
-            error,
-            exit: hooks.serverErrorExitHookFunction,
-            next: hooks.serverErrorNextHookFunction,
-            serverRequest,
-            serverResponse,
-        }).catch(utils.forward);
+    }, params);
+    const hooks$1 = hooks.makeNodeHook(inputHub, httpServerParams);
+    const hub = inputHub.addRouteHooks(hooks$1);
+    function whenUncaughtError(error, routerInitializationData) {
+        const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
             serverResponse.writeHead(500, {
                 [httpServerParams.informationHeaderKey]: "critical-server-error",
@@ -59,15 +32,35 @@ async function createHttpServer(inputHub, params) {
         if (!serverResponse.writableEnded) {
             serverResponse.end();
         }
-    }));
-    await new Promise((resolve) => {
-        server.listen({
-            port: httpServerParams.port,
-            host: httpServerParams.host,
-        }, () => void resolve());
+    }
+    return implementHttpServer.implementHttpServer({
+        hub,
+        httpServerParams,
+    }, ({ httpServerParams, execRouteSystem }) => {
+        const server = httpServerParams.https
+            ? https.createServer(httpServerParams.https)
+            : http.createServer(httpServerParams.http ?? {});
+        server.addListener("request", (serverRequest, serverResponse) => execRouteSystem({
+            method: serverRequest.method ?? "",
+            headers: serverRequest.headers,
+            host: serverRequest.headers.host ?? "",
+            origin: serverRequest.headers.origin ?? "",
+            url: serverRequest.url ?? "",
+            raw: {
+                request: serverRequest,
+                response: serverResponse,
+            },
+        }, whenUncaughtError));
+        if (hub.config.environment === "BUILD") {
+            return server;
+        }
+        return new Promise((resolve) => {
+            server.listen({
+                port: httpServerParams.port,
+                host: httpServerParams.host,
+            }, () => void resolve(server));
+        });
     });
-    await hooks.launchHookServer(newHub2.aggregatesHooksHubLifeCycle("afterStartServer"), newHub2, httpServerParams);
-    return server;
 }
 
 exports.createHttpServer = createHttpServer;

package/dist/interfaces/node/createHttpServer.d.ts

@@ -1,6 +1,6 @@
 import { type HttpServerParams, type Hub } from "../../core/hub";
 import { type Hosts } from "./types/host";
-import { type O, type BytesInString } from "@duplojs/utils";
+import { type BytesInString, O } from "@duplojs/utils";
 import http from "http";
 import https from "https";
 declare module "../../core/hub" {
@@ -15,10 +15,6 @@ declare module "../../core/hub" {
         readonly http?: http.ServerOptions;
         readonly https?: https.ServerOptions;
     }
-    interface HttpServerErrorParams {
-        readonly serverRequest: http.IncomingMessage;
-        readonly serverResponse: http.ServerResponse;
-    }
 }
 export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "predictedHeaderKey" | "fromHookHeaderKey">;
 export declare function createHttpServer(inputHub: Hub, params: CreateHttpServerParams): Promise<https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;

package/dist/interfaces/node/createHttpServer.mjs

@@ -1,50 +1,23 @@
-import '../../core/hub/index.mjs';
-import { buildRouter } from '../../core/router/index.mjs';
-import { forward } from '@duplojs/utils';
+import { O } from '@duplojs/utils';
 import http from 'http';
 import https from 'https';
 import { makeNodeHook } from './hooks.mjs';
-import { launchHookServer, launchHookServerError, serverErrorNextHookFunction, serverErrorExitHookFunction } from '../../core/hub/hooks.mjs';
+import { implementHttpServer } from '../../core/implementHttpServer.mjs';
 
-async function createHttpServer(inputHub, params) {
-    const httpServerParams = {
-        ...params,
+function createHttpServer(inputHub, params) {
+    const httpServerParams = O.override({
+        host: "localhost",
+        port: 80,
         maxBodySize: "50mb",
         informationHeaderKey: "information",
         predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
-    };
-    const newHub1 = await launchHookServer(inputHub.aggregatesHooksHubLifeCycle("beforeServerBuildRoutes"), inputHub, httpServerParams);
-    const router = await buildRouter(newHub1.addRouteHooks(makeNodeHook(newHub1, httpServerParams)));
-    const newHub2 = await launchHookServer(newHub1.aggregatesHooksHubLifeCycle("beforeStartServer"), newHub1, httpServerParams);
-    if (inputHub.config.environment === "BUILD") {
-        process.exit(0);
-    }
-    const server = params.https
-        ? https.createServer(params.https)
-        : http.createServer(params.http ?? {});
-    const serverErrorHooks = newHub1.aggregatesHooksHubLifeCycle("serverError");
-    server.addListener("request", (serverRequest, serverResponse) => router
-        .exec({
-        method: serverRequest.method ?? "",
-        headers: serverRequest.headers,
-        host: serverRequest.headers.host ?? "",
-        origin: serverRequest.headers.origin ?? "",
-        url: serverRequest.url ?? "",
-        raw: {
-            request: serverRequest,
-            response: serverResponse,
-        },
-    })
-        .catch(async (error) => {
-        await launchHookServerError(serverErrorHooks, {
-            error,
-            exit: serverErrorExitHookFunction,
-            next: serverErrorNextHookFunction,
-            serverRequest,
-            serverResponse,
-        }).catch(forward);
+    }, params);
+    const hooks = makeNodeHook(inputHub, httpServerParams);
+    const hub = inputHub.addRouteHooks(hooks);
+    function whenUncaughtError(error, routerInitializationData) {
+        const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
             serverResponse.writeHead(500, {
                 [httpServerParams.informationHeaderKey]: "critical-server-error",
@@ -57,15 +30,35 @@ async function createHttpServer(inputHub, params) {
         if (!serverResponse.writableEnded) {
             serverResponse.end();
         }
-    }));
-    await new Promise((resolve) => {
-        server.listen({
-            port: httpServerParams.port,
-            host: httpServerParams.host,
-        }, () => void resolve());
+    }
+    return implementHttpServer({
+        hub,
+        httpServerParams,
+    }, ({ httpServerParams, execRouteSystem }) => {
+        const server = httpServerParams.https
+            ? https.createServer(httpServerParams.https)
+            : http.createServer(httpServerParams.http ?? {});
+        server.addListener("request", (serverRequest, serverResponse) => execRouteSystem({
+            method: serverRequest.method ?? "",
+            headers: serverRequest.headers,
+            host: serverRequest.headers.host ?? "",
+            origin: serverRequest.headers.origin ?? "",
+            url: serverRequest.url ?? "",
+            raw: {
+                request: serverRequest,
+                response: serverResponse,
+            },
+        }, whenUncaughtError));
+        if (hub.config.environment === "BUILD") {
+            return server;
+        }
+        return new Promise((resolve) => {
+            server.listen({
+                port: httpServerParams.port,
+                host: httpServerParams.host,
+            }, () => void resolve(server));
+        });
     });
-    await launchHookServer(newHub2.aggregatesHooksHubLifeCycle("afterStartServer"), newHub2, httpServerParams);
-    return server;
 }
 
 export { createHttpServer };

package/dist/interfaces/node/error/bodyParseUnknownError.d.ts

@@ -1,6 +1,6 @@
 declare const BodyParseUnknownError_base: new (params: {
     "@DuplojsHttpInterfacesNode/body-parse-unknown-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-unknown-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-unknown-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-unknown-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-unknown-error", unknown>, unknown>;
 export declare class BodyParseUnknownError extends BodyParseUnknownError_base {
     contentType: string;
     unknownError: unknown;

package/dist/interfaces/node/error/bodyParseWrongChunkReceived.d.ts

@@ -1,6 +1,6 @@
 declare const BodyParseWrongChunkReceived_base: new (params: {
     "@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-wrong-chunk-received", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-wrong-chunk-received", unknown>, unknown>;
 export declare class BodyParseWrongChunkReceived extends BodyParseWrongChunkReceived_base {
     wrongChunk: unknown;
     constructor(wrongChunk: unknown);

package/dist/interfaces/node/error/bodySizeExceedsLimitError.d.ts

@@ -1,7 +1,7 @@
 import { type BytesInString } from "@duplojs/utils";
 declare const BodySizeExceedsLimitError_base: new (params: {
     "@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
 export declare class BodySizeExceedsLimitError extends BodySizeExceedsLimitError_base {
     bytesInString: BytesInString | number;
     constructor(bytesInString: BytesInString | number);

package/dist/interfaces/node/hooks.cjs

@@ -3,6 +3,7 @@
 require('../../core/route/index.cjs');
 var utils = require('@duplojs/utils');
 require('./error/index.cjs');
+require('../../core/response/index.cjs');
 var hooks = require('../../core/route/hooks.cjs');
 var predicted = require('../../core/response/predicted.cjs');
 var hook = require('../../core/response/hook.cjs');
@@ -80,15 +81,17 @@ function makeNodeHook(hub, serverParams) {
             return exit();
         },
         beforeSendResponse({ request, currentResponse, exit }) {
-            const body = currentResponse.body;
-            if (typeof body === "string"
-                || body instanceof Error) {
-                currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
-            }
-            else if (typeof body === "object"
-                || typeof body === "number"
-                || typeof body === "boolean") {
-                currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+            if (!currentResponse.headers?.["content-type"]) {
+                const body = currentResponse.body;
+                if (typeof body === "string"
+                    || body instanceof Error) {
+                    currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
+                }
+                else if (typeof body === "object"
+                    || typeof body === "number"
+                    || typeof body === "boolean") {
+                    currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+                }
             }
             currentResponse.setHeader(informationHeaderKey, currentResponse.information);
             if (currentResponse instanceof predicted.PredictedResponse) {

package/dist/interfaces/node/hooks.d.ts

@@ -1,5 +1,5 @@
 import { type HttpServerParams, type Hub } from "../../core/hub";
-import { HookResponse } from "../../core/route";
+import { HookResponse } from "../../core/response";
 export declare function makeNodeHook(hub: Hub, serverParams: HttpServerParams): {
     parseBody({ request, exit }: import("../../core/route").RouteHookParams<import("../../core/request").Request>): Promise<import("../../core/route").RouteHookExit>;
     error({ error, response, exit }: import("../../core/route").RouteHookErrorParams<import("../../core/request").Request>): import("../../core/route").RouteHookExit | HookResponse<"400", "body-size-exceeds-limit-error", unknown> | HookResponse<"400", "body-parse-wrong-chunk-received", unknown> | HookResponse<"400", "body-parse-unknown-error", unknown>;

package/dist/interfaces/node/hooks.mjs

@@ -1,6 +1,7 @@
 import '../../core/route/index.mjs';
 import { stringToBytes } from '@duplojs/utils';
 import './error/index.mjs';
+import '../../core/response/index.mjs';
 import { createHookRouteLifeCycle } from '../../core/route/hooks.mjs';
 import { PredictedResponse } from '../../core/response/predicted.mjs';
 import { HookResponse } from '../../core/response/hook.mjs';
@@ -78,15 +79,17 @@ function makeNodeHook(hub, serverParams) {
             return exit();
         },
         beforeSendResponse({ request, currentResponse, exit }) {
-            const body = currentResponse.body;
-            if (typeof body === "string"
-                || body instanceof Error) {
-                currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
-            }
-            else if (typeof body === "object"
-                || typeof body === "number"
-                || typeof body === "boolean") {
-                currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+            if (!currentResponse.headers?.["content-type"]) {
+                const body = currentResponse.body;
+                if (typeof body === "string"
+                    || body instanceof Error) {
+                    currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
+                }
+                else if (typeof body === "object"
+                    || typeof body === "number"
+                    || typeof body === "boolean") {
+                    currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+                }
             }
             currentResponse.setHeader(informationHeaderKey, currentResponse.information);
             if (currentResponse instanceof PredictedResponse) {

package/dist/plugins/codeGenerator/plugin.cjs

@@ -30,6 +30,9 @@ function codeGeneratorPlugin(pluginParams) {
         hooksHubLifeCycle: [
             {
                 beforeStartServer: async (hub) => {
+                    if (!utils.equal(hub.config.environment, ["DEV", "BUILD"])) {
+                        return;
+                    }
                     const routes = hub.aggregatesRoutes();
                     const dataParserRoutes = utils.A.flatMap(routes, (route) => routeToDataParser.routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,

package/dist/plugins/codeGenerator/plugin.mjs

@@ -1,5 +1,5 @@
 import * as DataParserToTypescript from '@duplojs/data-parser-tools/toTypescript';
-import { A, DP } from '@duplojs/utils';
+import { equal, A, DP } from '@duplojs/utils';
 import { routeToDataParser } from './routeToDataParser.mjs';
 import { writeFile } from 'node:fs/promises';
 
@@ -9,6 +9,9 @@ function codeGeneratorPlugin(pluginParams) {
         hooksHubLifeCycle: [
             {
                 beforeStartServer: async (hub) => {
+                    if (!equal(hub.config.environment, ["DEV", "BUILD"])) {
+                        return;
+                    }
                     const routes = hub.aggregatesRoutes();
                     const dataParserRoutes = A.flatMap(routes, (route) => routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,

package/dist/plugins/openApiGenerator/makeOpenApiRoute.cjs

@@ -1,13 +1,23 @@
 'use strict';
 
 require('../../core/builders/index.cjs');
+require('../../core/metadata/index.cjs');
 require('../../core/response/index.cjs');
 var utils = require('@duplojs/utils');
+var metadata$1 = require('../codeGenerator/metadata.cjs');
+var metadata = require('./metadata.cjs');
 var builder = require('../../core/builders/route/builder.cjs');
+var ignoreByRouteStore = require('../../core/metadata/ignoreByRouteStore.cjs');
 var contract = require('../../core/response/contract.cjs');
 
 function makeOpenApiRoute(routePath, openApiPage) {
-    return builder.useRouteBuilder("GET", routePath)
+    return builder.useRouteBuilder("GET", routePath, {
+        metadata: [
+            ignoreByRouteStore.IgnoreByRouteStoreMetadata(),
+            metadata.IgnoreByOpenApiGeneratorMetadata(),
+            metadata$1.IgnoreByCodeGeneratorMetadata(),
+        ],
+    })
         .handler(contract.ResponseContract.ok("swaggerUi", utils.DP.string()), (__, { response }) => response("swaggerUi", openApiPage)
         .setHeader("content-type", "text/html"));
 }

package/dist/plugins/openApiGenerator/makeOpenApiRoute.d.ts

@@ -3,7 +3,7 @@ import type { RoutePath } from "../../core/route";
 import { DP } from "@duplojs/utils";
 export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: string): import("../../core/route").Route<{
     readonly method: "GET";
-    readonly metadata: readonly [];
+    readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>, import("../../core/metadata").Metadata<"ignore-by-open-api-generator", unknown>, import("../../core/metadata").Metadata<"ignore-by-code-generator", unknown>];
     readonly hooks: readonly [];
     readonly preflightSteps: readonly [];
     readonly paths: readonly [`/${string}`];

package/dist/plugins/openApiGenerator/makeOpenApiRoute.mjs

@@ -1,11 +1,21 @@
 import '../../core/builders/index.mjs';
+import '../../core/metadata/index.mjs';
 import '../../core/response/index.mjs';
 import { DP } from '@duplojs/utils';
+import { IgnoreByCodeGeneratorMetadata } from '../codeGenerator/metadata.mjs';
+import { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';
 import { useRouteBuilder } from '../../core/builders/route/builder.mjs';
+import { IgnoreByRouteStoreMetadata } from '../../core/metadata/ignoreByRouteStore.mjs';
 import { ResponseContract } from '../../core/response/contract.mjs';
 
 function makeOpenApiRoute(routePath, openApiPage) {
-    return useRouteBuilder("GET", routePath)
+    return useRouteBuilder("GET", routePath, {
+        metadata: [
+            IgnoreByRouteStoreMetadata(),
+            IgnoreByOpenApiGeneratorMetadata(),
+            IgnoreByCodeGeneratorMetadata(),
+        ],
+    })
         .handler(ResponseContract.ok("swaggerUi", DP.string()), (__, { response }) => response("swaggerUi", openApiPage)
         .setHeader("content-type", "text/html"));
 }

package/dist/plugins/openApiGenerator/plugin.cjs

@@ -12,6 +12,11 @@ function openApiGeneratorPlugin(pluginParams) {
         hooksHubLifeCycle: [
             {
                 beforeServerBuildRoutes: async (hub) => {
+                    if (!utils.equal(hub.config.environment, ["DEV", "BUILD"])
+                        || (!pluginParams.routePath
+                            && !pluginParams.outputFile)) {
+                        return;
+                    }
                     const contextToJsonSchemaFactory = new Map();
                     const resultSchemaContext = new Map();
                     const routes = hub.aggregatesRoutes();
@@ -71,16 +76,19 @@ function openApiGeneratorPlugin(pluginParams) {
                             : undefined,
                     };
                     const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
-                    if (pluginParams.outputFilePath) {
-                        await promises.writeFile(pluginParams.outputFilePath, openApiDocumentString);
+                    if (pluginParams.outputFile) {
+                        await promises.writeFile(pluginParams.outputFile, openApiDocumentString);
+                    }
+                    if (pluginParams.routePath) {
+                        const openApiPage = makeOpenApiPage.makeOpenApiPage({
+                            openApiDocument: openApiDocumentString,
+                            pageTitle: pluginParams.title ?? "Swagger API",
+                            swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
+                        });
+                        const openApiRoute = makeOpenApiRoute.makeOpenApiRoute(pluginParams.routePath, openApiPage);
+                        return hub.register(openApiRoute);
                     }
-                    const openApiPage = makeOpenApiPage.makeOpenApiPage({
-                        openApiDocument: openApiDocumentString,
-                        pageTitle: pluginParams.title ?? "Swagger API",
-                        swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
-                    });
-                    const openApiRoute = makeOpenApiRoute.makeOpenApiRoute(pluginParams.routePath, openApiPage);
-                    return hub.register(openApiRoute);
+                    return;
                 },
             },
         ],

package/dist/plugins/openApiGenerator/plugin.d.ts

@@ -14,8 +14,8 @@ interface OpenApiSecurityOptionBasic {
     type: "basic";
 }
 export interface OpenApiGeneratorPluginParams {
-    routePath: RoutePath;
-    outputFilePath?: string;
+    routePath?: RoutePath;
+    outputFile?: string;
     /**
      * @default "Swagger API"
      */

package/dist/plugins/openApiGenerator/plugin.mjs

@@ -1,5 +1,5 @@
 import { routeToOpenApi } from './routeToOpenApi.mjs';
-import { pipe, A, O, G, P, justReturn } from '@duplojs/utils';
+import { equal, pipe, A, O, G, P, justReturn } from '@duplojs/utils';
 import { makeOpenApiPage } from './makeOpenApiPage.mjs';
 import { makeOpenApiRoute } from './makeOpenApiRoute.mjs';
 import { writeFile } from 'fs/promises';
@@ -10,6 +10,11 @@ function openApiGeneratorPlugin(pluginParams) {
         hooksHubLifeCycle: [
             {
                 beforeServerBuildRoutes: async (hub) => {
+                    if (!equal(hub.config.environment, ["DEV", "BUILD"])
+                        || (!pluginParams.routePath
+                            && !pluginParams.outputFile)) {
+                        return;
+                    }
                     const contextToJsonSchemaFactory = new Map();
                     const resultSchemaContext = new Map();
                     const routes = hub.aggregatesRoutes();
@@ -69,16 +74,19 @@ function openApiGeneratorPlugin(pluginParams) {
                             : undefined,
                     };
                     const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
-                    if (pluginParams.outputFilePath) {
-                        await writeFile(pluginParams.outputFilePath, openApiDocumentString);
+                    if (pluginParams.outputFile) {
+                        await writeFile(pluginParams.outputFile, openApiDocumentString);
+                    }
+                    if (pluginParams.routePath) {
+                        const openApiPage = makeOpenApiPage({
+                            openApiDocument: openApiDocumentString,
+                            pageTitle: pluginParams.title ?? "Swagger API",
+                            swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
+                        });
+                        const openApiRoute = makeOpenApiRoute(pluginParams.routePath, openApiPage);
+                        return hub.register(openApiRoute);
                     }
-                    const openApiPage = makeOpenApiPage({
-                        openApiDocument: openApiDocumentString,
-                        pageTitle: pluginParams.title ?? "Swagger API",
-                        swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
-                    });
-                    const openApiRoute = makeOpenApiRoute(pluginParams.routePath, openApiPage);
-                    return hub.register(openApiRoute);
+                    return;
                 },
             },
         ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -10,16 +10,19 @@
   },
   "scripts": {
     "build": "rollup --config",
+    "docs:dev": "npm -w docs run docs:dev",
+    "docs:build": "npm -w docs run docs:build",
+    "docs:preview": "npm -w docs run docs:preview",
     "test:tu": "vitest --coverage",
     "test:tu:bench": "vitest bench",
     "test:tu:watch": "vitest --coverage --watch",
     "test:tu:update": "vitest --coverage --update",
-    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/client/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json && tsc -p tests/plugins/codeGenerator/tsconfig.json && tsc -p tests/plugins/openApiGenerator/tsconfig.json && npm -w integration run test:types",
-    "test:lint": "eslint",
-    "test:lint:fix": "eslint --fix",
+    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/client/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json && tsc -p tests/plugins/codeGenerator/tsconfig.json && tsc -p tests/plugins/openApiGenerator/tsconfig.json && npm -w integration run test:types && npm -w docs run test:types",
+    "test:lint": "eslint --quiet",
+    "test:lint:fix": "eslint --fix --quiet",
     "prepare": "husky"
   },
-  "types": "./dist/index.d.ts",
+  "types": "./dist/core/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/core/index.mjs",
@@ -63,7 +66,7 @@
   ],
   "peerDependencies": {
     "@duplojs/data-parser-tools": ">=0.2.4 <1.0.0",
-    "@duplojs/utils": ">=1.4.40 <2.0.0"
+    "@duplojs/utils": ">=1.4.46 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
@@ -89,7 +92,8 @@
     "vitest": "3.2.4"
   },
   "workspaces": [
-    "integration"
+    "integration",
+    "docs"
   ],
   "keywords": [],
   "engines": {