@duplojs/http 0.1.0

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

@@ -0,0 +1,62 @@
+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 { processStepKind } from '../../../steps/process.mjs';
+import '../../../steps/presetChecker.mjs';
+import { Response } from '../../../response/index.mjs';
+import { createStepFunctionBuilder } from '../create.mjs';
+import { E, pipe, P, or, isType, forward, A, G, unwrap } from '@duplojs/utils';
+
+function buildStepsFunction(steps, buildStep) {
+    return G.asyncReduce(steps, G.reduceFrom([]), async ({ lastValue, element: step, next, exit }) => {
+        const result = await buildStep(step);
+        if (E.isLeft(result)) {
+            return exit(result);
+        }
+        return next(A.push(lastValue, unwrap(result)));
+    });
+}
+const defaultProcessStepFunctionBuilder = createStepFunctionBuilder(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 (E.isLeft(maybeBuildedSteps)) {
+        return maybeBuildedSteps;
+    }
+    const buildedSteps = maybeBuildedSteps;
+    const getOptions = pipe(stepOptions ?? processOptions, P.when(or([
+        isType("object"),
+        isType("undefined"),
+    ]), (options) => (() => options)), P.otherwise(forward));
+    return success({
+        buildedFunction: async (request, floor) => {
+            let processFloor = { options: getOptions(floor) };
+            // eslint-disable-next-line @typescript-eslint/prefer-for-of
+            for (let index = 0; index < buildedSteps.length; index++) {
+                const result = await buildedSteps[index].buildedFunction(request, floor);
+                if (result instanceof 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,
+            ...A.flatMap(buildedSteps, ({ hooksRouteLifeCycle }) => hooksRouteLifeCycle),
+        ],
+    });
+});
+
+export { buildStepsFunction, defaultProcessStepFunctionBuilder };

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

@@ -0,0 +1,3 @@
+export * from "./create";
+export * from "./defaults";
+export * from "./build";

package/dist/core/hub/defaultExtractContract.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('../response/index.cjs');
+var contract = require('../response/contract.cjs');
+
+const defaultExtractContract = contract.ResponseContract.unprocessableContent("extract-error");
+
+exports.defaultExtractContract = defaultExtractContract;

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

@@ -0,0 +1,6 @@
+import { ResponseContract } from "../response";
+export declare const defaultExtractContract: NoInfer<ResponseContract.Contract<"422", "extract-error", import("@duplojs/utils/dataParser").DataParserEmpty<{
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+    readonly checkers: readonly [];
+}>>>;

package/dist/core/hub/defaultExtractContract.mjs

@@ -0,0 +1,6 @@
+import '../response/index.mjs';
+import { ResponseContract } from '../response/contract.mjs';
+
+const defaultExtractContract = ResponseContract.unprocessableContent("extract-error");
+
+export { defaultExtractContract };

package/dist/core/hub/defaultNotfoundHandler.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+require('../response/index.cjs');
+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 utils = require('@duplojs/utils');
+var contract = require('../response/contract.cjs');
+
+const defaultNotfoundHandler = handler.createHandlerStep({
+    responseContract: contract.ResponseContract.notFound("notfound-route", utils.DP.string()),
+    theFunction: (floor, { request, response }) => response("notfound-route", `${request.method}:${request.path}`),
+});
+
+exports.defaultNotfoundHandler = defaultNotfoundHandler;

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

@@ -0,0 +1,10 @@
+import { ResponseContract } from "../response";
+import { DP } from "@duplojs/utils";
+export declare const defaultNotfoundHandler: import("../steps").HandlerStep<{
+    responseContract: NoInfer<ResponseContract.Contract<"404", "notfound-route", DP.DataParserString<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>>;
+    theFunction: (floor: import("..").Floor, { request, response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").Response<import("../response").ResponseCode, string, unknown>>) => never;
+}>;

package/dist/core/hub/defaultNotfoundHandler.mjs

@@ -0,0 +1,18 @@
+import '../response/index.mjs';
+import '../steps/kind.mjs';
+import '../steps/identifier.mjs';
+import '../steps/checker.mjs';
+import '../steps/extract.mjs';
+import '../steps/cut.mjs';
+import { createHandlerStep } from '../steps/handler.mjs';
+import '../steps/process.mjs';
+import '../steps/presetChecker.mjs';
+import { DP } from '@duplojs/utils';
+import { ResponseContract } from '../response/contract.mjs';
+
+const defaultNotfoundHandler = createHandlerStep({
+    responseContract: ResponseContract.notFound("notfound-route", DP.string()),
+    theFunction: (floor, { request, response }) => response("notfound-route", `${request.method}:${request.path}`),
+});
+
+export { defaultNotfoundHandler };

package/dist/core/hub/hooks.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+
+const hookServerExitKind = kind.createCoreLibKind("server-hook-exit");
+const hookServerNextKind = kind.createCoreLibKind("server-hook-next");
+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));
+}
+const hookExit = hookServerExitKind.setTo({});
+const hookNext = hookServerNextKind.setTo({});
+function serverErrorExitHookFunction() {
+    return hookExit;
+}
+function serverErrorNextHookFunction() {
+    return hookNext;
+}
+async function launchHookServerError(hooks, params) {
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let index = 0; index < hooks.length; index++) {
+        const result = await hooks[index](params);
+        if (hookServerExitKind.has(result)) {
+            return;
+        }
+    }
+}
+
+exports.hookServerExitKind = hookServerExitKind;
+exports.hookServerNextKind = hookServerNextKind;
+exports.launchHookBeforeBuildRoute = launchHookBeforeBuildRoute;
+exports.launchHookServer = launchHookServer;
+exports.launchHookServerError = launchHookServerError;
+exports.serverErrorExitHookFunction = serverErrorExitHookFunction;
+exports.serverErrorNextHookFunction = serverErrorNextHookFunction;

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

