@duplojs/http 0.4.0 → 0.5.1

package/dist/core/metadata/base.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+
+const metadataKind = kind.createCoreLibKind("metadata");
+function createMetadata(name) {
+    function metadataHandler(value) {
+        return metadataKind.setTo(utils.wrapValue(value), name);
+    }
+    metadataHandler.dataName = name;
+    metadataHandler.is = function (input) {
+        return metadataKind.has(input)
+            && metadataKind.getValue(input) === name;
+    };
+    return metadataHandler;
+}
+
+exports.createMetadata = createMetadata;
+exports.metadataKind = metadataKind;

package/dist/core/metadata/base.d.ts

@@ -0,0 +1,14 @@
+import { type WrappedValue, type Kind, type IsEqual, type Or, type IsExtends } from "@duplojs/utils";
+export declare const metadataKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/metadata", string>>;
+export interface Metadata<GenericName extends string = string, GenericValue extends unknown = unknown> extends Kind<typeof metadataKind.definition, GenericName>, WrappedValue<GenericValue> {
+}
+export interface MetadataHandler<GenericName extends string, GenericValue extends unknown> {
+    dataName: GenericName;
+    <GenericMetadataValue extends GenericValue>(...args: Or<[
+        IsEqual<GenericValue, unknown>,
+        IsEqual<GenericValue, never>,
+        IsExtends<undefined, GenericValue>
+    ]> extends true ? [value?: GenericMetadataValue] : [value: GenericMetadataValue]): Metadata<GenericName, GenericMetadataValue>;
+    is(input: unknown): input is Metadata<GenericName, any>;
+}
+export declare function createMetadata<GenericName extends string, GenericValue extends unknown = unknown>(name: GenericName): MetadataHandler<GenericName, GenericValue>;

package/dist/core/metadata/base.mjs

@@ -0,0 +1,17 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { wrapValue } from '@duplojs/utils';
+
+const metadataKind = createCoreLibKind("metadata");
+function createMetadata(name) {
+    function metadataHandler(value) {
+        return metadataKind.setTo(wrapValue(value), name);
+    }
+    metadataHandler.dataName = name;
+    metadataHandler.is = function (input) {
+        return metadataKind.has(input)
+            && metadataKind.getValue(input) === name;
+    };
+    return metadataHandler;
+}
+
+export { createMetadata, metadataKind };

package/dist/core/metadata/ignoreByRouteStore.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var base = require('./base.cjs');
+
+const IgnoreByRouteStoreMetadata = base.createMetadata("ignore-by-route-store");
+
+exports.IgnoreByRouteStoreMetadata = IgnoreByRouteStoreMetadata;

package/dist/core/metadata/ignoreByRouteStore.d.ts

@@ -0,0 +1 @@
+export declare const IgnoreByRouteStoreMetadata: import("./base").MetadataHandler<"ignore-by-route-store", unknown>;

package/dist/core/metadata/ignoreByRouteStore.mjs

@@ -0,0 +1,5 @@
+import { createMetadata } from './base.mjs';
+
+const IgnoreByRouteStoreMetadata = createMetadata("ignore-by-route-store");
+
+export { IgnoreByRouteStoreMetadata };

package/dist/core/metadata/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var base = require('./base.cjs');
+var ignoreByRouteStore = require('./ignoreByRouteStore.cjs');
+
+
+
+exports.createMetadata = base.createMetadata;
+exports.metadataKind = base.metadataKind;
+exports.IgnoreByRouteStoreMetadata = ignoreByRouteStore.IgnoreByRouteStoreMetadata;

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

@@ -0,0 +1,2 @@
+export * from "./base";
+export * from "./ignoreByRouteStore";

package/dist/core/metadata/index.mjs

@@ -0,0 +1,2 @@
+export { createMetadata, metadataKind } from './base.mjs';
+export { IgnoreByRouteStoreMetadata } from './ignoreByRouteStore.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/process/index.d.ts

