@duplojs/http 0.1.0 → 0.4.0

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

@@ -1,8 +1,10 @@
 import { type BuildStepFunctionParams } from "../steps";
 import { type BuildRouteNotSupportEither, type createRouteFunctionBuilder } from "./create";
 import { type HookRouteLifeCycle, type Route } from "../../route";
+import { type ResponseContract } from "../../response";
 export interface BuildRouteFunctionParams extends BuildStepFunctionParams {
     readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
     readonly globalHooksRouteLifeCycle: readonly HookRouteLifeCycle[];
+    readonly defaultExtractContract: ResponseContract.Contract;
 }
-export declare function buildRouteFunction(route: Route, params: BuildRouteFunctionParams): Promise<BuildRouteNotSupportEither | import("./create").BuildRouteSuccessEither>;
+export declare function buildRouteFunction(route: Route, params: BuildRouteFunctionParams): Promise<BuildRouteNotSupportEither | import("./create").BuildRouteSuccessEither | import("..").BuildStepNotSupportEither>;

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

@@ -1,18 +1,5 @@
-import { G, E } from '@duplojs/utils';
-import '../../checker.mjs';
-import '../../steps/kind.mjs';
-import '../../steps/identifier.mjs';
-import '../../steps/checker.mjs';
-import '../../steps/extract.mjs';
-import '../../steps/cut.mjs';
-import '../../steps/handler.mjs';
-import '../../steps/process.mjs';
-import '../../steps/presetChecker.mjs';
-import '../../response/index.mjs';
-import '../steps/defaults/cutStep.mjs';
-import '../steps/defaults/handlerStep.mjs';
-import '../steps/defaults/extractStep.mjs';
-import '../steps/defaults/processStep.mjs';
+import { E, G, unwrap } from '@duplojs/utils';
+import '../steps/index.mjs';
 import { buildStepFunction } from '../steps/build.mjs';
 
 function buildRouteFunction(route, params) {
@@ -25,10 +12,14 @@ function buildRouteFunction(route, params) {
         },
         environment: params.environment,
         globalHooksRouteLifeCycle: params.globalHooksRouteLifeCycle,
+        defaultExtractContract: params.defaultExtractContract,
     };
     return G.asyncReduce(params.routeFunctionBuilders, G.reduceFrom(E.left("routeNotSupport", route)), async ({ element: functionBuilder, lastValue, next, exit, }) => {
         const result = await functionBuilder(route, functionParams);
         if (E.isLeft(result)) {
+            if (unwrap(result) !== route) {
+                return exit(result);
+            }
             return next(lastValue);
         }
         return exit(result);

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

@@ -4,6 +4,7 @@ import { type Request } from "../../request";
 import { type Environment } from "../../types";
 import { type BuildStepSuccessEither, type BuildStepNotSupportEither } from "../steps";
 import { type Steps } from "../../steps";
+import { type ResponseContract } from "../../response";
 export type BuildedRouteFunction = (request: Request) => Promise<void>;
 export type BuildRouteSuccessEither = E.EitherRight<"buildSuccess", BuildedRouteFunction>;
 export type BuildRouteNotSupportEither = E.EitherLeft<"routeNotSupport", Route>;
@@ -12,5 +13,6 @@ export interface RouteFunctionBuilderParams {
     readonly environment: Environment;
     buildStep(element: Steps): Promise<BuildStepSuccessEither | BuildStepNotSupportEither>;
     success(result: BuildedRouteFunction): BuildRouteSuccessEither;
+    readonly defaultExtractContract: ResponseContract.Contract;
 }
 export declare function createRouteFunctionBuilder(support: (route: Route) => boolean, builder: (route: Route, params: RouteFunctionBuilderParams) => MaybePromise<BuildRouteSuccessEither | BuildStepNotSupportEither>): (route: Route, params: RouteFunctionBuilderParams) => MaybePromise<BuildRouteNotSupportEither | BuildRouteSuccessEither | BuildStepNotSupportEither>;

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

@@ -2,23 +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('../../checker.cjs');
-require('../../steps/kind.cjs');
-require('../../steps/identifier.cjs');
-require('../../steps/checker.cjs');
-require('../../steps/extract.cjs');
-require('../../steps/cut.cjs');
-require('../../steps/handler.cjs');
-require('../../steps/process.cjs');
-require('../../steps/presetChecker.cjs');
-require('../steps/defaults/cutStep.cjs');
-require('../steps/defaults/handlerStep.cjs');
-require('../steps/defaults/extractStep.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, }) => {
@@ -74,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;
@@ -91,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({
@@ -111,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,22 +1,12 @@
 import { routeKind } from '../../route/index.mjs';
 import { E, A, pipe, isType, forward } from '@duplojs/utils';
-import { Response } from '../../response/index.mjs';
-import { buildHookAfter, buildHookErrorBefore, buildHookBefore, nextHookFunction, exitHookFunction, createHookResponse } from './hook.mjs';
+import '../../response/index.mjs';
+import { buildHookAfter, buildHookErrorBefore, buildHookBefore, createHookResponse, nextHookFunction, exitHookFunction } from './hook.mjs';
 import { createRouteFunctionBuilder } from './create.mjs';
-import '../../checker.mjs';
-import '../../steps/kind.mjs';
-import '../../steps/identifier.mjs';
-import '../../steps/checker.mjs';
-import '../../steps/extract.mjs';
-import '../../steps/cut.mjs';
-import '../../steps/handler.mjs';
-import '../../steps/process.mjs';
-import '../../steps/presetChecker.mjs';
-import '../steps/defaults/cutStep.mjs';
-import '../steps/defaults/handlerStep.mjs';
-import '../steps/defaults/extractStep.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/route/index.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var build = require('./build.cjs');
+var create = require('./create.cjs');
+var _default = require('./default.cjs');
+var hook = require('./hook.cjs');
+
+
+
+exports.buildRouteFunction = build.buildRouteFunction;
+exports.createRouteFunctionBuilder = create.createRouteFunctionBuilder;
+exports.defaultRouteFunctionBuilder = _default.defaultRouteFunctionBuilder;
+exports.buildHookAfter = hook.buildHookAfter;
+exports.buildHookBefore = hook.buildHookBefore;
+exports.buildHookErrorBefore = hook.buildHookErrorBefore;
+exports.createHookResponse = hook.createHookResponse;
+exports.exitHookFunction = hook.exitHookFunction;
+exports.nextHookFunction = hook.nextHookFunction;

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

@@ -0,0 +1,4 @@
+export { buildRouteFunction } from './build.mjs';
+export { createRouteFunctionBuilder } from './create.mjs';
+export { defaultRouteFunctionBuilder } from './default.mjs';
+export { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, exitHookFunction, nextHookFunction } from './hook.mjs';

package/dist/core/functionsBuilders/steps/build.cjs

@@ -11,10 +11,14 @@ function buildStepFunction(step, params) {
             return buildStepFunction(step, params);
         },
         environment: params.environment,
+        defaultExtractContract: params.defaultExtractContract,
     };
     return utils.G.asyncReduce(params.stepFunctionBuilders, utils.G.reduceFrom(utils.E.left("stepNotSupport", step)), async ({ element: functionBuilder, lastValue, next, exit, }) => {
         const result = await functionBuilder(step, functionParams);
         if (utils.E.isLeft(result)) {
+            if (utils.unwrap(result) !== step) {
+                return exit(result);
+            }
             return next(lastValue);
         }
         return exit(result);

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

@@ -1,8 +1,10 @@
 import { type Steps } from "../../steps/types";
 import { type BuildStepNotSupportEither, type createStepFunctionBuilder } from "./create";
 import { type Environment } from "../../types";
+import { type ResponseContract } from "../../response";
 export interface BuildStepFunctionParams {
     readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
     readonly environment: Environment;
+    readonly defaultExtractContract: ResponseContract.Contract;
 }
 export declare function buildStepFunction(step: Steps, params: BuildStepFunctionParams): Promise<BuildStepNotSupportEither | import("./create").BuildStepSuccessEither>;

package/dist/core/functionsBuilders/steps/build.mjs

@@ -1,4 +1,4 @@
-import { G, E } from '@duplojs/utils';
+import { E, G, unwrap } from '@duplojs/utils';
 
 function buildStepFunction(step, params) {
     const functionParams = {
@@ -9,10 +9,14 @@ function buildStepFunction(step, params) {
             return buildStepFunction(step, params);
         },
         environment: params.environment,
+        defaultExtractContract: params.defaultExtractContract,
     };
     return G.asyncReduce(params.stepFunctionBuilders, G.reduceFrom(E.left("stepNotSupport", step)), async ({ element: functionBuilder, lastValue, next, exit, }) => {
         const result = await functionBuilder(step, functionParams);
         if (E.isLeft(result)) {
+            if (unwrap(result) !== step) {
+                return exit(result);
+            }
             return next(lastValue);
         }
         return exit(result);

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 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[];
@@ -16,5 +16,6 @@ export interface StepFunctionBuilderParams {
     buildStep(element: Steps): Promise<BuildStepSuccessEither | BuildStepNotSupportEither>;
     success(result: BuildStepResult): BuildStepSuccessEither;
     readonly environment: Environment;
+    readonly defaultExtractContract: ResponseContract.Contract;
 }
 export declare function createStepFunctionBuilder<GenericSupportStep extends Steps>(support: (step: Steps) => step is GenericSupportStep, builder: (step: GenericSupportStep, params: StepFunctionBuilderParams) => MaybePromise<BuildStepSuccessEither | BuildStepNotSupportEither>): (step: Steps, params: StepFunctionBuilderParams) => MaybePromise<BuildStepSuccessEither | BuildStepNotSupportEither>;

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

@@ -2,16 +2,12 @@
 
 var checker$1 = require('../../../checker.cjs');
 var create = require('../create.cjs');
-require('../../../steps/kind.cjs');
-require('../../../steps/identifier.cjs');
+require('../../../steps/index.cjs');
+var utils = require('@duplojs/utils');
+require('../../../response/index.cjs');
 var checker = require('../../../steps/checker.cjs');
-require('../../../steps/extract.cjs');
-require('../../../steps/cut.cjs');
-require('../../../steps/handler.cjs');
-require('../../../steps/process.cjs');
 var presetChecker = require('../../../steps/presetChecker.cjs');
-var utils = require('@duplojs/utils');
-var index = require('../../../response/index.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 }) => ({
@@ -41,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

@@ -1,15 +1,11 @@
 import { checkerOutputKind } from '../../../checker.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
-import '../../../steps/kind.mjs';
-import '../../../steps/identifier.mjs';
+import '../../../steps/index.mjs';
+import { pipe, P, or, isType, forward } from '@duplojs/utils';
+import '../../../response/index.mjs';
 import { checkerStepKind } from '../../../steps/checker.mjs';
-import '../../../steps/extract.mjs';
-import '../../../steps/cut.mjs';
-import '../../../steps/handler.mjs';
-import '../../../steps/process.mjs';
 import { presetCheckerStepKind } from '../../../steps/presetChecker.mjs';
-import { pipe, P, or, isType, forward } from '@duplojs/utils';
-import { Response } from '../../../response/index.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 }) => ({
@@ -39,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

@@ -1,17 +1,12 @@
 'use strict';
 
-require('../../../steps/kind.cjs');
-require('../../../steps/identifier.cjs');
-require('../../../steps/checker.cjs');
-require('../../../steps/extract.cjs');
-var cut = require('../../../steps/cut.cjs');
-require('../../../steps/handler.cjs');
-require('../../../steps/process.cjs');
-require('../../../steps/presetChecker.cjs');
+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;
@@ -24,11 +19,11 @@ const defaultCutStepFunctionBuilder = create.createStepFunctionBuilder(cut.cutSt
         if (!currentContract) {
             throw new contract.ResponseContract.Error(information);
         }
-        const result = currentContract.schema.parse(body);
+        const result = currentContract.body.parse(body);
         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)) {

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

@@ -1,15 +1,10 @@
-import '../../../steps/kind.mjs';
-import '../../../steps/identifier.mjs';
-import '../../../steps/checker.mjs';
-import '../../../steps/extract.mjs';
-import { cutStepKind, cutStepOutputKind } from '../../../steps/cut.mjs';
-import '../../../steps/handler.mjs';
-import '../../../steps/process.mjs';
-import '../../../steps/presetChecker.mjs';
+import '../../../steps/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
-import { A, wrapValue, E, unwrap } from '@duplojs/utils';
-import { Response } from '../../../response/index.mjs';
+import { wrapValue, A, E, unwrap } from '@duplojs/utils';
+import '../../../response/index.mjs';
+import { cutStepKind, cutStepOutputKind } from '../../../steps/cut.mjs';
 import { ResponseContract } from '../../../response/contract.mjs';
+import { PredictedResponse } from '../../../response/predicted.mjs';
 
 const defaultCutStepFunctionBuilder = createStepFunctionBuilder(cutStepKind.has, (step, { success }) => {
     const { responseContract, theFunction: cutFunction, } = step.definition;
@@ -22,11 +17,11 @@ const defaultCutStepFunctionBuilder = createStepFunctionBuilder(cutStepKind.has,
         if (!currentContract) {
             throw new ResponseContract.Error(information);
         }
-        const result = currentContract.schema.parse(body);
+        const result = currentContract.body.parse(body);
         if (E.isLeft(result)) {
             throw new ResponseContract.Error(information, unwrap(result));
         }
-        return new Response(currentContract.code, currentContract.information, body);
+        return new PredictedResponse(currentContract.code, currentContract.information, body);
     };
     function treatResult(result, floor) {
         if (cutStepOutputKind.has(result)) {

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

@@ -1,24 +1,17 @@
 'use strict';
 
-require('../../../steps/kind.cjs');
-require('../../../steps/identifier.cjs');
-require('../../../steps/checker.cjs');
-var extract = require('../../../steps/extract.cjs');
-require('../../../steps/cut.cjs');
-require('../../../steps/handler.cjs');
-require('../../../steps/process.cjs');
-require('../../../steps/presetChecker.cjs');
+require('../../../steps/index.cjs');
 var utils = require('@duplojs/utils');
-var index = require('../../../response/index.cjs');
+require('../../../response/index.cjs');
 var create = require('../create.cjs');
-var contract = require('../../../response/contract.cjs');
+var extract = require('../../../steps/extract.cjs');
+var predicted = require('../../../response/predicted.cjs');
 
-const defaultExtractStepFunctionBuilder = create.createStepFunctionBuilder(extract.extractStepKind.has, (step, { success, environment }) => {
+const defaultExtractStepFunctionBuilder = create.createStepFunctionBuilder(extract.extractStepKind.has, (step, { success, environment, defaultExtractContract }) => {
     const { shape, responseContract: stepResponseContract, } = step.definition;
-    const responseContract = stepResponseContract ?? contract.ResponseContract
-        .unprocessableContent("extract-error");
+    const responseContract = stepResponseContract ?? defaultExtractContract;
     function getResponse(result, key, subKey) {
-        const response = new index.Response(responseContract.code, responseContract.information, environment === "DEV"
+        const response = new predicted.PredictedResponse(responseContract.code, responseContract.information, environment === "DEV"
             ? utils.unwrap(result)
             : undefined);
         return subKey === undefined
@@ -41,9 +34,9 @@ const defaultExtractStepFunctionBuilder = create.createStepFunctionBuilder(extra
         buildedFunction: (request, floor) => {
             let newFloor = floor;
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
-            for (let index$1 = 0; index$1 < extractors.length; index$1++) {
-                const result = extractors[index$1](request, newFloor);
-                if (result instanceof index.Response) {
+            for (let index = 0; index < extractors.length; index++) {
+                const result = extractors[index](request, newFloor);
+                if (result instanceof predicted.PredictedResponse) {
                     return result;
                 }
                 newFloor = result;

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

@@ -1,22 +1,15 @@
-import '../../../steps/kind.mjs';
-import '../../../steps/identifier.mjs';
-import '../../../steps/checker.mjs';
-import { extractStepKind } from '../../../steps/extract.mjs';
-import '../../../steps/cut.mjs';
-import '../../../steps/handler.mjs';
-import '../../../steps/process.mjs';
-import '../../../steps/presetChecker.mjs';
-import { A, O, pipe, DP, P, isType, justReturn, innerPipe, E, unwrap } from '@duplojs/utils';
-import { Response } from '../../../response/index.mjs';
+import '../../../steps/index.mjs';
+import { unwrap, E, A, O, DP, pipe, P, isType, justReturn, innerPipe } from '@duplojs/utils';
+import '../../../response/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
-import { ResponseContract } from '../../../response/contract.mjs';
+import { extractStepKind } from '../../../steps/extract.mjs';
+import { PredictedResponse } from '../../../response/predicted.mjs';
 
-const defaultExtractStepFunctionBuilder = createStepFunctionBuilder(extractStepKind.has, (step, { success, environment }) => {
+const defaultExtractStepFunctionBuilder = createStepFunctionBuilder(extractStepKind.has, (step, { success, environment, defaultExtractContract }) => {
     const { shape, responseContract: stepResponseContract, } = step.definition;
-    const responseContract = stepResponseContract ?? ResponseContract
-        .unprocessableContent("extract-error");
+    const responseContract = stepResponseContract ?? defaultExtractContract;
     function getResponse(result, key, subKey) {
-        const response = new Response(responseContract.code, responseContract.information, environment === "DEV"
+        const response = new PredictedResponse(responseContract.code, responseContract.information, environment === "DEV"
             ? unwrap(result)
             : undefined);
         return subKey === undefined
@@ -41,7 +34,7 @@ const defaultExtractStepFunctionBuilder = createStepFunctionBuilder(extractStepK
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let index = 0; index < extractors.length; index++) {
                 const result = extractors[index](request, newFloor);
-                if (result instanceof Response) {
+                if (result instanceof PredictedResponse) {
                     return result;
                 }
                 newFloor = result;