@duplojs/http 0.1.0

package/dist/core/checker.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('./kind.cjs');
+
+const checkerOutputKind = kind.createCoreLibKind("checker-output");
+const checkerKind = kind.createCoreLibKind("checker");
+function createChecker(definition) {
+    return utils.pipe({ definition }, checkerKind.setTo);
+}
+
+exports.checkerKind = checkerKind;
+exports.checkerOutputKind = checkerOutputKind;
+exports.createChecker = createChecker;

package/dist/core/checker.d.ts

@@ -0,0 +1,22 @@
+import { type MaybePromise, type Kind } from "@duplojs/utils";
+export declare const checkerOutputKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-output", unknown>>;
+export interface CheckerFunctionOutput<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends Kind<typeof checkerOutputKind.definition> {
+    information: GenericInformation;
+    value: GenericValue;
+}
+export interface CheckerFunctionParams<GenericOptions extends Record<string, unknown> | undefined = Record<string, unknown> | undefined> {
+    options: GenericOptions;
+    output<GenericInformation extends string, GenericValue extends unknown>(information: GenericInformation, value: GenericValue): CheckerFunctionOutput<GenericInformation, GenericValue>;
+}
+export interface CheckerDefinition {
+    theFunction(input: unknown, params: CheckerFunctionParams): MaybePromise<CheckerFunctionOutput>;
+    readonly options?: Record<string, unknown>;
+}
+export declare const checkerKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker", unknown>>;
+export interface Checker<GenericDefinition extends CheckerDefinition = CheckerDefinition> extends Kind<typeof checkerKind.definition> {
+    readonly definition: GenericDefinition;
+}
+export declare function createChecker<GenericDefinition extends CheckerDefinition>(definition: GenericDefinition): Checker<GenericDefinition>;
+export type GetCheckerInput<GenericChecker extends Checker> = Parameters<GenericChecker["definition"]["theFunction"]>[0];
+export type GetCheckerResult<GenericChecker extends Checker> = ReturnType<GenericChecker["definition"]["theFunction"]>;
+export type GetCheckerOptions<GenericChecker extends Checker> = GenericChecker["definition"]["options"];

package/dist/core/checker.mjs

@@ -0,0 +1,10 @@
+import { pipe } from '@duplojs/utils';
+import { createCoreLibKind } from './kind.mjs';
+
+const checkerOutputKind = createCoreLibKind("checker-output");
+const checkerKind = createCoreLibKind("checker");
+function createChecker(definition) {
+    return pipe({ definition }, checkerKind.setTo);
+}
+
+export { checkerKind, checkerOutputKind, createChecker };

package/dist/core/floor.d.ts

@@ -0,0 +1 @@
+export type Floor = Record<string, unknown>;

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

@@ -0,0 +1,2 @@
+export * from "./route";
+export * from "./steps";

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

@@ -0,0 +1,40 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+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('../../response/index.cjs');
+require('../steps/defaults/cutStep.cjs');
+require('../steps/defaults/handlerStep.cjs');
+require('../steps/defaults/extractStep.cjs');
+require('../steps/defaults/processStep.cjs');
+var build = require('../steps/build.cjs');
+
+function buildRouteFunction(route, params) {
+    const functionParams = {
+        success(value) {
+            return utils.E.right("buildSuccess", value);
+        },
+        buildStep(step) {
+            return build.buildStepFunction(step, params);
+        },
+        environment: params.environment,
+        globalHooksRouteLifeCycle: params.globalHooksRouteLifeCycle,
+    };
+    return utils.G.asyncReduce(params.routeFunctionBuilders, utils.G.reduceFrom(utils.E.left("routeNotSupport", route)), async ({ element: functionBuilder, lastValue, next, exit, }) => {
+        const result = await functionBuilder(route, functionParams);
+        if (utils.E.isLeft(result)) {
+            return next(lastValue);
+        }
+        return exit(result);
+    });
+}
+
+exports.buildRouteFunction = buildRouteFunction;

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

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

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

@@ -0,0 +1,38 @@
+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 { buildStepFunction } from '../steps/build.mjs';
+
+function buildRouteFunction(route, params) {
+    const functionParams = {
+        success(value) {
+            return E.right("buildSuccess", value);
+        },
+        buildStep(step) {
+            return buildStepFunction(step, params);
+        },
+        environment: params.environment,
+        globalHooksRouteLifeCycle: params.globalHooksRouteLifeCycle,
+    };
+    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)) {
+            return next(lastValue);
+        }
+        return exit(result);
+    });
+}
+
+export { buildRouteFunction };

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