@@ -0,0 +1,33 @@
+import { type Route } from "../route";
+import { type EscapeVoid, type Kind, type MaybePromise } from "@duplojs/utils";
+import { type Hub } from ".";
+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> {
+}
+export declare const hookServerNextKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-hook-next", unknown>>;
+export interface ServerHookNext extends Kind<typeof hookServerNextKind.definition> {
+}
+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 HookBeforeServerBuildRoute = (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 | HookBeforeServerBuildRoute>, hub: Hub, httpServerParams: HttpServerParams): Promise<Hub<import(".").HubConfig>>;
+export interface HttpServerErrorParams {
+    readonly error: unknown;
+    next(): ServerHookNext;
+    exit(): ServerHookExit;
+}
+export type HookServerError = (httpServerErrorParams: HttpServerErrorParams) => MaybePromise<ServerHookExit | ServerHookNext>;
+export declare function serverErrorExitHookFunction(): Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-hook-exit", unknown>, unknown>;
+export declare function serverErrorNextHookFunction(): Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-hook-next", unknown>, unknown>;
+export declare function launchHookServerError(hooks: readonly HookServerError[], params: HttpServerErrorParams): Promise<void>;
+export interface HookHubLifeCycle {
+    beforeBuildRoute?: HookBeforeBuildRoute;
+    beforeStartServer?: HookBeforeStartServer;
+    afterStartServer?: HookAfterStartServer;
+    beforeServerBuildRoute?: HookBeforeServerBuildRoute;
+    serverError?: HookServerError;
+}

package/dist/core/hub/hooks.mjs

@@ -0,0 +1,30 @@
+import { G } from '@duplojs/utils';
+import { createCoreLibKind } from '../kind.mjs';
+
+const hookServerExitKind = createCoreLibKind("server-hook-exit");
+const hookServerNextKind = createCoreLibKind("server-hook-next");
+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));
+}
+const hookExit = hookServerExitKind.setTo({});
+const hookNext = hookServerNextKind.setTo({});
+function serverErrorExitHookFunction() {
+    return hookExit;
+}
+function serverErrorNextHookFunction() {
+    return hookNext;
+}
+async function launchHookServerError(hooks, params) {
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let index = 0; index < hooks.length; index++) {
+        const result = await hooks[index](params);
+        if (hookServerExitKind.has(result)) {
+            return;
+        }
+    }
+}
+
+export { hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction };

package/dist/core/hub/index.cjs