@@ -3,6 +3,7 @@ import { type ProcessStep, type CheckerStep, type CutStep, type ExtractStep, typ
 import { type Floor } from "../floor";
 import { type HookRouteLifeCycle } from "../route";
 import { type Request } from "../request";
+import { type Metadata } from "../metadata";
 export * from "./types";
 export interface ProcessStepsCustom {
 }
@@ -13,6 +14,7 @@ export interface ProcessDefinition {
     steps: readonly ProcessSteps[];
     options?: Record<string, unknown>;
     readonly hooks: readonly HookRouteLifeCycle[];
+    readonly metadata: readonly Metadata[];
     [SymbolProcessExportValue]?: Floor;
     [SymbolProcessRequest]?: Request;
 }
@@ -28,4 +30,4 @@ export declare const processKind: import("@duplojs/utils").KindHandler<import("@
 export interface Process<GenericDefinition extends ProcessDefinition = ProcessDefinition> extends Kind<typeof processKind.definition> {
     definition: GenericDefinition;
 }
-export declare function createProcess<GenericDefinition extends Pick<ProcessDefinition, "steps" | "options" | "hooks">>(definition: GenericDefinition): Process<GenericDefinition>;
+export declare function createProcess<GenericDefinition extends Pick<ProcessDefinition, "steps" | "options" | "hooks" | "metadata">>(definition: GenericDefinition): Process<GenericDefinition>;

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/route/index.d.ts

@@ -2,6 +2,7 @@ import { type O, type Kind } from "@duplojs/utils";
 import { type RequestMethods } from "../request";
 import { type ExtractStep, type CheckerStep, type CutStep, type HandlerStep, type ProcessStep, type stepKind, type PresetCheckerStep } from "../steps";
 import { type HookRouteLifeCycle } from "./hooks";
+import { type Metadata } from "../metadata";
 export * from "./types";
 export * from "./hooks";
 export interface RouteStepsCustom {
@@ -17,6 +18,7 @@ export interface RouteDefinition {
     readonly preflightSteps: readonly RoutePreFlightSteps[];
     readonly steps: readonly RouteSteps[];
     readonly hooks: readonly HookRouteLifeCycle[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const routeKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route", unknown>>;
 export interface Route<GenericDefinition extends RouteDefinition = RouteDefinition> extends Kind<typeof routeKind.definition> {

package/dist/core/router/index.cjs

@@ -58,6 +58,7 @@ async function buildRouter(inputHub) {
         hooks: [],
         preflightSteps: [],
         steps: [hub.notfoundHandler],
+        metadata: [],
     }), async (route) => {
         const result = await build.buildRouteFunction(route, buildParams);
         return utils.E.whenIsLeft(result, (element) => {

package/dist/core/router/index.mjs

@@ -57,6 +57,7 @@ async function buildRouter(inputHub) {
         hooks: [],
         preflightSteps: [],
         steps: [hub.notfoundHandler],
+        metadata: [],
     }), async (route) => {
         const result = await buildRouteFunction(route, buildParams);
         return E.whenIsLeft(result, (element) => {

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/core/steps/checker.d.ts

@@ -3,6 +3,7 @@ import { type StepKind } from "./kind";
 import { type Checker } from "../checker";
 import { type Floor } from "../floor";
 import { type ClientErrorResponseCode, type ResponseContract } from "../response";
+import { type Metadata } from "../metadata";
 export interface CheckerStepDefinition {
     readonly checker: Checker;
     readonly result: string | readonly string[];
@@ -10,6 +11,7 @@ export interface CheckerStepDefinition {
     input(input: Floor): unknown;
     readonly options?: Record<string, unknown> | ((input: any) => Record<string, unknown>);
     readonly responseContract: ResponseContract.Contract<ClientErrorResponseCode>;
+    readonly metadata: readonly Metadata[];
 }
 export declare const checkerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>>;
 export type _CheckerStep = (Kind<typeof checkerStepKind.definition> & StepKind);

package/dist/core/steps/cut.d.ts

@@ -4,6 +4,7 @@ import { type Floor } from "../floor";
 import { type StepFunctionParams } from "./types";
 import { type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
+import { type Metadata } from "../metadata";
 export declare const cutStepOutputKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-output", unknown>>;
 export interface CutStepFunctionOutput<GenericData extends Record<string, unknown> = Record<string, unknown>> extends Kind<typeof cutStepOutputKind.definition>, WrappedValue<GenericData> {
 }
@@ -13,6 +14,7 @@ export interface CutStepFunctionParams<GenericRequest extends Request = Request,
 export interface CutStepDefinition {
     theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | PredictedResponse>;
     readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const cutStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>>;
 export type _CutStep = (Kind<typeof cutStepKind.definition> & StepKind);

package/dist/core/steps/extract.d.ts

@@ -2,6 +2,7 @@ import { type DP, type Kind, type O, type AnyFunction } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Request } from "../request";
 import { type ClientErrorResponseCode, type ResponseContract } from "../response";
+import { type Metadata } from "../metadata";
 export interface DisabledExtractKeysCustom {
 }
 export type DisabledExtractKeys = O.GetPropsWithValue<DisabledExtractKeysCustom, true>;
@@ -9,6 +10,7 @@ export type ExtractShape<GenericRequest extends Request = Request> = Partial<Rec
 export interface ExtractStepDefinition {
     readonly shape: ExtractShape;
     readonly responseContract?: ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>;
+    readonly metadata: readonly Metadata[];
 }
 export declare const extractStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>>;
 export type _ExtractStep = (Kind<typeof extractStepKind.definition> & StepKind);

package/dist/core/steps/handler.d.ts

@@ -4,11 +4,13 @@ import { type Floor } from "../floor";
 import { type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
 import { type StepFunctionParams } from "./types";
+import { type Metadata } from "../metadata";
 export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
 }
 export interface HandlerStepDefinition {
     theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse>;
     readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const handlerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>>;
 type _HandlerStep = (Kind<typeof handlerStepKind.definition> & StepKind);

package/dist/core/steps/presetChecker.d.ts

@@ -2,9 +2,11 @@ import { type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type PresetChecker } from "../presetChecker";
+import { type Metadata } from "../metadata";
 export interface PresetCheckerStepDefinition {
     readonly presetChecker: PresetChecker;
     input(input: Floor): unknown;
+    readonly metadata: readonly Metadata[];
 }
 export declare const presetCheckerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>>;
 export type _PresetCheckerStep = (Kind<typeof presetCheckerStepKind.definition> & StepKind);

package/dist/core/steps/process.d.ts

@@ -1,10 +1,12 @@
 import { type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Process } from "../process";
+import { type Metadata } from "../metadata";
 export interface ProcessStepDefinition {
     readonly process: Process;
     readonly options?: Record<string, unknown> | ((input: any) => Record<string, unknown>);
     readonly imports?: readonly string[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const processStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>;
 export type _ProcessStep = (Kind<typeof processStepKind.definition> & StepKind);

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,32 @@ 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));
+        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,32 @@ 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));
+        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/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) {