@@ -0,0 +1,11 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function createRouteFunctionBuilder(support, builder) {
+    return (route, params) => support(route)
+        ? builder(route, params)
+        : Promise.resolve(utils.E.left("routeNotSupport", route));
+}
+
+exports.createRouteFunctionBuilder = createRouteFunctionBuilder;

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

@@ -0,0 +1,16 @@
+import { E, type MaybePromise } from "@duplojs/utils";
+import { type HookRouteLifeCycle, type Route } from "../../route";
+import { type Request } from "../../request";
+import { type Environment } from "../../types";
+import { type BuildStepSuccessEither, type BuildStepNotSupportEither } from "../steps";
+import { type Steps } from "../../steps";
+export type BuildedRouteFunction = (request: Request) => Promise<void>;
+export type BuildRouteSuccessEither = E.EitherRight<"buildSuccess", BuildedRouteFunction>;
+export type BuildRouteNotSupportEither = E.EitherLeft<"routeNotSupport", Route>;
+export interface RouteFunctionBuilderParams {
+    readonly globalHooksRouteLifeCycle: readonly HookRouteLifeCycle[];
+    readonly environment: Environment;
+    buildStep(element: Steps): Promise<BuildStepSuccessEither | BuildStepNotSupportEither>;
+    success(result: BuildedRouteFunction): BuildRouteSuccessEither;
+}
+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/create.mjs

@@ -0,0 +1,9 @@
+import { E } from '@duplojs/utils';
+
+function createRouteFunctionBuilder(support, builder) {
+    return (route, params) => support(route)
+        ? builder(route, params)
+        : Promise.resolve(E.left("routeNotSupport", route));
+}
+
+export { createRouteFunctionBuilder };

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

@@ -0,0 +1,143 @@
+'use strict';
+
+var index = require('../../route/index.cjs');
+var utils = require('@duplojs/utils');
+var index$1 = 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');
+var processStep = require('../steps/defaults/processStep.cjs');
+var response = require('../../route/hooks/response.cjs');
+
+/* eslint-disable @typescript-eslint/prefer-for-of */
+const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {
+    const { hooks: routeHooks, preflightSteps, steps, } = route.definition;
+    const maybeBuildedSteps = await processStep.buildStepsFunction(steps, buildStep);
+    if (utils.E.isLeft(maybeBuildedSteps)) {
+        return maybeBuildedSteps;
+    }
+    const buildedSteps = maybeBuildedSteps;
+    const maybeBuildedPreFlightSteps = await processStep.buildStepsFunction(preflightSteps, buildStep);
+    if (utils.E.isLeft(maybeBuildedPreFlightSteps)) {
+        return maybeBuildedPreFlightSteps;
+    }
+    const buildedPreFlightSteps = maybeBuildedPreFlightSteps;
+    const allHooks = [
+        ...routeHooks,
+        ...utils.A.flatMap(buildedPreFlightSteps, ({ hooksRouteLifeCycle }) => hooksRouteLifeCycle),
+        ...utils.A.flatMap(buildedSteps, ({ hooksRouteLifeCycle }) => hooksRouteLifeCycle),
+        ...globalHooksRouteLifeCycle,
+    ];
+    const hookAfterSendResponse = utils.pipe(allHooks, utils.A.map(({ afterSendResponse }) => afterSendResponse), utils.A.filter(utils.isType("function")), utils.forward);
+    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 = {
+        afterSendResponse: hook.buildHookAfter(hookAfterSendResponse),
+        beforeRouteExecution: hook.buildHookBefore(hookBeforeRouteExecution),
+        beforeSendResponse: hook.buildHookAfter(hookBeforeSendResponse),
+        onConstructRequest: hookOnConstructRequest.length
+            ? async (params) => {
+                let newRequest = params.request;
+                for (let index = 0; index < hookOnConstructRequest.length; index++) {
+                    newRequest = await hookOnConstructRequest[index]({
+                        ...params,
+                        request: newRequest,
+                    });
+                }
+                return newRequest;
+            }
+            : (params) => params.request,
+        parseBody: hook.buildHookBefore(hookParseBody),
+        error: hook.buildHookErrorBefore(hookError),
+        sendResponse: hook.buildHookAfter(hookSendResponse),
+    };
+    async function routeExecution(request) {
+        try {
+            const beforeRouteExecutionResult = await hooks.beforeRouteExecution({
+                request,
+                exit: hook.exitHookFunction,
+                next: hook.nextHookFunction,
+                response: hook.createHookResponse("beforeRouteExecution"),
+            });
+            if (beforeRouteExecutionResult instanceof index$1.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) {
+                    return result;
+                }
+                floor = result;
+            }
+            const parseBodyResult = await hooks.parseBody({
+                request,
+                exit: hook.exitHookFunction,
+                next: hook.nextHookFunction,
+                response: hook.createHookResponse("parseBody"),
+            });
+            if (parseBodyResult instanceof index$1.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) {
+                    return result;
+                }
+                floor = result;
+            }
+            return new index$1.Response("500", "missing-response", undefined);
+        }
+        catch (error) {
+            const errorResult = await hooks.error({
+                request,
+                error,
+                exit: hook.exitHookFunction,
+                next: hook.nextHookFunction,
+                response: hook.createHookResponse("error"),
+            });
+            if (errorResult instanceof response.HookResponse) {
+                return errorResult;
+            }
+            return new index$1.Response("500", "server-error", error);
+        }
+    }
+    return success(async (request) => {
+        const currentRequest = await hooks.onConstructRequest({
+            request,
+            addRequestProperties: (newProperties) => {
+                for (const key in newProperties) {
+                    request[key] = newProperties[key];
+                }
+                return request;
+            },
+        });
+        const currentResponse = await routeExecution(currentRequest);
+        const afterHookParams = {
+            request: currentRequest,
+            currentResponse,
+            exit: hook.exitHookFunction,
+            next: hook.nextHookFunction,
+        };
+        await hooks.beforeSendResponse(afterHookParams);
+        await hooks.sendResponse(afterHookParams);
+        await hooks.afterSendResponse(afterHookParams);
+    });
+});
+
+exports.defaultRouteFunctionBuilder = defaultRouteFunctionBuilder;

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