@@ -0,0 +1,157 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var index = require('../route/index.cjs');
+var utils = require('@duplojs/utils');
+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 request = require('../request.cjs');
+var defaultNotfoundHandler = require('./defaultNotfoundHandler.cjs');
+var defaultExtractContract = require('./defaultExtractContract.cjs');
+var hooks = require('./hooks.cjs');
+
+const hubKind = kind.createCoreLibKind("hub");
+function createHub(config) {
+    return {
+        ...hubKind.addTo({}),
+        config,
+        plugins: [],
+        hooksHubLifeCycle: [],
+        hooksRouteLifeCycle: [],
+        routeFunctionBuilders: [],
+        routes: [],
+        stepFunctionBuilders: [],
+        notfoundHandler: defaultNotfoundHandler.defaultNotfoundHandler,
+        defaultExtractContract: defaultExtractContract.defaultExtractContract,
+        classRequest: request.Request,
+        addHubHooks(hook) {
+            return {
+                ...this,
+                hooksHubLifeCycle: utils.A.concat(this.hooksHubLifeCycle, utils.A.coalescing(hook)),
+            };
+        },
+        addRouteFunctionBuilder(functionBuilder) {
+            return {
+                ...this,
+                routeFunctionBuilders: utils.A.concat(this.routeFunctionBuilders, utils.A.coalescing(functionBuilder)),
+            };
+        },
+        addRouteHooks(hook) {
+            return {
+                ...this,
+                hooksRouteLifeCycle: utils.A.concat(this.hooksRouteLifeCycle, utils.A.coalescing(hook)),
+            };
+        },
+        addStepFunctionBuilder(hook) {
+            return {
+                ...this,
+                stepFunctionBuilders: utils.A.concat(this.stepFunctionBuilders, utils.A.coalescing(hook)),
+            };
+        },
+        plug(plugin) {
+            return {
+                ...this,
+                plugins: utils.A.push(this.plugins, typeof plugin === "function"
+                    ? plugin(this)
+                    : plugin),
+            };
+        },
+        register(route) {
+            return {
+                ...this,
+                routes: utils.A.concat(this.routes, utils.pipe(route, utils.P.when(index.routeKind.has, utils.A.coalescing), utils.P.when(utils.isType("iterable"), utils.A.from), utils.P.otherwise(utils.O.values))),
+            };
+        },
+        setDefaultExtractContract(defaultExtractContract) {
+            return {
+                ...this,
+                defaultExtractContract,
+            };
+        },
+        setNotfoundHandler(responseContract, theFunction) {
+            return {
+                ...this,
+                notfoundHandler: handler.createHandlerStep({
+                    responseContract,
+                    theFunction: (floor, params) => theFunction(params),
+                }),
+            };
+        },
+        aggregates() {
+            return utils.A.reduce(this.plugins, utils.A.reduceFrom({
+                hooksRouteLifeCycle: this.hooksRouteLifeCycle,
+                routeFunctionBuilders: this.routeFunctionBuilders,
+                stepFunctionBuilders: this.stepFunctionBuilders,
+                routes: this.routes,
+                hooksHubLifeCycle: this.hooksHubLifeCycle,
+            }), ({ lastValue, element: plugin, next, }) => next({
+                hooksRouteLifeCycle: plugin.hooksRouteLifeCycle
+                    ? utils.A.concat(lastValue.hooksRouteLifeCycle, plugin.hooksRouteLifeCycle)
+                    : lastValue.hooksRouteLifeCycle,
+                routeFunctionBuilders: plugin.routeFunctionBuilders
+                    ? utils.A.concat(lastValue.routeFunctionBuilders, plugin.routeFunctionBuilders)
+                    : lastValue.routeFunctionBuilders,
+                stepFunctionBuilders: plugin.stepFunctionBuilders
+                    ? utils.A.concat(lastValue.stepFunctionBuilders, plugin.stepFunctionBuilders)
+                    : lastValue.stepFunctionBuilders,
+                routes: plugin.routes
+                    ? utils.A.concat(lastValue.routes, plugin.routes)
+                    : lastValue.routes,
+                hooksHubLifeCycle: plugin.hooksHubLifeCycle
+                    ? utils.A.concat(lastValue.hooksHubLifeCycle, plugin.hooksHubLifeCycle)
+                    : lastValue.hooksHubLifeCycle,
+            }));
+        },
+        aggregatesRoutes() {
+            return utils.A.reduce(this.plugins, utils.A.reduceFrom(this.routes), ({ lastValue, element: { routes }, next, }) => routes
+                ? next(utils.A.concat(lastValue, routes))
+                : next(lastValue));
+        },
+        aggregatesRouteFunctionBuilders() {
+            return utils.A.reduce(this.plugins, utils.A.reduceFrom(this.routeFunctionBuilders), ({ lastValue, element: { routeFunctionBuilders }, next, }) => routeFunctionBuilders
+                ? next(utils.A.concat(lastValue, routeFunctionBuilders))
+                : next(lastValue));
+        },
+        aggregatesStepFunctionBuilders() {
+            return utils.A.reduce(this.plugins, utils.A.reduceFrom(this.stepFunctionBuilders), ({ lastValue, element: { stepFunctionBuilders }, next, }) => stepFunctionBuilders
+                ? next(utils.A.concat(lastValue, stepFunctionBuilders))
+                : next(lastValue));
+        },
+        aggregatesHooksHubLifeCycle(hookName) {
+            const hooks = utils.A.flatMap(this.hooksHubLifeCycle, (hooks) => hooks[hookName] ?? []);
+            return utils.A.reduce(this.plugins, utils.A.reduceFrom(hooks), ({ lastValue, element: { hooksHubLifeCycle }, next, }) => {
+                if (!hooksHubLifeCycle) {
+                    return next(lastValue);
+                }
+                return next(utils.A.concat(lastValue, utils.A.flatMap(hooksHubLifeCycle, (hooks) => hooks[hookName] ?? [])));
+            });
+        },
+        aggregatesHooksRouteLifeCycle(hookName) {
+            const hooks = utils.A.flatMap(this.hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? []);
+            return utils.A.reduce(this.plugins, utils.A.reduceFrom(hooks), ({ lastValue, element: { hooksRouteLifeCycle }, next, }) => {
+                if (!hooksRouteLifeCycle) {
+                    return next(lastValue);
+                }
+                return next(utils.A.concat(lastValue, utils.A.flatMap(hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? [])));
+            });
+        },
+    };
+}
+
+exports.defaultNotfoundHandler = defaultNotfoundHandler.defaultNotfoundHandler;
+exports.defaultExtractContract = defaultExtractContract.defaultExtractContract;
+exports.hookServerExitKind = hooks.hookServerExitKind;
+exports.hookServerNextKind = hooks.hookServerNextKind;
+exports.launchHookBeforeBuildRoute = hooks.launchHookBeforeBuildRoute;
+exports.launchHookServer = hooks.launchHookServer;
+exports.launchHookServerError = hooks.launchHookServerError;
+exports.serverErrorExitHookFunction = hooks.serverErrorExitHookFunction;
+exports.serverErrorNextHookFunction = hooks.serverErrorNextHookFunction;
+exports.createHub = createHub;
+exports.hubKind = hubKind;

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

