@duplojs/http 0.1.0

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { E, type MaybePromise } from "@duplojs/utils";
+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 Environment } from "../../types";
+export type BuildedStepFunction = (request: Request, floor: Floor) => MaybePromise<Floor | Response>;
+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 interface StepFunctionBuilderParams {
+    buildStep(element: Steps): Promise<BuildStepSuccessEither | BuildStepNotSupportEither>;
+    success(result: BuildStepResult): BuildStepSuccessEither;
+    readonly environment: Environment;
+}
+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/create.mjs

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

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

@@ -0,0 +1,73 @@
+'use strict';
+
+var checker$1 = require('../../../checker.cjs');
+var create = require('../create.cjs');
+require('../../../steps/kind.cjs');
+require('../../../steps/identifier.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');
+
+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 }) => ({
+        checkerOptions: definition.checker.definition.options,
+        checkerFunction: definition.checker.definition.theFunction,
+        input: definition.input,
+        responseContract: definition.responseContract,
+        stepResult: definition.result,
+        indexing: definition.indexing,
+        stepOptions: definition.options,
+    })), utils.P.when(presetChecker.presetCheckerStepKind.has, ({ definition }) => ({
+        checkerOptions: definition.presetChecker.definition.checker.definition.options,
+        checkerFunction: definition.presetChecker.definition.checker.definition.theFunction,
+        input: definition.input,
+        responseContract: definition.presetChecker.definition.responseContract,
+        stepResult: definition.presetChecker.definition.result,
+        indexing: definition.presetChecker.definition.indexing,
+        stepOptions: definition.presetChecker.definition.options,
+    })), utils.P.exhaustive);
+    const getOptions = utils.pipe(stepOptions ?? checkerOptions, utils.P.when(utils.or([
+        utils.isType("object"),
+        utils.isType("undefined"),
+    ]), (options) => (() => options)), utils.P.otherwise(utils.forward));
+    const output = (information, value) => checker$1.checkerOutputKind.setTo({
+        information,
+        value,
+    });
+    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);
+    }
+    function treatResult(output, floor) {
+        if (!expectedResult(output.information)) {
+            return getResponse();
+        }
+        if (indexing) {
+            return {
+                ...floor,
+                [indexing]: output.value,
+            };
+        }
+        return floor;
+    }
+    return success({
+        buildedFunction: (_request, floor) => {
+            const result = checkerFunction(input(floor), {
+                options: getOptions(floor),
+                output,
+            });
+            if (result instanceof Promise) {
+                return result.then((awaitedResult) => treatResult(awaitedResult, floor));
+            }
+            return treatResult(result, floor);
+        },
+        hooksRouteLifeCycle: [],
+    });
+});
+
+exports.defaultCheckerStepFunctionBuilder = defaultCheckerStepFunctionBuilder;

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

@@ -0,0 +1 @@
+export declare const defaultCheckerStepFunctionBuilder: (step: import("../../../steps").Steps, params: import("..").StepFunctionBuilderParams) => import("@duplojs/utils").MaybePromise<import("..").BuildStepSuccessEither | import("..").BuildStepNotSupportEither>;

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

@@ -0,0 +1,71 @@
+import { checkerOutputKind } from '../../../checker.mjs';
+import { createStepFunctionBuilder } from '../create.mjs';
+import '../../../steps/kind.mjs';
+import '../../../steps/identifier.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';
+
+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 }) => ({
+        checkerOptions: definition.checker.definition.options,
+        checkerFunction: definition.checker.definition.theFunction,
+        input: definition.input,
+        responseContract: definition.responseContract,
+        stepResult: definition.result,
+        indexing: definition.indexing,
+        stepOptions: definition.options,
+    })), P.when(presetCheckerStepKind.has, ({ definition }) => ({
+        checkerOptions: definition.presetChecker.definition.checker.definition.options,
+        checkerFunction: definition.presetChecker.definition.checker.definition.theFunction,
+        input: definition.input,
+        responseContract: definition.presetChecker.definition.responseContract,
+        stepResult: definition.presetChecker.definition.result,
+        indexing: definition.presetChecker.definition.indexing,
+        stepOptions: definition.presetChecker.definition.options,
+    })), P.exhaustive);
+    const getOptions = pipe(stepOptions ?? checkerOptions, P.when(or([
+        isType("object"),
+        isType("undefined"),
+    ]), (options) => (() => options)), P.otherwise(forward));
+    const output = (information, value) => checkerOutputKind.setTo({
+        information,
+        value,
+    });
+    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);
+    }
+    function treatResult(output, floor) {
+        if (!expectedResult(output.information)) {
+            return getResponse();
+        }
+        if (indexing) {
+            return {
+                ...floor,
+                [indexing]: output.value,
+            };
+        }
+        return floor;
+    }
+    return success({
+        buildedFunction: (_request, floor) => {
+            const result = checkerFunction(input(floor), {
+                options: getOptions(floor),
+                output,
+            });
+            if (result instanceof Promise) {
+                return result.then((awaitedResult) => treatResult(awaitedResult, floor));
+            }
+            return treatResult(result, floor);
+        },
+        hooksRouteLifeCycle: [],
+    });
+});
+
+export { defaultCheckerStepFunctionBuilder };

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

