feat(27): add router function builder

scripts/core/functionsBuilders/index.ts

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

scripts/core/functionsBuilders/route/build.ts

@@ -1,12 +1,15 @@
 import { E, G, unwrap } from "@duplojs/utils";
-import { buildStepFunction, type BuildStepFunctionParams } from "../steps";
+import { buildStepFunction, type createStepFunctionBuilder } from "../steps";
 import { type RouteFunctionBuilderParams, type BuildRouteNotSupportEither, type createRouteFunctionBuilder } from "./create";
 import { type HookRouteLifeCycle, type Route } from "@core/route";
 import { type ResponseContract } from "@core/response";
+import { type Environment } from "@core/types";
 
-export interface BuildRouteFunctionParams extends BuildStepFunctionParams {
+export interface BuildRouteFunctionParams {
 	readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
 	readonly globalHooksRouteLifeCycle: readonly HookRouteLifeCycle[];
+	readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
+	readonly environment: Environment;
 	readonly defaultExtractContract: ResponseContract.Contract;
 }
 

scripts/core/functionsBuilders/route/create.ts

@@ -1,17 +1,12 @@
 import { E, type MaybePromise } from "@duplojs/utils";
-import { type HookRouteLifeCycle, type Route } from "@core/route";
-import { type Request } from "@core/request";
+import { type BuildedRoute, type HookRouteLifeCycle, type Route } from "@core/route";
 import { type Environment } from "@core/types";
 import { type BuildStepSuccessEither, type BuildStepNotSupportEither } from "../steps";
 import { type Steps } from "@core/steps";
 import { type ResponseContract } from "@core/response";
 
-export type BuildedRouteFunction = (
-	request: Request,
-) => Promise<void>;
-
 export type BuildRouteSuccessEither<
-> = E.Right<"buildSuccess", BuildedRouteFunction>;
+> = E.Right<"buildSuccess", BuildedRoute>;
 
 export type BuildRouteNotSupportEither = E.Left<"routeNotSupport", Route>;
 
@@ -28,7 +23,7 @@ export interface RouteFunctionBuilderParams {
 	>;
 
 	success(
-		result: BuildedRouteFunction
+		result: BuildedRoute
 	): BuildRouteSuccessEither;
 
 	readonly defaultExtractContract: ResponseContract.Contract;

scripts/core/functionsBuilders/route/default.ts → scripts/core/functionsBuilders/route/default/index.ts

@@ -4,8 +4,10 @@ import { A, E, forward, isType, pipe } from "@duplojs/utils";
 import { HookResponse, Response } from "@core/response";
 import { type Request } from "@core/request";
 import { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, exitHookFunction, nextHookFunction } from "./hook";
-import { createRouteFunctionBuilder } from "./create";
-import { buildStepsFunction } from "../steps";
+import { createRouteFunctionBuilder } from "../create";
+import { buildStepsFunction } from "../../steps";
+
+export * from "./hook";
 
 export const defaultRouteFunctionBuilder = createRouteFunctionBuilder(
 	routeKind.has,

scripts/core/functionsBuilders/route/index.ts

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

scripts/core/functionsBuilders/router/build.ts

@@ -0,0 +1,23 @@
+import { type Environment } from "@core/types";
+import { type createRouterFunctionBuilder } from "./create";
+import { type Request } from "@core/request";
+import { type RouterElementWrapper } from "@core/router/types/routerElementWrapper";
+import { type RouterElementSystem } from "@core/router/types/routerElementSystem";
+
+export interface BuildRouterFunctionParams {
+	readonly routerFunctionBuilder: ReturnType<typeof createRouterFunctionBuilder>;
+	readonly environment: Environment;
+	readonly routerElementWrapper: RouterElementWrapper;
+	readonly classRequest: typeof Request;
+	readonly notfoundRouterElement: RouterElementSystem;
+	readonly malformedUrlRouterElement: RouterElementSystem;
+}
+
+export async function buildRouterFunction(
+	{
+		routerFunctionBuilder,
+		...params
+	}: BuildRouterFunctionParams,
+) {
+	return routerFunctionBuilder(params);
+}

scripts/core/functionsBuilders/router/create.ts

@@ -0,0 +1,24 @@
+import { type Request } from "@core/request";
+import { type BuildedRouter } from "@core/router";
+import { type RouterElementSystem } from "@core/router/types/routerElementSystem";
+import { type RouterElementWrapper } from "@core/router/types/routerElementWrapper";
+import { type Environment } from "@core/types";
+import { type MaybePromise } from "bun";
+
+export interface RouterFunctionBuilderParams {
+	readonly environment: Environment;
+	readonly routerElementWrapper: RouterElementWrapper;
+	readonly classRequest: typeof Request;
+	readonly notfoundRouterElement: RouterElementSystem;
+	readonly malformedUrlRouterElement: RouterElementSystem;
+}
+
+export type RouterFunctionBuilder = (
+	params: RouterFunctionBuilderParams
+) => MaybePromise<BuildedRouter>;
+
+export function createRouterFunctionBuilder(
+	theFunction: RouterFunctionBuilder,
+) {
+	return theFunction;
+}

scripts/core/functionsBuilders/router/default/index.ts

@@ -0,0 +1,69 @@
+import { decodeUrl } from "@core/decodeUrl";
+import { createRouterFunctionBuilder } from "../create";
+
+export const defaultRouterFunctionBuilder = createRouterFunctionBuilder(
+	({
+		routerElementWrapper,
+		malformedUrlRouterElement,
+		notfoundRouterElement,
+		classRequest,
+	}) => (initializationData) => {
+		const routerElements = routerElementWrapper[initializationData.method];
+		const decodedUrl = decodeUrl(initializationData.url);
+
+		if (!decodedUrl) {
+			return malformedUrlRouterElement.buildedRoute(
+				new classRequest({
+					...initializationData,
+					params: {},
+					path: "",
+					query: {},
+					matchedPath: null,
+					bodyReader: malformedUrlRouterElement.bodyReader,
+				}),
+			);
+		}
+
+		if (!routerElements) {
+			return notfoundRouterElement.buildedRoute(
+				new classRequest({
+					...initializationData,
+					...decodedUrl,
+					params: {},
+					matchedPath: null,
+					bodyReader: notfoundRouterElement.bodyReader,
+				}),
+			);
+		}
+
+		// eslint-disable-next-line @typescript-eslint/prefer-for-of
+		for (let index = 0; index < routerElements.length; index++) {
+			const routerElement = routerElements[index]!;
+			const result = routerElement.pattern.exec(decodedUrl.path);
+
+			if (!result) {
+				continue;
+			}
+
+			return routerElement.buildedRoute(
+				new classRequest({
+					...initializationData,
+					...decodedUrl,
+					params: result.groups ?? {},
+					matchedPath: routerElement.matchedPath,
+					bodyReader: routerElement.bodyReader,
+				}),
+			);
+		}
+
+		return notfoundRouterElement.buildedRoute(
+			new classRequest({
+				...initializationData,
+				...decodedUrl,
+				params: {},
+				matchedPath: null,
+				bodyReader: notfoundRouterElement.bodyReader,
+			}),
+		);
+	},
+);

scripts/core/functionsBuilders/router/index.ts

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

scripts/core/functionsBuilders/steps/build.ts

@@ -6,9 +6,7 @@ import { type ResponseContract } from "@core/response";
 
 export interface BuildStepFunctionParams {
 	readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
-
 	readonly environment: Environment;
-
 	readonly defaultExtractContract: ResponseContract.Contract;
 }
 

scripts/core/functionsBuilders/steps/create.ts

@@ -1,18 +1,11 @@
 import { E, type MaybePromise } from "@duplojs/utils";
-import { type Steps } from "../../steps/types";
-import { type Floor } from "@core/floor";
+import { type BuildedStep, type Steps } from "../../steps/types";
 import { type HookRouteLifeCycle } from "@core/route";
-import { type Request } from "@core/request";
-import { type ResponseContract, type Response } from "@core/response";
+import { type ResponseContract } from "@core/response";
 import { type Environment } from "@core/types";
 
-export type BuildedStepFunction = (
-	request: Request,
-	floor: Floor
-) => MaybePromise<Floor | Response>;
-
 export interface BuildStepResult {
-	readonly buildedFunction: BuildedStepFunction;
+	readonly buildedFunction: BuildedStep;
 	readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
 }
 

scripts/core/hub/hooks.ts

@@ -2,7 +2,7 @@ import { type Route } from "@core/route";
 import { type EscapeVoid, G, type Kind, type MaybePromise } from "@duplojs/utils";
 import { type Hub } from ".";
 import { createCoreLibKind } from "@core/kind";
-import { type RouterInitializationData } from "@core/router";
+import { type RouterParams } from "@core/router";
 import { type HttpServerParams } from "@core/types";
 
 export const hookServerExitKind = createCoreLibKind("server-hook-exit");
@@ -65,7 +65,7 @@ export interface HttpServerErrorParams {
 	readonly error: unknown;
 	next(): ServerHookNext;
 	exit(): ServerHookExit;
-	routerInitializationData: RouterInitializationData;
+	routerInitializationData: RouterParams;
 }
 
 export type HookServerError = (

scripts/core/hub/index.ts

@@ -13,6 +13,7 @@ import { type createRouteFunctionBuilder } from "@core/functionsBuilders/route";
 import { defaultBodyController } from "./defaultBodyController";
 import { defaultMalformedUrlHandler } from "./defaultMalformedUrlHandler";
 import { defaultEmptyReaderImplementation } from "./defaultEmptyReaderImplementation";
+import { type createRouterFunctionBuilder } from "@core/functionsBuilders/router";
 
 export * from "./hooks";
 export * from "./defaultNotfoundHandler";
@@ -51,6 +52,8 @@ export class Hub<
 
 	public routes = new Set<Route>();
 
+	public routerFunctionBuilder: ReturnType<typeof createRouterFunctionBuilder> | undefined = undefined;
+
 	public routeFunctionBuilders: ReturnType<typeof createRouteFunctionBuilder>[] = [];
 
 	public stepFunctionBuilders: ReturnType<typeof createStepFunctionBuilder>[] = [];
@@ -97,6 +100,13 @@ export class Hub<
 		return this;
 	}
 
+	public setRouterFunctionBuilder(
+		functionBuilder: ReturnType<typeof createRouterFunctionBuilder>,
+	) {
+		this.routerFunctionBuilder = functionBuilder;
+		return this;
+	}
+
 	public addRouteFunctionBuilder(
 		functionBuilder: MaybeArray<ReturnType<typeof createRouteFunctionBuilder>>,
 	) {

scripts/core/implementHttpServer.ts

@@ -1,6 +1,5 @@
-
 import { type Hub, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from "./hub";
-import { buildRouter, type RouterInitializationData } from "./router";
+import { createRouter, type RouterParams } from "./router";
 import { type AnyTuple, forward, type MaybePromise } from "@duplojs/utils";
 import { type HttpServerParams } from "./types";
 import { type HookRouteLifeCycle } from "./route";
@@ -18,10 +17,10 @@ export interface ImplementHttpServerParams {
 }
 
 export type ExecRouteSystem = (
-	routerInitializationData: RouterInitializationData,
+	routerInitializationData: RouterParams,
 	whenUncaughtError: (
 		error: unknown,
-		routerInitializationData: RouterInitializationData
+		routerInitializationData: RouterParams
 	) => MaybePromise<void>
 ) => Promise<void>;
 
@@ -47,7 +46,7 @@ export async function implementHttpServer<
 		...params.getInterfaceHooks(params),
 	]);
 
-	const router = await buildRouter(
+	const router = await createRouter(
 		params.hub,
 	);
 

scripts/core/router/buildSystemRoute.ts → scripts/core/router/createRouterElementSystem.ts

@@ -3,15 +3,16 @@ import { buildRouteFunction, type BuildRouteFunctionParams } from "@core/functio
 import { controlBodyAsEmpty } from "@core/request";
 import { createRoute } from "@core/route";
 import { RouterBuildError } from "./buildError";
-import { defaultEmptyReaderImplementation } from "@core/hub/defaultEmptyReaderImplementation";
+import { defaultEmptyReaderImplementation } from "@core/hub";
 import { type HandlerStep } from "@core/steps";
+import { type RouterElementSystem } from "./types";
 
-interface BuildSystemRouteParams {
+interface CreateRouterElementSystemParams {
 	handlerStep: HandlerStep;
 	buildParams: BuildRouteFunctionParams;
 }
 
-export async function buildSystemRoute(params: BuildSystemRouteParams) {
+export async function createRouterElementSystem(params: CreateRouterElementSystemParams): Promise<RouterElementSystem> {
 	const bodyController = controlBodyAsEmpty();
 	const bodyReader = bodyController.createReaderOrThrow(
 		defaultEmptyReaderImplementation,