@@ -0,0 +1,58 @@
+import { type Route, type HookRouteLifeCycle } from "../route";
+import { type Kind, type MaybeArray, type MaybePromise, type DP } from "@duplojs/utils";
+import { type HookHubLifeCycle } from "./hooks";
+import { type HandlerStepFunctionParams, type HandlerStep } from "../steps";
+import { Request } from "../request";
+import { type ClientErrorResponseCode, type ResponseContract } from "../response";
+import { type Environment } from "../types";
+import { type createStepFunctionBuilder } from "../functionsBuilders/steps";
+import { type createRouteFunctionBuilder } from "../functionsBuilders/route";
+export * from "./hooks";
+export * from "./defaultNotfoundHandler";
+export * from "./defaultExtractContract";
+export declare const hubKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hub", unknown>>;
+export interface HubConfig {
+    readonly environment: Environment;
+}
+export interface HubPlugin {
+    readonly name: string;
+    readonly hooksRouteLifeCycle?: readonly HookRouteLifeCycle[];
+    readonly hooksHubLifeCycle?: readonly HookHubLifeCycle[];
+    readonly routes?: readonly Route[];
+    readonly routeFunctionBuilders?: readonly ReturnType<typeof createRouteFunctionBuilder>[];
+    readonly stepFunctionBuilders?: readonly ReturnType<typeof createStepFunctionBuilder>[];
+}
+export interface HubAggregates {
+    readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
+    readonly hooksHubLifeCycle: readonly HookHubLifeCycle[];
+    readonly routes: readonly Route[];
+    readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
+    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
+}
+export interface Hub<GenericConfig extends HubConfig = HubConfig> extends Kind<typeof hubKind.definition> {
+    readonly config: GenericConfig;
+    readonly plugins: readonly HubPlugin[];
+    readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
+    readonly hooksHubLifeCycle: readonly HookHubLifeCycle[];
+    readonly routes: readonly Route[];
+    readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
+    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
+    readonly classRequest: typeof Request;
+    readonly notfoundHandler: HandlerStep;
+    readonly defaultExtractContract: ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>;
+    register(routes: Route | Iterable<Route> | Record<string, Route>): Hub<GenericConfig>;
+    addRouteFunctionBuilder(functionBuilder: MaybeArray<ReturnType<typeof createRouteFunctionBuilder>>): Hub<GenericConfig>;
+    addStepFunctionBuilder(functionBuilder: MaybeArray<ReturnType<typeof createStepFunctionBuilder>>): Hub<GenericConfig>;
+    addRouteHooks(hook: MaybeArray<HookRouteLifeCycle>): Hub<GenericConfig>;
+    addHubHooks(hook: MaybeArray<HookHubLifeCycle>): Hub<GenericConfig>;
+    plug(plugin: HubPlugin | ((self: this) => HubPlugin)): Hub<GenericConfig>;
+    setNotfoundHandler<GenericResponseContract extends ResponseContract.Contract, GenericResponse extends ResponseContract.Convert<GenericResponseContract>>(responseContract: GenericResponseContract, theFunction: (param: HandlerStepFunctionParams<Request, GenericResponse>) => MaybePromise<GenericResponse>): Hub<GenericConfig>;
+    setDefaultExtractContract(responseContract: this["defaultExtractContract"]): Hub<GenericConfig>;
+    aggregates(): HubAggregates;
+    aggregatesRoutes(): readonly Route[];
+    aggregatesRouteFunctionBuilders(): readonly ReturnType<typeof createRouteFunctionBuilder>[];
+    aggregatesStepFunctionBuilders(): readonly ReturnType<typeof createStepFunctionBuilder>[];
+    aggregatesHooksHubLifeCycle<GenericHookName extends keyof HookHubLifeCycle>(hookName: GenericHookName): readonly Exclude<HookHubLifeCycle[GenericHookName], undefined>[];
+    aggregatesHooksRouteLifeCycle<GenericHookName extends keyof HookRouteLifeCycle>(hookName: GenericHookName): readonly Exclude<HookRouteLifeCycle[GenericHookName], undefined>[];
+}
+export declare function createHub<const GenericConfig extends HubConfig>(config: GenericConfig): Hub<GenericConfig>;