@@ -0,0 +1 @@
+export declare const defaultRouteFunctionBuilder: (route: import("../../route").Route, params: import("./create").RouteFunctionBuilderParams) => import("@duplojs/utils").MaybePromise<import("./create").BuildRouteNotSupportEither | import("./create").BuildRouteSuccessEither | import("..").BuildStepNotSupportEither>;

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

@@ -0,0 +1,141 @@
+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 { 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 { buildStepsFunction } from '../steps/defaults/processStep.mjs';
+import { HookResponse } from '../../route/hooks/response.mjs';
+
+/* eslint-disable @typescript-eslint/prefer-for-of */
+const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {
+    const { hooks: routeHooks, preflightSteps, steps, } = route.definition;
+    const maybeBuildedSteps = await buildStepsFunction(steps, buildStep);
+    if (E.isLeft(maybeBuildedSteps)) {
+        return maybeBuildedSteps;
+    }
+    const buildedSteps = maybeBuildedSteps;
+    const maybeBuildedPreFlightSteps = await buildStepsFunction(preflightSteps, buildStep);
+    if (E.isLeft(maybeBuildedPreFlightSteps)) {
+        return maybeBuildedPreFlightSteps;
+    }
+    const buildedPreFlightSteps = maybeBuildedPreFlightSteps;
+    const allHooks = [
+        ...routeHooks,
+        ...A.flatMap(buildedPreFlightSteps, ({ hooksRouteLifeCycle }) => hooksRouteLifeCycle),
+        ...A.flatMap(buildedSteps, ({ hooksRouteLifeCycle }) => hooksRouteLifeCycle),
+        ...globalHooksRouteLifeCycle,
+    ];
+    const hookAfterSendResponse = pipe(allHooks, A.map(({ afterSendResponse }) => afterSendResponse), A.filter(isType("function")), forward);
+    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 = {
+        afterSendResponse: buildHookAfter(hookAfterSendResponse),
+        beforeRouteExecution: buildHookBefore(hookBeforeRouteExecution),
+        beforeSendResponse: buildHookAfter(hookBeforeSendResponse),
+        onConstructRequest: hookOnConstructRequest.length
+            ? async (params) => {
+                let newRequest = params.request;
+                for (let index = 0; index < hookOnConstructRequest.length; index++) {
+                    newRequest = await hookOnConstructRequest[index]({
+                        ...params,
+                        request: newRequest,
+                    });
+                }
+                return newRequest;
+            }
+            : (params) => params.request,
+        parseBody: buildHookBefore(hookParseBody),
+        error: buildHookErrorBefore(hookError),
+        sendResponse: buildHookAfter(hookSendResponse),
+    };
+    async function routeExecution(request) {
+        try {
+            const beforeRouteExecutionResult = await hooks.beforeRouteExecution({
+                request,
+                exit: exitHookFunction,
+                next: nextHookFunction,
+                response: createHookResponse("beforeRouteExecution"),
+            });
+            if (beforeRouteExecutionResult instanceof Response) {
+                return beforeRouteExecutionResult;
+            }
+            let floor = {};
+            for (let index = 0; index < buildedPreFlightSteps.length; index++) {
+                const result = await buildedPreFlightSteps[index].buildedFunction(request, floor);
+                if (result instanceof Response) {
+                    return result;
+                }
+                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) {
+                    return result;
+                }
+                floor = result;
+            }
+            return new Response("500", "missing-response", undefined);
+        }
+        catch (error) {
+            const errorResult = await hooks.error({
+                request,
+                error,
+                exit: exitHookFunction,
+                next: nextHookFunction,
+                response: createHookResponse("error"),
+            });
+            if (errorResult instanceof HookResponse) {
+                return errorResult;
+            }
+            return new Response("500", "server-error", error);
+        }
+    }
+    return success(async (request) => {
+        const currentRequest = await hooks.onConstructRequest({
+            request,
+            addRequestProperties: (newProperties) => {
+                for (const key in newProperties) {
+                    request[key] = newProperties[key];
+                }
+                return request;
+            },
+        });
+        const currentResponse = await routeExecution(currentRequest);
+        const afterHookParams = {
+            request: currentRequest,
+            currentResponse,
+            exit: exitHookFunction,
+            next: nextHookFunction,
+        };
+        await hooks.beforeSendResponse(afterHookParams);
+        await hooks.sendResponse(afterHookParams);
+        await hooks.afterSendResponse(afterHookParams);
+    });
+});
+
+export { defaultRouteFunctionBuilder };

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

