@duplojs/http 0.6.2 → 0.7.1

package/dist/core/defaultHooks/index.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+require('../response/index.cjs');
+require('../route/index.cjs');
+var serverUtils = require('@duplojs/server-utils');
+var hooks = require('../route/hooks.cjs');
+var predicted = require('../response/predicted.cjs');
+var hook = require('../response/hook.cjs');
+
+function initDefaultHook(hub, serverParams) {
+    const informationHeaderKey = serverParams.informationHeaderKey;
+    const predictedHeaderKey = serverParams.predictedHeaderKey;
+    const fromHookHeaderKey = serverParams.fromHookHeaderKey;
+    const isDev = hub.config.environment === "DEV";
+    return hooks.createHookRouteLifeCycle({
+        beforeSendResponse({ currentResponse, next }) {
+            if (!currentResponse.headers?.["content-type"]) {
+                const body = currentResponse.body;
+                if (typeof body === "string"
+                    || body instanceof Error) {
+                    currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
+                }
+                else if (serverUtils.SF.isFileInterface(body)) {
+                    const filename = body.getName();
+                    const filenameHeader = filename
+                        ? ` filename="${filename}"`
+                        : "";
+                    currentResponse
+                        .setHeader("content-type", body.getMimeType() ?? "application/octet-stream")
+                        .setHeader("content-disposition", `attachment;${filenameHeader}`);
+                }
+                else if (typeof body === "object"
+                    || typeof body === "number"
+                    || typeof body === "boolean") {
+                    currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+                }
+            }
+            currentResponse.setHeader(informationHeaderKey, currentResponse.information);
+            if (currentResponse instanceof predicted.PredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+            }
+            else if (currentResponse instanceof hook.HookResponse) {
+                currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
+            }
+            return next();
+        },
+    });
+}
+
+exports.initDefaultHook = initDefaultHook;

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

@@ -0,0 +1,5 @@
+import { type Hub } from "../hub";
+import { type HttpServerParams } from "../types";
+export declare function initDefaultHook(hub: Hub, serverParams: HttpServerParams): {
+    beforeSendResponse({ currentResponse, next }: import("../route").RouteHookParamsAfter<import("..").Request>): import("../route").RouteHookNext;
+};

package/dist/core/defaultHooks/index.mjs

@@ -0,0 +1,48 @@
+import '../response/index.mjs';
+import '../route/index.mjs';
+import { SF } from '@duplojs/server-utils';
+import { createHookRouteLifeCycle } from '../route/hooks.mjs';
+import { PredictedResponse } from '../response/predicted.mjs';
+import { HookResponse } from '../response/hook.mjs';
+
+function initDefaultHook(hub, serverParams) {
+    const informationHeaderKey = serverParams.informationHeaderKey;
+    const predictedHeaderKey = serverParams.predictedHeaderKey;
+    const fromHookHeaderKey = serverParams.fromHookHeaderKey;
+    const isDev = hub.config.environment === "DEV";
+    return createHookRouteLifeCycle({
+        beforeSendResponse({ currentResponse, next }) {
+            if (!currentResponse.headers?.["content-type"]) {
+                const body = currentResponse.body;
+                if (typeof body === "string"
+                    || body instanceof Error) {
+                    currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
+                }
+                else if (SF.isFileInterface(body)) {
+                    const filename = body.getName();
+                    const filenameHeader = filename
+                        ? ` filename="${filename}"`
+                        : "";
+                    currentResponse
+                        .setHeader("content-type", body.getMimeType() ?? "application/octet-stream")
+                        .setHeader("content-disposition", `attachment;${filenameHeader}`);
+                }
+                else if (typeof body === "object"
+                    || typeof body === "number"
+                    || typeof body === "boolean") {
+                    currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+                }
+            }
+            currentResponse.setHeader(informationHeaderKey, currentResponse.information);
+            if (currentResponse instanceof PredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+            }
+            else if (currentResponse instanceof HookResponse) {
+                currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
+            }
+            return next();
+        },
+    });
+}
+
+export { initDefaultHook };

