@bejibun/core 0.1.72 → 0.1.73

package/CHANGELOG.md

@@ -3,6 +3,20 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [v0.1.73](https://github.com/Bejibun-Framework/bejibun-core/compare/v0.1.72...v0.1.73) - 2026-02-02
+
+### 🩹 Fixes
+- Fix infinite nested router - [#14](https://github.com/Bejibun-Framework/bejibun-core/pull/14)
+
+### 📖 Changes
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/Bejibun-Framework/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
 ## [v0.1.72](https://github.com/Bejibun-Framework/bejibun-core/compare/v0.1.71...v0.1.72) - 2026-01-29
 
 ### 🩹 Fixes

package/builders/RouterBuilder.d.ts

@@ -1,6 +1,6 @@
 import type { TFacilitator, TPaywall, TX402Config } from "@bejibun/x402";
 import type { IMiddleware } from "../types/middleware";
-import type { HandlerType, ResourceAction, Route, RouterGroup } from "../types/router";
+import type { HandlerType, RawsRoute, ResourceAction, Route, RouterGroup } from "../types/router";
 import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
 import BaseController from "../bases/BaseController";
 export interface ResourceOptions {
@@ -29,12 +29,13 @@ export default class RouterBuilder {
     trace(path: string, handler: string | HandlerType): Route;
     match(methods: Array<HttpMethodEnum>, path: string, handler: string | HandlerType): RouterGroup;
     any(path: string, handler: string | HandlerType): RouterGroup;
-    serialize(routes: Route | Array<Route> | RouterGroup | Array<RouterGroup>): RouterGroup;
+    serialize(routes: Route | Array<Route> | RouterGroup | Array<RouterGroup> | Array<RawsRoute>): RouterGroup;
     private mergeRoutes;
     private joinPaths;
     private resolveControllerString;
     private resolveIncludedActions;
     private hasRaw;
+    private hasRaws;
     private isMethodMap;
     private applyGroup;
 }

package/builders/RouterBuilder.js

@@ -31,9 +31,36 @@ export default class RouterBuilder {
     group(routes) {
         const rawGroups = [];
         let routeGroups = {};
+        if (this.hasRaws(routes)) {
+            const routeList = Array.isArray(routes) ? routes.flat() : [routes];
+            const routerGroups = routeList.filter((value) => !this.hasRaws(value) && !this.hasRaw(value));
+            const rawRoutes = routeList.filter((value) => this.hasRaws(value)).map((value) => value.raws).flat();
+            const newRoutes = {};
+            for (const route of rawRoutes) {
+                const middlewares = this.middlewares.concat(defineValue(route.raw.middlewares, []));
+                const effectiveNamespace = defineValue(this.baseNamespace, route.raw.namespace);
+                const cleanPath = this.joinPaths(defineValue(route.raw.prefix, this.basePath), route.raw.path);
+                let resolvedHandler = typeof route.raw.handler === "string" ?
+                    this.resolveControllerString(route.raw.handler, effectiveNamespace) :
+                    route.raw.handler;
+                for (const middleware of [...middlewares].reverse()) {
+                    resolvedHandler = middleware.handle(resolvedHandler);
+                }
+                if (isEmpty(newRoutes[cleanPath]))
+                    newRoutes[cleanPath] = {};
+                Object.assign(newRoutes[cleanPath], {
+                    [route.raw.method]: resolvedHandler
+                });
+                route.raw.middlewares = middlewares;
+                route.raw.namespace = effectiveNamespace;
+                route.raw.path = cleanPath;
+                rawGroups.push(route);
+            }
+            routeGroups = Object.assign({}, ...routerGroups.map((value) => this.applyGroup(value)), newRoutes);
+        }
         if (this.hasRaw(routes)) {
             const routeList = Array.isArray(routes) ? routes.flat() : [routes];
-            const routerGroups = routeList.filter((value) => !this.hasRaw(value));
+            const routerGroups = routeList.filter((value) => !this.hasRaws(value) && !this.hasRaw(value));
             const rawRoutes = routeList.filter((value) => this.hasRaw(value));
             const newRoutes = {};
             for (const route of rawRoutes) {
@@ -196,13 +223,15 @@ export default class RouterBuilder {
         if (Array.isArray(routes)) {
             if (this.hasRaw(routes))
                 routes = routes.map((value) => value.route);
+            if (this.hasRaws(routes))
+                routes = routes.map((value) => value.routes).flat();
         }
         else {
             if (this.hasRaw(routes))
                 routes = routes.route;
+            if (this.hasRaws(routes))
+                routes = routes.routes;
         }
-        if ("raws" in routes)
-            routes = routes.routes;
         const mergedRoutes = this.mergeRoutes(routes);
         if (Array.isArray(mergedRoutes))
             return Object.assign({}, ...mergedRoutes);
@@ -289,10 +318,17 @@ export default class RouterBuilder {
             typeof routes === "object" &&
             "raw" in routes);
     }
+    hasRaws(routes) {
+        if (Array.isArray(routes))
+            return routes.flat().some(route => isNotEmpty(route) && "raws" in route);
+        return (isNotEmpty(routes) &&
+            typeof routes === "object" &&
+            "raws" in routes);
+    }
     isMethodMap(value) {
         return (isNotEmpty(value) &&
             typeof value === "object" &&
-            Object.values(value).every(v => typeof v === "function"));
+            Object.values(value).every((v) => typeof v === "function"));
     }
     applyGroup(route) {
         if (isEmpty(route))
@@ -301,6 +337,7 @@ export default class RouterBuilder {
             const routeList = Array.isArray(route) ? route.flat() : [route];
             const rawRoutes = routeList.filter((value) => this.hasRaw(value));
             const newRoutes = {};
+            const rawGroups = [];
             for (const route of rawRoutes) {
                 const middlewares = route.raw.middlewares.concat(defineValue(this.middlewares, []));
                 const cleanPath = this.joinPaths(defineValue(route.raw.prefix, this.basePath), route.raw.path);
@@ -318,7 +355,16 @@ export default class RouterBuilder {
                 Object.assign(newRoutes[cleanPath], {
                     [route.raw.method]: resolvedHandler
                 });
+                route.raw.middlewares = middlewares;
+                route.raw.namespace = effectiveNamespace;
+                route.raw.path = cleanPath;
+                rawGroups.push(route);
             }
+            if (isNotEmpty(rawGroups))
+                return {
+                    raws: rawGroups,
+                    routes: newRoutes
+                };
             return newRoutes;
         }
         const result = {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.72",
+    "version": "0.1.73",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -16,7 +16,7 @@
         "@bejibun/logger": "^0.1.22",
         "@bejibun/utils": "^0.1.28",
         "@vinejs/vine": "^4.2.0",
-        "commander": "^14.0.2",
+        "commander": "^14.0.3",
         "luxon": "^3.7.2",
         "objection": "^3.1.5"
     },

package/types/router.d.ts

@@ -15,4 +15,8 @@ export type Route = {
     raw: RawRoute,
     route: RouterGroup
 };
+export type RawsRoute = {
+    raws: Array<Route>,
+    routes: Array<RouterGroup>
+};
 export type ResourceAction = "index" | "store" | "show" | "update" | "destroy";