@duplojs/http 0.4.0 → 0.5.0

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

@@ -74,6 +74,7 @@ function createHub(config) {
                 notfoundHandler: handler.createHandlerStep({
                     responseContract,
                     theFunction: (floor, params) => theFunction(params),
+                    metadata: [],
                 }),
             };
         },

package/dist/core/hub/index.mjs

@@ -72,6 +72,7 @@ function createHub(config) {
                 notfoundHandler: createHandlerStep({
                     responseContract,
                     theFunction: (floor, params) => theFunction(params),
+                    metadata: [],
                 }),
             };
         },

package/dist/core/index.cjs

@@ -15,6 +15,7 @@ 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 checker = require('./builders/checker.cjs');
 var builder = require('./builders/route/builder.cjs');
 var store = require('./builders/route/store.cjs');
@@ -50,6 +51,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');
 
 
 
@@ -133,3 +136,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,4 @@ export * from "./hub";
 export * from "./functionsBuilders";
 export * from "./router";
 export * from "./stringIdentifier";
+export * from "./metadata";

package/dist/core/index.mjs

@@ -13,6 +13,7 @@ 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 { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
 export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
 export { routeStore } from './builders/route/store.mjs';
@@ -48,3 +49,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';

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