@duplojs/http 0.2.0 → 0.5.0

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

@@ -5,15 +5,16 @@ import { type O, type MaybeArray, type NeverCoalescing, type FixDeepFunctionInfe
 import { type GetCheckerInput, type Checker, type GetCheckerResult, type GetCheckerOptions } from "../../checker";
 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> {
-        check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never>(checker: GenericChecker, params: {
+        check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(checker: GenericChecker, params: {
             input(floor: GenericFloor): GenericInput;
             readonly result: GenericResultInformation;
             readonly indexing?: GenericIndex;
             readonly options?: FixDeepFunctionInfer<GenericChecker["definition"]["options"] | ((floor: GenericFloor) => GenericChecker["definition"]["options"]), GenericOptions>;
             readonly otherwise: GenericResponseContract;
-        }): RouteBuilder<O.AssignObjects<GenericDefinition, {
+        }, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 CheckerStep<{
@@ -23,6 +24,7 @@ declare module "./builder" {
                     input(floor: GenericFloor): GenericInput;
                     readonly options: NeverCoalescing<Adaptor<GenericOptions, AnyFunction | GenericChecker["definition"]["options"]>, undefined>;
                     readonly responseContract: GenericResponseContract;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, O.AssignObjects<GenericFloor, {

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

@@ -2,7 +2,7 @@ import '../../steps/index.mjs';
 import { routeBuilderHandler } from './builder.mjs';
 import { createCheckerStep } from '../../steps/checker.mjs';
 
-routeBuilderHandler.set("check", ({ args: [checker, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+routeBuilderHandler.set("check", ({ args: [checker, { otherwise: responseContract, ...params }, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
@@ -10,6 +10,7 @@ routeBuilderHandler.set("check", ({ args: [checker, { otherwise: responseContrac
             ...params,
             responseContract,
             checker,
+            metadata,
         }),
     ],
 }));

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

@@ -2,12 +2,13 @@
 
 var index = require('../../route/index.cjs');
 var utils = require('@duplojs/utils');
-var index$1 = require('../../response/index.cjs');
+require('../../response/index.cjs');
 var hook = require('./hook.cjs');
 var create = require('./create.cjs');
 require('../steps/index.cjs');
 var processStep = require('../steps/defaults/processStep.cjs');
-var response = require('../../route/hooks/response.cjs');
+var base = require('../../response/base.cjs');
+var hook$1 = require('../../response/hook.cjs');
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {
@@ -63,13 +64,13 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 next: hook.nextHookFunction,
                 response: hook.createHookResponse("beforeRouteExecution"),
             });
-            if (beforeRouteExecutionResult instanceof index$1.Response) {
+            if (beforeRouteExecutionResult instanceof base.Response) {
                 return beforeRouteExecutionResult;
             }
             let floor = {};
             for (let index = 0; index < buildedPreFlightSteps.length; index++) {
                 const result = await buildedPreFlightSteps[index].buildedFunction(request, floor);
-                if (result instanceof index$1.Response) {
+                if (result instanceof base.Response) {
                     return result;
                 }
                 floor = result;
@@ -80,17 +81,17 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 next: hook.nextHookFunction,
                 response: hook.createHookResponse("parseBody"),
             });
-            if (parseBodyResult instanceof index$1.Response) {
+            if (parseBodyResult instanceof base.Response) {
                 return parseBodyResult;
             }
             for (let index = 0; index < buildedSteps.length; index++) {
                 const result = await buildedSteps[index].buildedFunction(request, floor);
-                if (result instanceof index$1.Response) {
+                if (result instanceof base.Response) {
                     return result;
                 }
                 floor = result;
             }
-            return new index$1.Response("500", "missing-response", undefined);
+            return new base.Response("500", "missing-response", undefined);
         }
         catch (error) {
             const errorResult = await hooks.error({
@@ -100,10 +101,10 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 next: hook.nextHookFunction,
                 response: hook.createHookResponse("error"),
             });
-            if (errorResult instanceof response.HookResponse) {
+            if (errorResult instanceof hook$1.HookResponse) {
                 return errorResult;
             }
-            return new index$1.Response("500", "server-error", error);
+            return new base.Response("500", "server-error", error);
         }
     }
     return success(async (request) => {

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

@@ -1,11 +1,12 @@
 import { routeKind } from '../../route/index.mjs';
 import { E, A, pipe, isType, forward } from '@duplojs/utils';
-import { Response } from '../../response/index.mjs';
+import '../../response/index.mjs';
 import { buildHookAfter, buildHookErrorBefore, buildHookBefore, createHookResponse, nextHookFunction, exitHookFunction } from './hook.mjs';
 import { createRouteFunctionBuilder } from './create.mjs';
 import '../steps/index.mjs';
 import { buildStepsFunction } from '../steps/defaults/processStep.mjs';
-import { HookResponse } from '../../route/hooks/response.mjs';
+import { Response } from '../../response/base.mjs';
+import { HookResponse } from '../../response/hook.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {

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

@@ -1,56 +1,56 @@
 'use strict';
 
 require('../../route/index.cjs');
-var index = require('../../route/hooks/index.cjs');
-var response = require('../../route/hooks/response.cjs');
+var hooks = require('../../route/hooks.cjs');
+var hook = require('../../response/hook.cjs');
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
-const hookExit = index.hookRouteExitKind.setTo({});
-const hookNext = index.hookRouteNextKind.setTo({});
+const hookExit = hooks.hookRouteExitKind.setTo({});
+const hookNext = hooks.hookRouteNextKind.setTo({});
 function exitHookFunction() {
     return hookExit;
 }
 function nextHookFunction() {
     return hookNext;
 }
-function buildHookBefore(hooks) {
-    if (!hooks.length) {
+function buildHookBefore(hooks$1) {
+    if (!hooks$1.length) {
         return exitHookFunction;
     }
     return async (params) => {
-        for (let index$1 = 0; index$1 < hooks.length; index$1++) {
-            const result = await hooks[index$1](params);
-            if (index.hookRouteExitKind.has(result)
-                || result instanceof response.HookResponse) {
+        for (let index = 0; index < hooks$1.length; index++) {
+            const result = await hooks$1[index](params);
+            if (hooks.hookRouteExitKind.has(result)
+                || result instanceof hook.HookResponse) {
                 return result;
             }
         }
         return hookNext;
     };
 }
-function buildHookErrorBefore(hooks) {
-    if (!hooks.length) {
+function buildHookErrorBefore(hooks$1) {
+    if (!hooks$1.length) {
         return exitHookFunction;
     }
     return async (params) => {
-        for (let index$1 = 0; index$1 < hooks.length; index$1++) {
-            const result = await hooks[index$1](params);
-            if (index.hookRouteExitKind.has(result)
-                || result instanceof response.HookResponse) {
+        for (let index = 0; index < hooks$1.length; index++) {
+            const result = await hooks$1[index](params);
+            if (hooks.hookRouteExitKind.has(result)
+                || result instanceof hook.HookResponse) {
                 return result;
             }
         }
         return hookNext;
     };
 }
-function buildHookAfter(hooks) {
-    if (!hooks.length) {
+function buildHookAfter(hooks$1) {
+    if (!hooks$1.length) {
         return exitHookFunction;
     }
     return async (params) => {
-        for (let index$1 = 0; index$1 < hooks.length; index$1++) {
-            const result = await hooks[index$1](params);
-            if (index.hookRouteExitKind.has(result)) {
+        for (let index = 0; index < hooks$1.length; index++) {
+            const result = await hooks$1[index](params);
+            if (hooks.hookRouteExitKind.has(result)) {
                 return result;
             }
         }
@@ -58,7 +58,7 @@ function buildHookAfter(hooks) {
     };
 }
 function createHookResponse(from) {
-    return (code, information, body) => new response.HookResponse(from, code, information, body);
+    return (code, information, body) => new hook.HookResponse(from, code, information, body);
 }
 
 exports.buildHookAfter = buildHookAfter;

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

@@ -1,7 +1,7 @@
 import { type HookAfterSendResponse, type HookBeforeRouteExecution, type HookBeforeSendResponse, type HookError, type HookParseBody, HookResponse, 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("../..").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("../..").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("../../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 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,6 +1,6 @@
 import '../../route/index.mjs';
-import { hookRouteExitKind, hookRouteNextKind } from '../../route/hooks/index.mjs';
-import { HookResponse } from '../../route/hooks/response.mjs';
+import { hookRouteExitKind, hookRouteNextKind } from '../../route/hooks.mjs';
+import { HookResponse } from '../../response/hook.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const hookExit = hookRouteExitKind.setTo({});

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

@@ -3,9 +3,9 @@ import { type Steps } from "../../steps/types";
 import { type Floor } from "../../floor";
 import { type HookRouteLifeCycle } from "../../route";
 import { type Request } from "../../request";
-import { type ResponseContract, type Response } from "../../response";
+import { type ResponseContract, type PredictedResponse } from "../../response";
 import { type Environment } from "../../types";
-export type BuildedStepFunction = (request: Request, floor: Floor) => MaybePromise<Floor | Response>;
+export type BuildedStepFunction = (request: Request, floor: Floor) => MaybePromise<Floor | PredictedResponse>;
 export interface BuildStepResult {
     readonly buildedFunction: BuildedStepFunction;
     readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];

package/dist/core/functionsBuilders/steps/defaults/checkerStep.cjs

@@ -4,9 +4,10 @@ var checker$1 = require('../../../checker.cjs');
 var create = require('../create.cjs');
 require('../../../steps/index.cjs');
 var utils = require('@duplojs/utils');
-var index = require('../../../response/index.cjs');
+require('../../../response/index.cjs');
 var checker = require('../../../steps/checker.cjs');
 var presetChecker = require('../../../steps/presetChecker.cjs');
+var predicted = require('../../../response/predicted.cjs');
 
 const defaultCheckerStepFunctionBuilder = create.createStepFunctionBuilder((element) => checker.checkerStepKind.has(element) || presetChecker.presetCheckerStepKind.has(element), (step, { success }) => {
     const { checkerOptions, checkerFunction, input, responseContract, stepResult, indexing, stepOptions, } = utils.pipe(step, utils.P.when(checker.checkerStepKind.has, ({ definition }) => ({
@@ -36,7 +37,7 @@ const defaultCheckerStepFunctionBuilder = create.createStepFunctionBuilder((elem
     });
     const expectedResult = utils.pipe(stepResult, utils.P.when(utils.isType("string"), (expectedInformation) => ((information) => information === expectedInformation)), utils.P.otherwise((expectedInformation) => ((information) => expectedInformation.includes(information))));
     function getResponse() {
-        return new index.Response(responseContract.code, responseContract.information, undefined);
+        return new predicted.PredictedResponse(responseContract.code, responseContract.information, undefined);
     }
     function treatResult(output, floor) {
         if (!expectedResult(output.information)) {

package/dist/core/functionsBuilders/steps/defaults/checkerStep.mjs

@@ -2,9 +2,10 @@ import { checkerOutputKind } from '../../../checker.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import '../../../steps/index.mjs';
 import { pipe, P, or, isType, forward } from '@duplojs/utils';
-import { Response } from '../../../response/index.mjs';
+import '../../../response/index.mjs';
 import { checkerStepKind } from '../../../steps/checker.mjs';
 import { presetCheckerStepKind } from '../../../steps/presetChecker.mjs';
+import { PredictedResponse } from '../../../response/predicted.mjs';
 
 const defaultCheckerStepFunctionBuilder = createStepFunctionBuilder((element) => checkerStepKind.has(element) || presetCheckerStepKind.has(element), (step, { success }) => {
     const { checkerOptions, checkerFunction, input, responseContract, stepResult, indexing, stepOptions, } = pipe(step, P.when(checkerStepKind.has, ({ definition }) => ({
@@ -34,7 +35,7 @@ const defaultCheckerStepFunctionBuilder = createStepFunctionBuilder((element) =>
     });
     const expectedResult = pipe(stepResult, P.when(isType("string"), (expectedInformation) => ((information) => information === expectedInformation)), P.otherwise((expectedInformation) => ((information) => expectedInformation.includes(information))));
     function getResponse() {
-        return new Response(responseContract.code, responseContract.information, undefined);
+        return new PredictedResponse(responseContract.code, responseContract.information, undefined);
     }
     function treatResult(output, floor) {
         if (!expectedResult(output.information)) {

package/dist/core/functionsBuilders/steps/defaults/cutStep.cjs

@@ -3,9 +3,10 @@
 require('../../../steps/index.cjs');
 var create = require('../create.cjs');
 var utils = require('@duplojs/utils');
-var index = require('../../../response/index.cjs');
+require('../../../response/index.cjs');
 var cut = require('../../../steps/cut.cjs');
 var contract = require('../../../response/contract.cjs');
+var predicted = require('../../../response/predicted.cjs');
 
 const defaultCutStepFunctionBuilder = create.createStepFunctionBuilder(cut.cutStepKind.has, (step, { success }) => {
     const { responseContract, theFunction: cutFunction, } = step.definition;
@@ -22,7 +23,7 @@ const defaultCutStepFunctionBuilder = create.createStepFunctionBuilder(cut.cutSt
         if (utils.E.isLeft(result)) {
             throw new contract.ResponseContract.Error(information, utils.unwrap(result));
         }
-        return new index.Response(currentContract.code, currentContract.information, body);
+        return new predicted.PredictedResponse(currentContract.code, currentContract.information, body);
     };
     function treatResult(result, floor) {
         if (cut.cutStepOutputKind.has(result)) {