@duplojs/http 0.6.1 → 0.7.0

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

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

@@ -1,5 +1,5 @@
 import '../../../steps/index.mjs';
-import { unwrap, E, A, O, DP, pipe, P, isType, justReturn, innerPipe } from '@duplojs/utils';
+import { unwrap, E, forward, A, O, pipe, P, DP, isType, justReturn, innerPipe } from '@duplojs/utils';
 import '../../../response/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import { extractStepKind } from '../../../steps/extract.mjs';
@@ -8,32 +8,56 @@ import { PredictedResponse } from '../../../response/predicted.mjs';
 const defaultExtractStepFunctionBuilder = createStepFunctionBuilder(extractStepKind.has, (step, { success, environment, defaultExtractContract }) => {
     const { shape, responseContract: stepResponseContract, } = step.definition;
     const responseContract = stepResponseContract ?? defaultExtractContract;
-    function getResponse(result, key, subKey) {
-        const response = new PredictedResponse(responseContract.code, responseContract.information, environment === "DEV"
-            ? 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 (E.isLeft(result)) {
-            return getResponse(result, key, subKey);
+    function createExtractor(parser, key, subKey) {
+        const createResponse = environment === "DEV"
+            ? (result) => new PredictedResponse(responseContract.code, responseContract.information, result)
+            : () => new 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) => E.isLeft(result)
+            ? getResponse(unwrap(result))
+            : {
+                ...floor,
+                [subKey ?? key]: unwrap(result),
+            };
+        const getValue = typeof subKey === "string"
+            ? (value) => value?.[subKey]
+            : forward;
+        if (key === "body") {
+            const parseFunction = parser.isAsynchronous()
+                ? parser.asyncParse
+                : parser.parse;
+            return async (request, floor) => {
+                const bodyResult = await request.getBody();
+                if (E.isLeft(bodyResult)) {
+                    return treatResult(bodyResult, floor);
+                }
+                const result = await parseFunction(getValue(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]: unwrap(result),
+        const parseFunction = parser.parse;
+        return (request, floor) => {
+            const result = parseFunction(getValue(request[key]));
+            return treatResult(result, floor);
         };
     }
-    const extractors = A.reduce(O.entries(shape), A.reduceFrom([]), ({ lastValue, element: [key, value], next }) => next(DP.dataParserKind.has(value)
-        ? A.push(lastValue, (request, floor) => treatResult(value.parse(request[key]), floor, key))
-        : pipe(value, P.when(isType("undefined"), justReturn(lastValue)), P.otherwise(innerPipe(O.entries, A.map(([subKey, subValue]) => ((request, floor) => treatResult(subValue.parse(request[key]?.[subKey]), floor, key, subKey))), (subExtractor) => A.concat(lastValue, subExtractor))))));
+    const extractors = A.reduce(O.entries(shape), A.reduceFrom([]), ({ lastValue, element: [key, value], next, }) => pipe(value, P.when(DP.dataParserKind.has, (value) => A.push(lastValue, createExtractor(value, key, undefined))), P.otherwise((value) => pipe(value, P.when(isType("undefined"), justReturn(lastValue)), P.otherwise(innerPipe(O.entries, A.map(([subKey, subValue]) => createExtractor(subValue, key, subKey)), (subExtractor) => 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 PredictedResponse) {
                     return result;
                 }

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

@@ -18,17 +18,23 @@ const defaultHandlerStepFunctionBuilder = create.createStepFunctionBuilder(handl
         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);
     };
     return success({
-        buildedFunction: (request, floor) => handlerFunction(floor, {
-            request,
-            response,
-        }),
+        buildedFunction: async (request, floor) => {
+            const predictedResponse = await handlerFunction(floor, {
+                request,
+                response,
+            });
+            const currentContract = preparedContractResponse[predictedResponse.information];
+            const result = currentContract.body.isAsynchronous()
+                ? await currentContract.body.asyncParse(predictedResponse.body)
+                : currentContract.body.parse(predictedResponse.body);
+            if (utils.E.isLeft(result)) {
+                throw new contract.ResponseContract.Error(predictedResponse.information, utils.unwrap(result));
+            }
+            return predictedResponse;
+        },
         hooksRouteLifeCycle: [],
     });
 });

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

@@ -16,17 +16,23 @@ const defaultHandlerStepFunctionBuilder = createStepFunctionBuilder(handlerStepK
         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);
     };
     return success({
-        buildedFunction: (request, floor) => handlerFunction(floor, {
-            request,
-            response,
-        }),
+        buildedFunction: async (request, floor) => {
+            const predictedResponse = await handlerFunction(floor, {
+                request,
+                response,
+            });
+            const currentContract = preparedContractResponse[predictedResponse.information];
+            const result = currentContract.body.isAsynchronous()
+                ? await currentContract.body.asyncParse(predictedResponse.body)
+                : currentContract.body.parse(predictedResponse.body);
+            if (E.isLeft(result)) {
+                throw new ResponseContract.Error(predictedResponse.information, unwrap(result));
+            }
+            return predictedResponse;
+        },
         hooksRouteLifeCycle: [],
     });
 });

package/dist/core/hub/defaultBodyController.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('../request/index.cjs');
+var text = require('../request/bodyController/text.cjs');
+
+const defaultBodyController = text.controlBodyAsText();
+
+exports.defaultBodyController = defaultBodyController;

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

@@ -0,0 +1 @@
+export declare const defaultBodyController: import("../request").BodyController<"text", import("../request").TextBodyReaderParams>;

package/dist/core/hub/defaultBodyController.mjs

@@ -0,0 +1,6 @@
+import '../request/index.mjs';
+import { controlBodyAsText } from '../request/bodyController/text.mjs';
+
+const defaultBodyController = controlBodyAsText();
+
+export { defaultBodyController };

package/dist/core/hub/hooks.cjs

@@ -9,7 +9,9 @@ async function launchHookBeforeBuildRoute(hooks, route) {
     return utils.G.asyncReduce(hooks, utils.G.reduceFrom(route), async ({ element: hook, lastValue, next, }) => next(await hook(lastValue)));
 }
 async function launchHookServer(hooks, hub, httpServerParams) {
-    return utils.G.asyncReduce(hooks, utils.G.reduceFrom(hub), async ({ element: hook, lastValue, next, }) => next((await hook(lastValue, httpServerParams)) ?? lastValue));
+    for (const hook of hooks) {
+        await hook(hub, httpServerParams);
+    }
 }
 const hookExit = hookServerExitKind.setTo({});
 const hookNext = hookServerNextKind.setTo({});

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

@@ -2,6 +2,7 @@ import { type Route } from "../route";
 import { type EscapeVoid, type Kind, type MaybePromise } from "@duplojs/utils";
 import { type Hub } from ".";
 import { type RouterInitializationData } from "../router";
+import { type HttpServerParams } from "../types";
 export declare const hookServerExitKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-hook-exit", unknown>>;
 export interface ServerHookExit extends Kind<typeof hookServerExitKind.definition> {
 }
@@ -10,12 +11,10 @@ export interface ServerHookNext extends Kind<typeof hookServerNextKind.definitio
 }
 export type HookBeforeBuildRoute = (route: Route) => MaybePromise<Route>;
 export declare function launchHookBeforeBuildRoute(hooks: Iterable<HookBeforeBuildRoute>, route: Route): Promise<Route<import("../route").RouteDefinition>>;
-export interface HttpServerParams {
-}
 export type HookBeforeServerBuildRoutes = (hub: Hub, httpServerParams: HttpServerParams) => MaybePromise<Hub | EscapeVoid>;
 export type HookBeforeStartServer = (hub: Hub, httpServerParams: HttpServerParams) => MaybePromise<Hub | EscapeVoid>;
 export type HookAfterStartServer = (hub: Hub, httpServerParams: HttpServerParams) => MaybePromise<Hub | EscapeVoid>;
-export declare function launchHookServer(hooks: Iterable<HookBeforeStartServer | HookAfterStartServer | HookBeforeServerBuildRoutes>, hub: Hub, httpServerParams: HttpServerParams): Promise<Hub<import(".").HubConfig>>;
+export declare function launchHookServer(hooks: Iterable<HookBeforeStartServer | HookAfterStartServer | HookBeforeServerBuildRoutes>, hub: Hub, httpServerParams: HttpServerParams): Promise<void>;
 export interface HttpServerErrorParams {
     readonly error: unknown;
     next(): ServerHookNext;

package/dist/core/hub/hooks.mjs

@@ -7,7 +7,9 @@ async function launchHookBeforeBuildRoute(hooks, route) {
     return G.asyncReduce(hooks, G.reduceFrom(route), async ({ element: hook, lastValue, next, }) => next(await hook(lastValue)));
 }
 async function launchHookServer(hooks, hub, httpServerParams) {
-    return G.asyncReduce(hooks, G.reduceFrom(hub), async ({ element: hook, lastValue, next, }) => next((await hook(lastValue, httpServerParams)) ?? lastValue));
+    for (const hook of hooks) {
+        await hook(hub, httpServerParams);
+    }
 }
 const hookExit = hookServerExitKind.setTo({});
 const hookNext = hookServerNextKind.setTo({});