package/dist/core/hub/index.mjs

@@ -0,0 +1,145 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { routeKind } from '../route/index.mjs';
+import { A, pipe, P, isType, O } from '@duplojs/utils';
+import '../steps/kind.mjs';
+import '../steps/identifier.mjs';
+import '../steps/checker.mjs';
+import '../steps/extract.mjs';
+import '../steps/cut.mjs';
+import { createHandlerStep } from '../steps/handler.mjs';
+import '../steps/process.mjs';
+import '../steps/presetChecker.mjs';
+import { Request } from '../request.mjs';
+import { defaultNotfoundHandler } from './defaultNotfoundHandler.mjs';
+import { defaultExtractContract } from './defaultExtractContract.mjs';
+export { hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hooks.mjs';
+
+const hubKind = createCoreLibKind("hub");
+function createHub(config) {
+    return {
+        ...hubKind.addTo({}),
+        config,
+        plugins: [],
+        hooksHubLifeCycle: [],
+        hooksRouteLifeCycle: [],
+        routeFunctionBuilders: [],
+        routes: [],
+        stepFunctionBuilders: [],
+        notfoundHandler: defaultNotfoundHandler,
+        defaultExtractContract,
+        classRequest: Request,
+        addHubHooks(hook) {
+            return {
+                ...this,
+                hooksHubLifeCycle: A.concat(this.hooksHubLifeCycle, A.coalescing(hook)),
+            };
+        },
+        addRouteFunctionBuilder(functionBuilder) {
+            return {
+                ...this,
+                routeFunctionBuilders: A.concat(this.routeFunctionBuilders, A.coalescing(functionBuilder)),
+            };
+        },
+        addRouteHooks(hook) {
+            return {
+                ...this,
+                hooksRouteLifeCycle: A.concat(this.hooksRouteLifeCycle, A.coalescing(hook)),
+            };
+        },
+        addStepFunctionBuilder(hook) {
+            return {
+                ...this,
+                stepFunctionBuilders: A.concat(this.stepFunctionBuilders, A.coalescing(hook)),
+            };
+        },
+        plug(plugin) {
+            return {
+                ...this,
+                plugins: A.push(this.plugins, typeof plugin === "function"
+                    ? plugin(this)
+                    : plugin),
+            };
+        },
+        register(route) {
+            return {
+                ...this,
+                routes: A.concat(this.routes, pipe(route, P.when(routeKind.has, A.coalescing), P.when(isType("iterable"), A.from), P.otherwise(O.values))),
+            };
+        },
+        setDefaultExtractContract(defaultExtractContract) {
+            return {
+                ...this,
+                defaultExtractContract,
+            };
+        },
+        setNotfoundHandler(responseContract, theFunction) {
+            return {
+                ...this,
+                notfoundHandler: createHandlerStep({
+                    responseContract,
+                    theFunction: (floor, params) => theFunction(params),
+                }),
+            };
+        },
+        aggregates() {
+            return A.reduce(this.plugins, A.reduceFrom({
+                hooksRouteLifeCycle: this.hooksRouteLifeCycle,
+                routeFunctionBuilders: this.routeFunctionBuilders,
+                stepFunctionBuilders: this.stepFunctionBuilders,
+                routes: this.routes,
+                hooksHubLifeCycle: this.hooksHubLifeCycle,
+            }), ({ lastValue, element: plugin, next, }) => next({
+                hooksRouteLifeCycle: plugin.hooksRouteLifeCycle
+                    ? A.concat(lastValue.hooksRouteLifeCycle, plugin.hooksRouteLifeCycle)
+                    : lastValue.hooksRouteLifeCycle,
+                routeFunctionBuilders: plugin.routeFunctionBuilders
+                    ? A.concat(lastValue.routeFunctionBuilders, plugin.routeFunctionBuilders)
+                    : lastValue.routeFunctionBuilders,
+                stepFunctionBuilders: plugin.stepFunctionBuilders
+                    ? A.concat(lastValue.stepFunctionBuilders, plugin.stepFunctionBuilders)
+                    : lastValue.stepFunctionBuilders,
+                routes: plugin.routes
+                    ? A.concat(lastValue.routes, plugin.routes)
+                    : lastValue.routes,
+                hooksHubLifeCycle: plugin.hooksHubLifeCycle
+                    ? A.concat(lastValue.hooksHubLifeCycle, plugin.hooksHubLifeCycle)
+                    : lastValue.hooksHubLifeCycle,
+            }));
+        },
+        aggregatesRoutes() {
+            return A.reduce(this.plugins, A.reduceFrom(this.routes), ({ lastValue, element: { routes }, next, }) => routes
+                ? next(A.concat(lastValue, routes))
+                : next(lastValue));
+        },
+        aggregatesRouteFunctionBuilders() {
+            return A.reduce(this.plugins, A.reduceFrom(this.routeFunctionBuilders), ({ lastValue, element: { routeFunctionBuilders }, next, }) => routeFunctionBuilders
+                ? next(A.concat(lastValue, routeFunctionBuilders))
+                : next(lastValue));
+        },
+        aggregatesStepFunctionBuilders() {
+            return A.reduce(this.plugins, A.reduceFrom(this.stepFunctionBuilders), ({ lastValue, element: { stepFunctionBuilders }, next, }) => stepFunctionBuilders
+                ? next(A.concat(lastValue, stepFunctionBuilders))
+                : next(lastValue));
+        },
+        aggregatesHooksHubLifeCycle(hookName) {
+            const hooks = A.flatMap(this.hooksHubLifeCycle, (hooks) => hooks[hookName] ?? []);
+            return A.reduce(this.plugins, A.reduceFrom(hooks), ({ lastValue, element: { hooksHubLifeCycle }, next, }) => {
+                if (!hooksHubLifeCycle) {
+                    return next(lastValue);
+                }
+                return next(A.concat(lastValue, A.flatMap(hooksHubLifeCycle, (hooks) => hooks[hookName] ?? [])));
+            });
+        },
+        aggregatesHooksRouteLifeCycle(hookName) {
+            const hooks = A.flatMap(this.hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? []);
+            return A.reduce(this.plugins, A.reduceFrom(hooks), ({ lastValue, element: { hooksRouteLifeCycle }, next, }) => {
+                if (!hooksRouteLifeCycle) {
+                    return next(lastValue);
+                }
+                return next(A.concat(lastValue, A.flatMap(hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? [])));
+            });
+        },
+    };
+}
+
+export { createHub, defaultExtractContract, defaultNotfoundHandler, hubKind };