@@ -0,0 +1,58 @@
+'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');
+var create = require('../create.cjs');
+var utils = require('@duplojs/utils');
+var index = require('../../../response/index.cjs');
+var contract = require('../../../response/contract.cjs');
+
+const defaultCutStepFunctionBuilder = create.createStepFunctionBuilder(cut.cutStepKind.has, (step, { success }) => {
+    const { responseContract, theFunction: cutFunction, } = step.definition;
+    const output = (data) => cut.cutStepOutputKind.setTo(utils.wrapValue(data ?? {}));
+    const preparedContractResponse = utils.A.reduce(utils.A.coalescing(responseContract), utils.A.reduceFrom({}), ({ element, lastValue, nextWithObject }) => nextWithObject(lastValue, {
+        [element.information]: element,
+    }));
+    const response = (information, body) => {
+        const currentContract = preparedContractResponse[information];
+        if (!currentContract) {
+            throw new contract.ResponseContract.Error(information);
+        }
+        const result = currentContract.schema.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);
+    };
+    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, {
+                request,
+                output,
+                response,
+            });
+            if (result instanceof Promise) {
+                return result.then((awaitedResult) => treatResult(awaitedResult, floor));
+            }
+            return treatResult(result, floor);
+        },
+        hooksRouteLifeCycle: [],
+    });
+});
+
+exports.defaultCutStepFunctionBuilder = defaultCutStepFunctionBuilder;

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

@@ -0,0 +1 @@
+export declare const defaultCutStepFunctionBuilder: (step: import("../../../steps").Steps, params: import("..").StepFunctionBuilderParams) => import("@duplojs/utils").MaybePromise<import("..").BuildStepSuccessEither | import("..").BuildStepNotSupportEither>;

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

@@ -0,0 +1,56 @@
+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 { createStepFunctionBuilder } from '../create.mjs';
+import { A, wrapValue, E, unwrap } from '@duplojs/utils';
+import { Response } from '../../../response/index.mjs';
+import { ResponseContract } from '../../../response/contract.mjs';
+
+const defaultCutStepFunctionBuilder = createStepFunctionBuilder(cutStepKind.has, (step, { success }) => {
+    const { responseContract, theFunction: cutFunction, } = step.definition;
+    const output = (data) => cutStepOutputKind.setTo(wrapValue(data ?? {}));
+    const preparedContractResponse = A.reduce(A.coalescing(responseContract), A.reduceFrom({}), ({ element, lastValue, nextWithObject }) => nextWithObject(lastValue, {
+        [element.information]: element,
+    }));
+    const response = (information, body) => {
+        const currentContract = preparedContractResponse[information];
+        if (!currentContract) {
+            throw new ResponseContract.Error(information);
+        }
+        const result = currentContract.schema.parse(body);
+        if (E.isLeft(result)) {
+            throw new ResponseContract.Error(information, unwrap(result));
+        }
+        return new Response(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, {
+                request,
+                output,
+                response,
+            });
+            if (result instanceof Promise) {
+                return result.then((awaitedResult) => treatResult(awaitedResult, floor));
+            }
+            return treatResult(result, floor);
+        },
+        hooksRouteLifeCycle: [],
+    });
+});
+
+export { defaultCutStepFunctionBuilder };

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