@@ -0,0 +1,69 @@
+'use strict';
+
+require('../../route/index.cjs');
+var index = require('../../route/hooks/index.cjs');
+var response = require('../../route/hooks/response.cjs');
+
+/* eslint-disable @typescript-eslint/prefer-for-of */
+const hookExit = index.hookRouteExitKind.setTo({});
+const hookNext = index.hookRouteNextKind.setTo({});
+function exitHookFunction() {
+    return hookExit;
+}
+function nextHookFunction() {
+    return hookNext;
+}
+function buildHookBefore(hooks) {
+    if (!hooks.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) {
+                return result;
+            }
+        }
+        return hookNext;
+    };
+}
+function buildHookErrorBefore(hooks) {
+    if (!hooks.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) {
+                return result;
+            }
+        }
+        return hookNext;
+    };
+}
+function buildHookAfter(hooks) {
+    if (!hooks.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)) {
+                return result;
+            }
+        }
+        return hookNext;
+    };
+}
+function createHookResponse(from) {
+    return (code, information, body) => new response.HookResponse(from, code, information, body);
+}
+
+exports.buildHookAfter = buildHookAfter;
+exports.buildHookBefore = buildHookBefore;
+exports.buildHookErrorBefore = buildHookErrorBefore;
+exports.createHookResponse = createHookResponse;
+exports.exitHookFunction = exitHookFunction;
+exports.nextHookFunction = nextHookFunction;

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

@@ -0,0 +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 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

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

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

@@ -0,0 +1,4 @@
+export * from "./build";
+export * from "./create";
+export * from "./default";
+export * from "./hook";

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

@@ -0,0 +1,24 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function buildStepFunction(step, params) {
+    const functionParams = {
+        success(value) {
+            return utils.E.right("buildSuccess", value);
+        },
+        buildStep(step) {
+            return buildStepFunction(step, params);
+        },
+        environment: params.environment,
+    };
+    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)) {
+            return next(lastValue);
+        }
+        return exit(result);
+    });
+}
+
+exports.buildStepFunction = buildStepFunction;

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

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