package/dist/{interfaces/node/error → core/errors}/bodyParseWrongChunkReceived.cjs

@@ -1,12 +1,14 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
 var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
 
-class BodyParseWrongChunkReceived extends utils.kindHeritage("body-parse-wrong-chunk-received", kind.createInterfacesNodeLibKind("body-parse-wrong-chunk-received"), Error) {
+class BodyParseWrongChunkReceived extends utils.kindHeritage("body-parse-wrong-chunk-received", kind.createCoreLibKind("body-parse-wrong-chunk-received"), Error) {
+    information;
     wrongChunk;
-    constructor(wrongChunk) {
-        super({}, ["Received chunk is not buffer or string."]);
+    constructor(information, wrongChunk) {
+        super({}, [`Received chunk is not ${information}`]);
+        this.information = information;
         this.wrongChunk = wrongChunk;
     }
 }

package/dist/core/errors/bodyParseWrongChunkReceived.d.ts

@@ -0,0 +1,9 @@
+declare const BodyParseWrongChunkReceived_base: new (params: {
+    "@DuplojsHttpCore/body-parse-wrong-chunk-received"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-parse-wrong-chunk-received", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-wrong-chunk-received", unknown>, unknown>;
+export declare class BodyParseWrongChunkReceived extends BodyParseWrongChunkReceived_base {
+    information: string;
+    wrongChunk: unknown;
+    constructor(information: string, wrongChunk: unknown);
+}
+export {};

package/dist/core/errors/bodyParseWrongChunkReceived.mjs

@@ -0,0 +1,14 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+class BodyParseWrongChunkReceived extends kindHeritage("body-parse-wrong-chunk-received", createCoreLibKind("body-parse-wrong-chunk-received"), Error) {
+    information;
+    wrongChunk;
+    constructor(information, wrongChunk) {
+        super({}, [`Received chunk is not ${information}`]);
+        this.information = information;
+        this.wrongChunk = wrongChunk;
+    }
+}
+
+export { BodyParseWrongChunkReceived };

package/dist/{interfaces/node/error → core/errors}/bodySizeExceedsLimitError.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
 var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
 
-class BodySizeExceedsLimitError extends utils.kindHeritage("body-size-exceeds-limit-error", kind.createInterfacesNodeLibKind("body-size-exceeds-limit-error"), Error) {
+class BodySizeExceedsLimitError extends utils.kindHeritage("body-size-exceeds-limit-error", kind.createCoreLibKind("body-size-exceeds-limit-error"), Error) {
     bytesInString;
     constructor(bytesInString) {
         super({}, [`Body size is bigger than ${bytesInString}.`]);

package/dist/{interfaces/node/error → core/errors}/bodySizeExceedsLimitError.d.ts

@@ -1,7 +1,7 @@
 import { type BytesInString } from "@duplojs/utils";
 declare const BodySizeExceedsLimitError_base: new (params: {
-    "@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error"?: unknown;
-}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
+    "@DuplojsHttpCore/body-size-exceeds-limit-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
 export declare class BodySizeExceedsLimitError extends BodySizeExceedsLimitError_base {
     bytesInString: BytesInString | number;
     constructor(bytesInString: BytesInString | number);

package/dist/{interfaces/node/error → core/errors}/bodySizeExceedsLimitError.mjs

@@ -1,7 +1,7 @@
+import { createCoreLibKind } from '../kind.mjs';
 import { kindHeritage } from '@duplojs/utils';
-import { createInterfacesNodeLibKind } from '../kind.mjs';
 
-class BodySizeExceedsLimitError extends kindHeritage("body-size-exceeds-limit-error", createInterfacesNodeLibKind("body-size-exceeds-limit-error"), Error) {
+class BodySizeExceedsLimitError extends kindHeritage("body-size-exceeds-limit-error", createCoreLibKind("body-size-exceeds-limit-error"), Error) {
     bytesInString;
     constructor(bytesInString) {
         super({}, [`Body size is bigger than ${bytesInString}.`]);

package/dist/{interfaces/node/error → core/errors}/index.cjs

@@ -1,11 +1,13 @@
 'use strict';
 
-var bodySizeExceedsLimitError = require('./bodySizeExceedsLimitError.cjs');
+var wrongContentTypeError = require('./wrongContentTypeError.cjs');
 var bodyParseWrongChunkReceived = require('./bodyParseWrongChunkReceived.cjs');
-var bodyParseUnknownError = require('./bodyParseUnknownError.cjs');
+var bodySizeExceedsLimitError = require('./bodySizeExceedsLimitError.cjs');
+var parseJsonError = require('./parseJsonError.cjs');
 
 
 
-exports.BodySizeExceedsLimitError = bodySizeExceedsLimitError.BodySizeExceedsLimitError;
+exports.WrongContentTypeError = wrongContentTypeError.WrongContentTypeError;
 exports.BodyParseWrongChunkReceived = bodyParseWrongChunkReceived.BodyParseWrongChunkReceived;
-exports.BodyParseUnknownError = bodyParseUnknownError.BodyParseUnknownError;
+exports.BodySizeExceedsLimitError = bodySizeExceedsLimitError.BodySizeExceedsLimitError;
+exports.ParseJsonError = parseJsonError.ParseJsonError;

package/dist/{interfaces/node/error → core/errors}/index.d.ts

@@ -1,3 +1,4 @@
-export * from "./bodySizeExceedsLimitError";
+export * from "./wrongContentTypeError";
 export * from "./bodyParseWrongChunkReceived";
-export * from "./bodyParseUnknownError";
+export * from "./bodySizeExceedsLimitError";
+export * from "./parseJsonError";

package/dist/{interfaces/node/error → core/errors}/index.mjs

@@ -1,3 +1,4 @@
-export { BodySizeExceedsLimitError } from './bodySizeExceedsLimitError.mjs';
+export { WrongContentTypeError } from './wrongContentTypeError.mjs';
 export { BodyParseWrongChunkReceived } from './bodyParseWrongChunkReceived.mjs';
-export { BodyParseUnknownError } from './bodyParseUnknownError.mjs';
+export { BodySizeExceedsLimitError } from './bodySizeExceedsLimitError.mjs';
+export { ParseJsonError } from './parseJsonError.mjs';

package/dist/core/errors/parseJsonError.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+
+class ParseJsonError extends utils.kindHeritage("parse-json-error", kind.createCoreLibKind("parse-json-error"), Error) {
+    payload;
+    error;
+    constructor(payload, error) {
+        super({}, ["Error when parse on json."]);
+        this.payload = payload;
+        this.error = error;
+    }
+}
+
+exports.ParseJsonError = ParseJsonError;

package/dist/core/errors/parseJsonError.d.ts

@@ -0,0 +1,9 @@
+declare const ParseJsonError_base: new (params: {
+    "@DuplojsHttpCore/parse-json-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/parse-json-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"parse-json-error", unknown>, unknown>;
+export declare class ParseJsonError extends ParseJsonError_base {
+    payload: string;
+    error: unknown;
+    constructor(payload: string, error: unknown);
+}
+export {};

package/dist/core/errors/parseJsonError.mjs

@@ -0,0 +1,14 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+class ParseJsonError extends kindHeritage("parse-json-error", createCoreLibKind("parse-json-error"), Error) {
+    payload;
+    error;
+    constructor(payload, error) {
+        super({}, ["Error when parse on json."]);
+        this.payload = payload;
+        this.error = error;
+    }
+}
+
+export { ParseJsonError };

package/dist/core/errors/wrongContentTypeError.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+
+class WrongContentTypeError extends utils.kindHeritage("wrong-content-type-error", kind.createCoreLibKind("wrong-content-type-error"), Error) {
+    expectedContentType;
+    contentType;
+    constructor(expectedContentType, contentType) {
+        super({}, [`expect content-type "${expectedContentType}" but receive "${contentType}".`]);
+        this.expectedContentType = expectedContentType;
+        this.contentType = contentType;
+    }
+}
+
+exports.WrongContentTypeError = WrongContentTypeError;

package/dist/core/errors/wrongContentTypeError.d.ts

@@ -0,0 +1,9 @@
+declare const WrongContentTypeError_base: new (params: {
+    "@DuplojsHttpCore/wrong-content-type-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/wrong-content-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"wrong-content-type-error", unknown>, unknown>;
+export declare class WrongContentTypeError extends WrongContentTypeError_base {
+    expectedContentType: string;
+    contentType: string;
+    constructor(expectedContentType: string, contentType: string);
+}
+export {};

package/dist/core/errors/wrongContentTypeError.mjs

@@ -0,0 +1,14 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+class WrongContentTypeError extends kindHeritage("wrong-content-type-error", createCoreLibKind("wrong-content-type-error"), Error) {
+    expectedContentType;
+    contentType;
+    constructor(expectedContentType, contentType) {
+        super({}, [`expect content-type "${expectedContentType}" but receive "${contentType}".`]);
+        this.expectedContentType = expectedContentType;
+        this.contentType = contentType;
+    }
+}
+
+export { WrongContentTypeError };

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

@@ -6,8 +6,8 @@ import { type BuildStepSuccessEither, type BuildStepNotSupportEither } from "../
 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>;
+export type BuildRouteSuccessEither = E.Right<"buildSuccess", BuildedRouteFunction>;
+export type BuildRouteNotSupportEither = E.Left<"routeNotSupport", Route>;
 export interface RouteFunctionBuilderParams {
     readonly globalHooksRouteLifeCycle: readonly HookRouteLifeCycle[];
     readonly environment: Environment;

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

@@ -33,7 +33,6 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
     const hookBeforeRouteExecution = utils.pipe(allHooks, utils.A.map(({ beforeRouteExecution }) => beforeRouteExecution), utils.A.filter(utils.isType("function")), utils.forward);
     const hookBeforeSendResponse = utils.pipe(allHooks, utils.A.map(({ beforeSendResponse }) => beforeSendResponse), utils.A.filter(utils.isType("function")), utils.forward);
     const hookOnConstructRequest = utils.pipe(allHooks, utils.A.map(({ onConstructRequest }) => onConstructRequest), utils.A.filter(utils.isType("function")), utils.forward);
-    const hookParseBody = utils.pipe(allHooks, utils.A.map(({ parseBody }) => parseBody), utils.A.filter(utils.isType("function")), utils.forward);
     const hookError = utils.pipe(allHooks, utils.A.map(({ error }) => error), utils.A.filter(utils.isType("function")), utils.forward);
     const hookSendResponse = utils.pipe(allHooks, utils.A.map(({ sendResponse }) => sendResponse), utils.A.filter(utils.isType("function")), utils.forward);
     const hooks = {
@@ -52,7 +51,6 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 return newRequest;
             }
             : (params) => params.request,
-        parseBody: hook.buildHookBefore(hookParseBody),
         error: hook.buildHookErrorBefore(hookError),
         sendResponse: hook.buildHookAfter(hookSendResponse),
     };
@@ -75,15 +73,6 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 }
                 floor = result;
             }
-            const parseBodyResult = await hooks.parseBody({
-                request,
-                exit: hook.exitHookFunction,
-                next: hook.nextHookFunction,
-                response: hook.createHookResponse("parseBody"),
-            });
-            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 base.Response) {

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

@@ -31,7 +31,6 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
     const hookBeforeRouteExecution = pipe(allHooks, A.map(({ beforeRouteExecution }) => beforeRouteExecution), A.filter(isType("function")), forward);
     const hookBeforeSendResponse = pipe(allHooks, A.map(({ beforeSendResponse }) => beforeSendResponse), A.filter(isType("function")), forward);
     const hookOnConstructRequest = pipe(allHooks, A.map(({ onConstructRequest }) => onConstructRequest), A.filter(isType("function")), forward);
-    const hookParseBody = pipe(allHooks, A.map(({ parseBody }) => parseBody), A.filter(isType("function")), forward);
     const hookError = pipe(allHooks, A.map(({ error }) => error), A.filter(isType("function")), forward);
     const hookSendResponse = pipe(allHooks, A.map(({ sendResponse }) => sendResponse), A.filter(isType("function")), forward);
     const hooks = {
@@ -50,7 +49,6 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
                 return newRequest;
             }
             : (params) => params.request,
-        parseBody: buildHookBefore(hookParseBody),
         error: buildHookErrorBefore(hookError),
         sendResponse: buildHookAfter(hookSendResponse),
     };
@@ -73,15 +71,6 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
                 }
                 floor = result;
             }
-            const parseBodyResult = await hooks.parseBody({
-                request,
-                exit: exitHookFunction,
-                next: nextHookFunction,
-                response: createHookResponse("parseBody"),
-            });
-            if (parseBodyResult instanceof Response) {
-                return parseBodyResult;
-            }
             for (let index = 0; index < buildedSteps.length; index++) {
                 const result = await buildedSteps[index].buildedFunction(request, floor);
                 if (result instanceof Response) {

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

@@ -1,8 +1,8 @@
 import { HookResponse } from "../../response";
-import { type HookAfterSendResponse, type HookBeforeRouteExecution, type HookBeforeSendResponse, type HookError, type HookParseBody, type HookRouteLifeCycle, type HookSendResponse, type RouteHookErrorParams, type RouteHookParams, type RouteHookParamsAfter } from "../../route";
+import { type HookAfterSendResponse, type HookBeforeRouteExecution, type HookBeforeSendResponse, type HookError, 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("../../response").ResponseCode, string, unknown>>);
+export declare function buildHookBefore(hooks: (HookBeforeRouteExecution)[]): typeof exitHookFunction | ((params: RouteHookParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../response").ResponseCode, string, unknown>>);
 export declare function buildHookErrorBefore(hooks: HookError[]): typeof exitHookFunction | ((params: RouteHookErrorParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../response").ResponseCode, string, unknown>>);
 export declare function buildHookAfter(hooks: (HookBeforeSendResponse | HookSendResponse | HookAfterSendResponse)[]): typeof exitHookFunction | ((params: RouteHookParamsAfter) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown>>);
 export declare function createHookResponse(from: keyof HookRouteLifeCycle): RouteHookParams["response"];

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

@@ -10,8 +10,8 @@ export interface BuildStepResult {
     readonly buildedFunction: BuildedStepFunction;
     readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
 }
-export type BuildStepSuccessEither = E.EitherRight<"buildSuccess", BuildStepResult>;
-export type BuildStepNotSupportEither = E.EitherLeft<"stepNotSupport", Steps>;
+export type BuildStepSuccessEither = E.Right<"buildSuccess", BuildStepResult>;
+export type BuildStepNotSupportEither = E.Left<"stepNotSupport", Steps>;
 export interface StepFunctionBuilderParams {
     buildStep(element: Steps): Promise<BuildStepSuccessEither | BuildStepNotSupportEither>;
     success(result: BuildStepResult): BuildStepSuccessEither;

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

@@ -19,32 +19,29 @@ const defaultCutStepFunctionBuilder = create.createStepFunctionBuilder(cut.cutSt
         if (!currentContract) {
             throw new contract.ResponseContract.Error(information);
         }
-        const result = currentContract.body.parse(body);
-        if (utils.E.isLeft(result)) {
-            throw new contract.ResponseContract.Error(information, utils.unwrap(result));
-        }
         return new predicted.PredictedResponse(currentContract.code, currentContract.information, body);
     };
-    function treatResult(result, floor) {
-        if (cut.cutStepOutputKind.has(result)) {
-            return {
-                ...floor,
-                ...utils.unwrap(result),
-            };
-        }
-        return result;
-    }
     return success({
-        buildedFunction: (request, floor) => {
-            const result = cutFunction(floor, {
+        buildedFunction: async (request, floor) => {
+            const cutResult = await cutFunction(floor, {
                 request,
                 output,
                 response,
             });
-            if (result instanceof Promise) {
-                return result.then((awaitedResult) => treatResult(awaitedResult, floor));
+            if (cutResult instanceof predicted.PredictedResponse) {
+                const currentContract = preparedContractResponse[cutResult.information];
+                const resultBody = currentContract.body.isAsynchronous()
+                    ? await currentContract.body.asyncParse(cutResult.body)
+                    : currentContract.body.parse(cutResult.body);
+                if (utils.E.isLeft(resultBody)) {
+                    throw new contract.ResponseContract.Error(cutResult.information, utils.unwrap(resultBody));
+                }
+                return cutResult;
             }
-            return treatResult(result, floor);
+            return {
+                ...floor,
+                ...utils.unwrap(cutResult),
+            };
         },
         hooksRouteLifeCycle: [],
     });

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

@@ -17,32 +17,29 @@ const defaultCutStepFunctionBuilder = createStepFunctionBuilder(cutStepKind.has,
         if (!currentContract) {
             throw new ResponseContract.Error(information);
         }
-        const result = currentContract.body.parse(body);
-        if (E.isLeft(result)) {
-            throw new ResponseContract.Error(information, unwrap(result));
-        }
         return new PredictedResponse(currentContract.code, currentContract.information, body);
     };
-    function treatResult(result, floor) {
-        if (cutStepOutputKind.has(result)) {
-            return {
-                ...floor,
-                ...unwrap(result),
-            };
-        }
-        return result;
-    }
     return success({
-        buildedFunction: (request, floor) => {
-            const result = cutFunction(floor, {
+        buildedFunction: async (request, floor) => {
+            const cutResult = await cutFunction(floor, {
                 request,
                 output,
                 response,
             });
-            if (result instanceof Promise) {
-                return result.then((awaitedResult) => treatResult(awaitedResult, floor));
+            if (cutResult instanceof PredictedResponse) {
+                const currentContract = preparedContractResponse[cutResult.information];
+                const resultBody = currentContract.body.isAsynchronous()
+                    ? await currentContract.body.asyncParse(cutResult.body)
+                    : currentContract.body.parse(cutResult.body);
+                if (E.isLeft(resultBody)) {
+                    throw new ResponseContract.Error(cutResult.information, unwrap(resultBody));
+                }
+                return cutResult;
             }
-            return treatResult(result, floor);
+            return {
+                ...floor,
+                ...unwrap(cutResult),
+            };
         },
         hooksRouteLifeCycle: [],
     });

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

@@ -10,32 +10,56 @@ var predicted = require('../../../response/predicted.cjs');
 const defaultExtractStepFunctionBuilder = create.createStepFunctionBuilder(extract.extractStepKind.has, (step, { success, environment, defaultExtractContract }) => {
     const { shape, responseContract: stepResponseContract, } = step.definition;
     const responseContract = stepResponseContract ?? defaultExtractContract;
-    function getResponse(result, key, subKey) {
-        const response = new predicted.PredictedResponse(responseContract.code, responseContract.information, environment === "DEV"
-            ? utils.unwrap(result)
-            : undefined);
-        return subKey === undefined
-            ? response.setHeader("extract-key", `request.${key}`)
-            : response.setHeader("extract-key", `request.${key}.${subKey}`);
-    }
-    function treatResult(result, floor, key, subKey) {
-        if (utils.E.isLeft(result)) {
-            return getResponse(result, key, subKey);
+    function createExtractor(parser, key, subKey) {
+        const createResponse = environment === "DEV"
+            ? (result) => new predicted.PredictedResponse(responseContract.code, responseContract.information, result)
+            : () => new predicted.PredictedResponse(responseContract.code, responseContract.information, undefined);
+        const setHeader = subKey === undefined || key === "body"
+            ? (response) => response.setHeader("extract-key", `request.${key}`)
+            : (response) => response.setHeader("extract-key", `request.${key}.${subKey}`);
+        const getResponse = (result) => setHeader(createResponse(result));
+        const treatResult = (result, floor) => utils.E.isLeft(result)
+            ? getResponse(utils.unwrap(result))
+            : {
+                ...floor,
+                [subKey ?? key]: utils.unwrap(result),
+            };
+        const getValue = typeof subKey === "string"
+            ? (value) => value?.[subKey]
+            : utils.forward;
+        if (key === "body") {
+            const parseFunction = parser.isAsynchronous()
+                ? parser.asyncParse
+                : parser.parse;
+            return async (request, floor) => {
+                const bodyResult = await request.getBody();
+                if (utils.E.isLeft(bodyResult)) {
+                    return treatResult(bodyResult, floor);
+                }
+                const result = await parseFunction(getValue(utils.unwrap(bodyResult)));
+                return treatResult(result, floor);
+            };
+        }
+        if (parser.isAsynchronous()) {
+            const parseFunction = parser.asyncParse;
+            return async (request, floor) => {
+                const result = await parseFunction(getValue(request[key]));
+                return treatResult(result, floor);
+            };
         }
-        return {
-            ...floor,
-            [subKey ?? key]: utils.unwrap(result),
+        const parseFunction = parser.parse;
+        return (request, floor) => {
+            const result = parseFunction(getValue(request[key]));
+            return treatResult(result, floor);
         };
     }
-    const extractors = utils.A.reduce(utils.O.entries(shape), utils.A.reduceFrom([]), ({ lastValue, element: [key, value], next }) => next(utils.DP.dataParserKind.has(value)
-        ? utils.A.push(lastValue, (request, floor) => treatResult(value.parse(request[key]), floor, key))
-        : utils.pipe(value, utils.P.when(utils.isType("undefined"), utils.justReturn(lastValue)), utils.P.otherwise(utils.innerPipe(utils.O.entries, utils.A.map(([subKey, subValue]) => ((request, floor) => treatResult(subValue.parse(request[key]?.[subKey]), floor, key, subKey))), (subExtractor) => utils.A.concat(lastValue, subExtractor))))));
+    const extractors = utils.A.reduce(utils.O.entries(shape), utils.A.reduceFrom([]), ({ lastValue, element: [key, value], next, }) => utils.pipe(value, utils.P.when(utils.DP.dataParserKind.has, (value) => utils.A.push(lastValue, createExtractor(value, key, undefined))), utils.P.otherwise((value) => utils.pipe(value, utils.P.when(utils.isType("undefined"), utils.justReturn(lastValue)), utils.P.otherwise(utils.innerPipe(utils.O.entries, utils.A.map(([subKey, subValue]) => createExtractor(subValue, key, subKey)), (subExtractor) => utils.A.concat(lastValue, subExtractor))))), next));
     return success({
-        buildedFunction: (request, floor) => {
+        buildedFunction: async (request, floor) => {
             let newFloor = floor;
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let index = 0; index < extractors.length; index++) {
-                const result = extractors[index](request, newFloor);
+                const result = await extractors[index](request, newFloor);
                 if (result instanceof predicted.PredictedResponse) {
                     return result;
                 }

package/dist/core/functionsBuilders/steps/defaults/extractStep.d.ts

@@ -1 +1,2 @@
-export declare const defaultExtractStepFunctionBuilder: (step: import("../../../steps").Steps, params: import("..").StepFunctionBuilderParams) => import("@duplojs/utils").MaybePromise<import("..").BuildStepSuccessEither | import("..").BuildStepNotSupportEither>;
+import { type MaybePromise } from "@duplojs/utils";
+export declare const defaultExtractStepFunctionBuilder: (step: import("../../../steps").Steps, params: import("..").StepFunctionBuilderParams) => MaybePromise<import("..").BuildStepSuccessEither | import("..").BuildStepNotSupportEither>;