@@ -0,0 +1,57 @@
+'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');
+var utils = require('@duplojs/utils');
+var index = require('../../../response/index.cjs');
+var create = require('../create.cjs');
+var contract = require('../../../response/contract.cjs');
+
+const defaultExtractStepFunctionBuilder = create.createStepFunctionBuilder(extract.extractStepKind.has, (step, { success, environment }) => {
+    const { shape, responseContract: stepResponseContract, } = step.definition;
+    const responseContract = stepResponseContract ?? contract.ResponseContract
+        .unprocessableContent("extract-error");
+    function getResponse(result, key, subKey) {
+        const response = new index.Response(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);
+        }
+        return {
+            ...floor,
+            [subKey ?? key]: utils.unwrap(result),
+        };
+    }
+    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))))));
+    return success({
+        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) {
+                    return result;
+                }
+                newFloor = result;
+            }
+            return newFloor;
+        },
+        hooksRouteLifeCycle: [],
+    });
+});
+
+exports.defaultExtractStepFunctionBuilder = defaultExtractStepFunctionBuilder;

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

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

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

@@ -0,0 +1,55 @@
+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 { createStepFunctionBuilder } from '../create.mjs';
+import { ResponseContract } from '../../../response/contract.mjs';
+
+const defaultExtractStepFunctionBuilder = createStepFunctionBuilder(extractStepKind.has, (step, { success, environment }) => {
+    const { shape, responseContract: stepResponseContract, } = step.definition;
+    const responseContract = stepResponseContract ?? ResponseContract
+        .unprocessableContent("extract-error");
+    function getResponse(result, key, subKey) {
+        const response = new Response(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);
+        }
+        return {
+            ...floor,
+            [subKey ?? key]: unwrap(result),
+        };
+    }
+    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))))));
+    return success({
+        buildedFunction: (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);
+                if (result instanceof Response) {
+                    return result;
+                }
+                newFloor = result;
+            }
+            return newFloor;
+        },
+        hooksRouteLifeCycle: [],
+    });
+});
+
+export { defaultExtractStepFunctionBuilder };

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

