@duplojs/http 0.4.0 → 0.5.1

package/dist/core/builders/route/cut.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var cut = require('../../steps/cut.cjs');
 
-builder.routeBuilderHandler.set("cut", ({ args: [responseContract, theFunction], accumulator, next, }) => next({
+builder.routeBuilderHandler.set("cut", ({ args: [responseContract, theFunction, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         cut.createCutStep({
             responseContract,
             theFunction,
+            metadata,
         }),
     ],
 }));

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

@@ -4,14 +4,16 @@ import { type RouteDefinition } from "../../route";
 import { type CutStepFunctionOutput, type CutStep, type CutStepFunctionParams } from "../../steps";
 import { type Unwrap, type O, type MaybePromise, type IsEqual, type A } from "@duplojs/utils";
 import { type Request } from "../../request";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        cut<const GenericResponseContract extends (ResponseContract.Contract | readonly ResponseContract.Contract[]), GenericResponse extends ResponseContract.Convert<A.ArrayCoalescing<GenericResponseContract>[number]>, GenericOutput extends CutStepFunctionOutput | GenericResponse>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericOutput>): RouteBuilder<O.AssignObjects<GenericDefinition, {
+        cut<const GenericResponseContract extends (ResponseContract.Contract | readonly ResponseContract.Contract[]), GenericResponse extends ResponseContract.Convert<A.ArrayCoalescing<GenericResponseContract>[number]>, GenericOutput extends CutStepFunctionOutput | GenericResponse, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, params: CutStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericOutput>, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 CutStep<{
                     readonly responseContract: GenericResponseContract;
                     theFunction(floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>): MaybePromise<GenericOutput>;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, IsEqual<Extract<GenericOutput, CutStepFunctionOutput>, never> extends true ? GenericFloor : (GenericOutput extends infer InferredOutputData extends CutStepFunctionOutput ? O.AssignObjects<GenericFloor, Unwrap<InferredOutputData>> : never), GenericRequest>;

package/dist/core/builders/route/cut.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { routeBuilderHandler } from './builder.mjs';
 import { createCutStep } from '../../steps/cut.mjs';
 
-routeBuilderHandler.set("cut", ({ args: [responseContract, theFunction], accumulator, next, }) => next({
+routeBuilderHandler.set("cut", ({ args: [responseContract, theFunction, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         createCutStep({
             responseContract,
             theFunction,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/route/extract.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var extract = require('../../steps/extract.cjs');
 
-builder.routeBuilderHandler.set("extract", ({ args: [shape, responseContract], accumulator, next, }) => next({
+builder.routeBuilderHandler.set("extract", ({ args: [shape, responseContract, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         extract.createExtractStep({
             shape,
             responseContract,
+            metadata,
         }),
     ],
 }));

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

@@ -4,14 +4,16 @@ import { type ExtractShape, type ExtractStep } from "../../steps";
 import { type DP, type ObjectEntry, type O, type SimplifyTopLevel, type NeverCoalescing } from "@duplojs/utils";
 import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
 import { type Request } from "../../request";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        extract<GenericShape extends ExtractShape<GenericRequest>, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>) = never>(shape: GenericShape, responseContract?: GenericResponseContract): RouteBuilder<O.AssignObjects<GenericDefinition, {
+        extract<GenericShape extends ExtractShape<GenericRequest>, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty> | undefined) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(shape: GenericShape, responseContract?: GenericResponseContract, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 ExtractStep<{
                     readonly shape: GenericShape;
                     readonly responseContract: NeverCoalescing<GenericResponseContract, undefined>;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, O.AssignObjects<GenericFloor, {

package/dist/core/builders/route/extract.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { routeBuilderHandler } from './builder.mjs';
 import { createExtractStep } from '../../steps/extract.mjs';
 
-routeBuilderHandler.set("extract", ({ args: [shape, responseContract], accumulator, next, }) => next({
+routeBuilderHandler.set("extract", ({ args: [shape, responseContract, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         createExtractStep({
             shape,
             responseContract,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/route/handler.cjs

@@ -2,11 +2,14 @@
 
 var index = require('../../route/index.cjs');
 require('../../steps/index.cjs');
+var utils = require('@duplojs/utils');
 var builder = require('./builder.cjs');
 var store = require('./store.cjs');
+require('../../metadata/index.cjs');
 var handler = require('../../steps/handler.cjs');
+var ignoreByRouteStore = require('../../metadata/ignoreByRouteStore.cjs');
 
-builder.routeBuilderHandler.set("handler", ({ args: [responseContract, theFunction], accumulator, }) => {
+builder.routeBuilderHandler.set("handler", ({ args: [responseContract, theFunction, ...metadata], accumulator, }) => {
     const route = index.createRoute({
         ...accumulator,
         steps: [
@@ -14,9 +17,13 @@ builder.routeBuilderHandler.set("handler", ({ args: [responseContract, theFuncti
             handler.createHandlerStep({
                 responseContract,
                 theFunction,
+                metadata,
             }),
         ],
     });
-    store.routeStore.add(route);
+    const ignoreByRouteStoreMetadata = utils.A.find(accumulator.metadata, ignoreByRouteStore.IgnoreByRouteStoreMetadata.is);
+    if (ignoreByRouteStoreMetadata === undefined) {
+        store.routeStore.add(route);
+    }
     return route;
 });

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

@@ -4,14 +4,16 @@ import { type Route, type RouteDefinition } from "../../route";
 import { type HandlerStep, type HandlerStepFunctionParams } from "../../steps";
 import { type MaybePromise, type AnyTuple, type O } from "@duplojs/utils";
 import { type Request } from "../../request";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        handler<GenericResponseContract extends (ResponseContract.Contract | readonly [ResponseContract.Contract, ...ResponseContract.Contract[]]), GenericResponse extends ResponseContract.Convert<GenericResponseContract extends AnyTuple ? GenericResponseContract[number] : GenericResponseContract>>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: HandlerStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericResponse>): Route<O.AssignObjects<GenericDefinition, {
+        handler<GenericResponseContract extends (ResponseContract.Contract | readonly [ResponseContract.Contract, ...ResponseContract.Contract[]]), GenericResponse extends ResponseContract.Convert<GenericResponseContract extends AnyTuple ? GenericResponseContract[number] : GenericResponseContract>, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: HandlerStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericResponse>, ...metadata: GenericMetadata): Route<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 HandlerStep<{
                     readonly responseContract: GenericResponseContract;
                     theFunction(floor: GenericFloor, param: HandlerStepFunctionParams<GenericRequest, GenericResponse>): MaybePromise<GenericResponse>;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>>;

package/dist/core/builders/route/handler.mjs

@@ -1,10 +1,13 @@
 import { createRoute } from '../../route/index.mjs';
 import '../../steps/index.mjs';
+import { A } from '@duplojs/utils';
 import { routeBuilderHandler } from './builder.mjs';
 import { routeStore } from './store.mjs';
+import '../../metadata/index.mjs';
 import { createHandlerStep } from '../../steps/handler.mjs';
+import { IgnoreByRouteStoreMetadata } from '../../metadata/ignoreByRouteStore.mjs';
 
-routeBuilderHandler.set("handler", ({ args: [responseContract, theFunction], accumulator, }) => {
+routeBuilderHandler.set("handler", ({ args: [responseContract, theFunction, ...metadata], accumulator, }) => {
     const route = createRoute({
         ...accumulator,
         steps: [
@@ -12,9 +15,13 @@ routeBuilderHandler.set("handler", ({ args: [responseContract, theFunction], acc
             createHandlerStep({
                 responseContract,
                 theFunction,
+                metadata,
             }),
         ],
     });
-    routeStore.add(route);
+    const ignoreByRouteStoreMetadata = A.find(accumulator.metadata, IgnoreByRouteStoreMetadata.is);
+    if (ignoreByRouteStoreMetadata === undefined) {
+        routeStore.add(route);
+    }
     return route;
 });

package/dist/core/builders/route/presetChecker.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var presetChecker = require('../../steps/presetChecker.cjs');
 
-builder.routeBuilderHandler.set("presetCheck", ({ args: [presetChecker$1, input,], accumulator, next, }) => next({
+builder.routeBuilderHandler.set("presetCheck", ({ args: [presetChecker$1, input, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         presetChecker.createPresetCheckerStep({
             presetChecker: presetChecker$1,
             input,
+            metadata,
         }),
     ],
 }));

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

@@ -4,14 +4,16 @@ import { type PresetCheckerStep } from "../../steps";
 import { type O, type A } from "@duplojs/utils";
 import { type Request } from "../../request";
 import { type GetPresetCheckerIndex, type GetPresetCheckerInformation, type GetPresetCheckerResult, type GetPresetCheckerInput, type PresetChecker } from "../../presetChecker";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        presetCheck<GenericPresetChecker extends PresetChecker, GenericInput extends GetPresetCheckerInput<GenericPresetChecker>>(presetChecker: GenericPresetChecker, input: (floor: GenericFloor) => GenericInput): RouteBuilder<O.AssignObjects<GenericDefinition, {
+        presetCheck<GenericPresetChecker extends PresetChecker, GenericInput extends GetPresetCheckerInput<GenericPresetChecker>, const GenericMetadata extends readonly Metadata[] = readonly []>(presetChecker: GenericPresetChecker, input: (floor: GenericFloor) => GenericInput, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 PresetCheckerStep<{
                     readonly presetChecker: GenericPresetChecker;
                     input(floor: GenericFloor): GenericInput;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, O.AssignObjects<GenericFloor, {

package/dist/core/builders/route/presetChecker.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { routeBuilderHandler } from './builder.mjs';
 import { createPresetCheckerStep } from '../../steps/presetChecker.mjs';
 
-routeBuilderHandler.set("presetCheck", ({ args: [presetChecker, input,], accumulator, next, }) => next({
+routeBuilderHandler.set("presetCheck", ({ args: [presetChecker, input, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         createPresetCheckerStep({
             presetChecker,
             input,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/route/process.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var process = require('../../steps/process.cjs');
 
-builder.routeBuilderHandler.set("exec", ({ args: [process$1, params,], accumulator, next, }) => next({
+builder.routeBuilderHandler.set("exec", ({ args: [process$1, params, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         process.createProcessStep({
             ...params,
             process: process$1,
+            metadata,
         }),
     ],
 }));

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

@@ -4,18 +4,20 @@ import { type ProcessStep } from "../../steps";
 import { type O, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction } from "@duplojs/utils";
 import { type GetProcessRequest, type GetProcessExportValue, type Process } from "../../process";
 import { type Request } from "../../request";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        exec<GenericProcess extends Process, GenericProcessExportValue extends GetProcessExportValue<GenericProcess>, const GenericImportation extends readonly Extract<keyof GenericProcessExportValue, string>[] = never, GenericOptions extends (GenericProcess["definition"]["options"] | ((floor: GenericFloor) => Exclude<GenericProcess["definition"]["options"], undefined>)) = never>(process: GenericProcess, params?: {
+        exec<GenericProcess extends Process, GenericProcessExportValue extends GetProcessExportValue<GenericProcess>, const GenericImportation extends readonly Extract<keyof GenericProcessExportValue, string>[] = never, GenericOptions extends (GenericProcess["definition"]["options"] | ((floor: GenericFloor) => Exclude<GenericProcess["definition"]["options"], undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(process: GenericProcess, params?: {
             readonly imports?: GenericImportation;
             readonly options?: FixDeepFunctionInfer<GenericProcess["definition"]["options"] | ((floor: GenericFloor) => GenericProcess["definition"]["options"]), GenericOptions>;
-        }): RouteBuilder<O.AssignObjects<GenericDefinition, {
+        }, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 ProcessStep<{
                     readonly process: GenericProcess;
                     readonly options: NeverCoalescing<Adaptor<GenericOptions, AnyFunction | GenericProcess["definition"]["options"]>, undefined>;
                     readonly imports: NeverCoalescing<GenericImportation, undefined>;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>, GenericRequest & NeverCoalescing<GetProcessRequest<GenericProcess>, Request>>;

package/dist/core/builders/route/process.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { routeBuilderHandler } from './builder.mjs';
 import { createProcessStep } from '../../steps/process.mjs';
 
-routeBuilderHandler.set("exec", ({ args: [process, params,], accumulator, next, }) => next({
+routeBuilderHandler.set("exec", ({ args: [process, params, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         createProcessStep({
             ...params,
             process,
+            metadata,
         }),
     ],
 }));

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/defaultNotfoundHandler.cjs

@@ -9,6 +9,7 @@ var contract = require('../response/contract.cjs');
 const defaultNotfoundHandler = handler.createHandlerStep({
     responseContract: contract.ResponseContract.notFound("notfound-route", utils.DP.string()),
     theFunction: (floor, { request, response }) => response("notfound-route", `${request.method}:${request.path}`),
+    metadata: [],
 });
 
 exports.defaultNotfoundHandler = defaultNotfoundHandler;

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

@@ -7,4 +7,5 @@ export declare const defaultNotfoundHandler: import("../steps").HandlerStep<{
         readonly checkers: readonly [];
     }>>>;
     theFunction: (floor: import("..").Floor, { request, response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
+    metadata: never[];
 }>;

package/dist/core/hub/defaultNotfoundHandler.mjs

@@ -7,6 +7,7 @@ import { ResponseContract } from '../response/contract.mjs';
 const defaultNotfoundHandler = createHandlerStep({
     responseContract: ResponseContract.notFound("notfound-route", DP.string()),
     theFunction: (floor, { request, response }) => response("notfound-route", `${request.method}:${request.path}`),
+    metadata: [],
 });
 
 export { defaultNotfoundHandler };

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

@@ -74,6 +74,7 @@ function createHub(config) {
                 notfoundHandler: handler.createHandlerStep({
                     responseContract,
                     theFunction: (floor, params) => theFunction(params),
+                    metadata: [],
                 }),
             };
         },
@@ -140,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");
@@ -72,6 +72,7 @@ function createHub(config) {
                 notfoundHandler: createHandlerStep({
                     responseContract,
                     theFunction: (floor, params) => theFunction(params),
+                    metadata: [],
                 }),
             };
         },

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

@@ -15,6 +15,9 @@ var index$2 = require('./hub/index.cjs');
 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');
@@ -50,6 +53,8 @@ var build$1 = require('./functionsBuilders/steps/build.cjs');
 var pathToRegExp = require('./router/pathToRegExp.cjs');
 var buildError = require('./router/buildError.cjs');
 var decodeUrl = require('./router/decodeUrl.cjs');
+var base$1 = require('./metadata/base.cjs');
+var ignoreByRouteStore = require('./metadata/ignoreByRouteStore.cjs');
 
 
 
@@ -68,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;
@@ -102,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;
@@ -133,3 +141,6 @@ exports.RouterBuildError = buildError.RouterBuildError;
 exports.decodeUrl = decodeUrl.decodeUrl;
 exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
 exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
+exports.createMetadata = base$1.createMetadata;
+exports.metadataKind = base$1.metadataKind;
+exports.IgnoreByRouteStoreMetadata = ignoreByRouteStore.IgnoreByRouteStoreMetadata;

package/dist/core/index.d.ts

@@ -13,3 +13,6 @@ export * from "./hub";
 export * from "./functionsBuilders";
 export * from "./router";
 export * from "./stringIdentifier";
+export * from "./metadata";
+export * from "./implementHttpServer";
+export * from "./narrowingInput";

package/dist/core/index.mjs

@@ -13,6 +13,9 @@ export { createHub, hubKind } from './hub/index.mjs';
 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';
@@ -31,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';
@@ -48,3 +51,5 @@ export { buildStepFunction } from './functionsBuilders/steps/build.mjs';
 export { pathToRegExp } from './router/pathToRegExp.mjs';
 export { RouterBuildError } from './router/buildError.mjs';
 export { decodeUrl, regexQueryAnalyser, regexUrlAnalyser } from './router/decodeUrl.mjs';
+export { createMetadata, metadataKind } from './metadata/base.mjs';
+export { IgnoreByRouteStoreMetadata } from './metadata/ignoreByRouteStore.mjs';