@@ -0,0 +1,41 @@
+'use strict';
+
+require('../../../steps/kind.cjs');
+require('../../../steps/identifier.cjs');
+require('../../../steps/checker.cjs');
+require('../../../steps/extract.cjs');
+require('../../../steps/cut.cjs');
+var handler = require('../../../steps/handler.cjs');
+require('../../../steps/process.cjs');
+require('../../../steps/presetChecker.cjs');
+var create = require('../create.cjs');
+var utils = require('@duplojs/utils');
+var index = require('../../../response/index.cjs');
+var contract = require('../../../response/contract.cjs');
+
+const defaultHandlerStepFunctionBuilder = create.createStepFunctionBuilder(handler.handlerStepKind.has, (step, { success }) => {
+    const { responseContract, theFunction: handlerFunction, } = step.definition;
+    const preparedContractResponse = utils.A.reduce(utils.A.coalescing(responseContract), utils.A.reduceFrom({}), ({ element, lastValue, nextWithObject }) => nextWithObject(lastValue, {
+        [element.information]: element,
+    }));
+    const response = (information, body) => {
+        const currentContract = preparedContractResponse[information];
+        if (!currentContract) {
+            throw new contract.ResponseContract.Error(information);
+        }
+        const result = currentContract.schema.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 success({
+        buildedFunction: (request, floor) => handlerFunction(floor, {
+            request,
+            response,
+        }),
+        hooksRouteLifeCycle: [],
+    });
+});
+
+exports.defaultHandlerStepFunctionBuilder = defaultHandlerStepFunctionBuilder;

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

@@ -0,0 +1 @@
+export declare const defaultHandlerStepFunctionBuilder: (step: import("../../../steps").Steps, params: import("..").StepFunctionBuilderParams) => import("@duplojs/utils").MaybePromise<import("..").BuildStepSuccessEither | import("..").BuildStepNotSupportEither>;

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

@@ -0,0 +1,39 @@
+import '../../../steps/kind.mjs';
+import '../../../steps/identifier.mjs';
+import '../../../steps/checker.mjs';
+import '../../../steps/extract.mjs';
+import '../../../steps/cut.mjs';
+import { handlerStepKind } from '../../../steps/handler.mjs';
+import '../../../steps/process.mjs';
+import '../../../steps/presetChecker.mjs';
+import { createStepFunctionBuilder } from '../create.mjs';
+import { A, E, unwrap } from '@duplojs/utils';
+import { Response } from '../../../response/index.mjs';
+import { ResponseContract } from '../../../response/contract.mjs';
+
+const defaultHandlerStepFunctionBuilder = createStepFunctionBuilder(handlerStepKind.has, (step, { success }) => {
+    const { responseContract, theFunction: handlerFunction, } = step.definition;
+    const preparedContractResponse = A.reduce(A.coalescing(responseContract), A.reduceFrom({}), ({ element, lastValue, nextWithObject }) => nextWithObject(lastValue, {
+        [element.information]: element,
+    }));
+    const response = (information, body) => {
+        const currentContract = preparedContractResponse[information];
+        if (!currentContract) {
+            throw new ResponseContract.Error(information);
+        }
+        const result = currentContract.schema.parse(body);
+        if (E.isLeft(result)) {
+            throw new ResponseContract.Error(information, unwrap(result));
+        }
+        return new Response(currentContract.code, currentContract.information, body);
+    };
+    return success({
+        buildedFunction: (request, floor) => handlerFunction(floor, {
+            request,
+            response,
+        }),
+        hooksRouteLifeCycle: [],
+    });
+});
+
+export { defaultHandlerStepFunctionBuilder };

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

@@ -0,0 +1,5 @@
+export * from "./checkerStep";
+export * from "./cutStep";
+export * from "./handlerStep";
+export * from "./extractStep";
+export * from "./processStep";

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

@@ -0,0 +1,65 @@
+'use strict';
+
+require('../../../steps/kind.cjs');
+require('../../../steps/identifier.cjs');
+require('../../../steps/checker.cjs');
+require('../../../steps/extract.cjs');
+require('../../../steps/cut.cjs');
+require('../../../steps/handler.cjs');
+var process = require('../../../steps/process.cjs');
+require('../../../steps/presetChecker.cjs');
+var index = require('../../../response/index.cjs');
+var create = require('../create.cjs');
+var utils = require('@duplojs/utils');
+
+function buildStepsFunction(steps, buildStep) {
+    return utils.G.asyncReduce(steps, utils.G.reduceFrom([]), async ({ lastValue, element: step, next, exit }) => {
+        const result = await buildStep(step);
+        if (utils.E.isLeft(result)) {
+            return exit(result);
+        }
+        return next(utils.A.push(lastValue, utils.unwrap(result)));
+    });
+}
+const defaultProcessStepFunctionBuilder = create.createStepFunctionBuilder(process.processStepKind.has, async (step, { success, buildStep }) => {
+    const { process, imports, options: stepOptions, } = step.definition;
+    const { steps, hooks: processHook, options: processOptions, } = process.definition;
+    const maybeBuildedSteps = await buildStepsFunction(steps, buildStep);
+    if (utils.E.isLeft(maybeBuildedSteps)) {
+        return maybeBuildedSteps;
+    }
+    const buildedSteps = maybeBuildedSteps;
+    const getOptions = utils.pipe(stepOptions ?? processOptions, utils.P.when(utils.or([
+        utils.isType("object"),
+        utils.isType("undefined"),
+    ]), (options) => (() => options)), utils.P.otherwise(utils.forward));
+    return success({
+        buildedFunction: async (request, floor) => {
+            let processFloor = { options: getOptions(floor) };
+            // eslint-disable-next-line @typescript-eslint/prefer-for-of
+            for (let index$1 = 0; index$1 < buildedSteps.length; index$1++) {
+                const result = await buildedSteps[index$1].buildedFunction(request, floor);
+                if (result instanceof index.Response) {
+                    return result;
+                }
+                processFloor = result;
+            }
+            if (imports) {
+                const newFloor = { ...floor };
+                // eslint-disable-next-line @typescript-eslint/prefer-for-of
+                for (let index = 0; index < imports.length; index++) {
+                    newFloor[imports[index]] = processFloor[imports[index]];
+                }
+                return newFloor;
+            }
+            return floor;
+        },
+        hooksRouteLifeCycle: [
+            ...processHook,
+            ...utils.A.flatMap(buildedSteps, ({ hooksRouteLifeCycle }) => hooksRouteLifeCycle),
+        ],
+    });
+});
+
+exports.buildStepsFunction = buildStepsFunction;
+exports.defaultProcessStepFunctionBuilder = defaultProcessStepFunctionBuilder;

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

@@ -0,0 +1,4 @@
+import { type Steps } from "../../../steps";
+import { type BuildStepResult, type StepFunctionBuilderParams } from "../create";
+export declare function buildStepsFunction(steps: readonly Steps[], buildStep: StepFunctionBuilderParams["buildStep"]): Promise<import("..").BuildStepNotSupportEither | BuildStepResult[]>;
+export declare const defaultProcessStepFunctionBuilder: (step: Steps, params: StepFunctionBuilderParams) => import("@duplojs/utils").MaybePromise<import("..").BuildStepSuccessEither | import("..").BuildStepNotSupportEither>;