@bejibun/core 0.1.64 → 0.1.66

package/CHANGELOG.md

@@ -3,6 +3,51 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [v0.1.66](https://github.com/crenata/bejibun-core/compare/v0.1.65...v0.1.66) - 2025-12-31
+
+### 🩹 Fixes
+
+### 📖 Changes
+#### What's New :
+- Added `Router.resource()`
+  
+Single line code that automatically generates a full set of CRUD.
+
+#### How to use?
+```ts
+import Router from "@bejibun/core/facades/Router";
+import YourController from "@/app/controllers/YourController";
+
+Router.resource("path", YourController);
+Router.resource("path", YourController, {
+    only: ["index", "store"] // "index" | "store" | "show" | "update" | "destroy"
+});
+Router.resource("path", YourController, {
+    except: ["index", "store"] // "index" | "store" | "show" | "update" | "destroy"
+});
+```
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/crenata/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
+## [v0.1.65](https://github.com/crenata/bejibun-core/compare/v0.1.64...v0.1.65) - 2025-12-29
+
+### 🩹 Fixes
+- Router namespace on group - [#6](https://github.com/crenata/bejibun-core/issues/6)
+
+### 📖 Changes
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/crenata/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
 ## [v0.1.64](https://github.com/crenata/bejibun-core/compare/v0.1.61...v0.1.64) - 2025-12-25
 
 ### 🩹 Fixes

package/builders/RouterBuilder.d.ts

@@ -1,7 +1,8 @@
 import type { TFacilitator, TPaywall, TX402Config } from "@bejibun/x402";
 import type { IMiddleware } from "../types/middleware";
-import type { HandlerType, ResourceAction, RouterGroup } from "../types/router";
+import type { HandlerType, ResourceAction, Route, RouterGroup } from "../types/router";
 import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
+import BaseController from "../bases/BaseController";
 export interface ResourceOptions {
     only?: Array<ResourceAction>;
     except?: Array<ResourceAction>;
@@ -14,21 +15,26 @@ export default class RouterBuilder {
     middleware(...middlewares: Array<IMiddleware>): RouterBuilder;
     namespace(baseNamespace: string): RouterBuilder;
     x402(config?: TX402Config, facilitatorConfig?: TFacilitator, paywallConfig?: TPaywall): RouterBuilder;
-    group(routes: RouterGroup | Array<RouterGroup>): RouterGroup;
-    resources(controller: Record<string, HandlerType>, options?: ResourceOptions): RouterGroup;
-    buildSingle(method: HttpMethodEnum, path: string, handler: string | HandlerType): RouterGroup;
-    connect(path: string, handler: string | HandlerType): RouterGroup;
-    delete(path: string, handler: string | HandlerType): RouterGroup;
-    get(path: string, handler: string | HandlerType): RouterGroup;
-    head(path: string, handler: string | HandlerType): RouterGroup;
-    options(path: string, handler: string | HandlerType): RouterGroup;
-    patch(path: string, handler: string | HandlerType): RouterGroup;
-    post(path: string, handler: string | HandlerType): RouterGroup;
-    put(path: string, handler: string | HandlerType): RouterGroup;
-    trace(path: string, handler: string | HandlerType): RouterGroup;
+    group(routes: Route | Array<Route> | RouterGroup): RouterGroup | Array<RouterGroup>;
+    resource(path: string, controller: typeof BaseController, options?: ResourceOptions): RouterGroup;
+    buildSingle(method: HttpMethodEnum, path: string, handler: string | HandlerType): Route;
+    connect(path: string, handler: string | HandlerType): Route;
+    delete(path: string, handler: string | HandlerType): Route;
+    get(path: string, handler: string | HandlerType): Route;
+    head(path: string, handler: string | HandlerType): Route;
+    options(path: string, handler: string | HandlerType): Route;
+    patch(path: string, handler: string | HandlerType): Route;
+    post(path: string, handler: string | HandlerType): Route;
+    put(path: string, handler: string | HandlerType): Route;
+    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;
+    private mergeRoutes;
     private joinPaths;
     private resolveControllerString;
     private resolveIncludedActions;
+    private hasRaw;
+    private isMethodMap;
+    private applyGroup;
 }

package/builders/RouterBuilder.js

@@ -1,5 +1,6 @@
 import App from "@bejibun/app";
-import { isEmpty, isModuleExists } from "@bejibun/utils";
+import Logger from "@bejibun/logger";
+import { defineValue, isEmpty, isModuleExists, isNotEmpty } from "@bejibun/utils";
 import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
 import Enum from "@bejibun/utils/facades/Enum";
 import path from "path";
@@ -28,67 +29,124 @@ export default class RouterBuilder {
         return this;
     }
     group(routes) {
-        const routeList = Array.isArray(routes) ? routes : [routes];
-        const newRoutes = {};
-        for (const route of routeList) {
-            for (const path in route) {
-                const cleanPath = this.joinPaths(this.basePath, path);
-                const routeHandlers = route[path];
-                const wrappedHandlers = {};
-                for (const method in routeHandlers) {
-                    let handler = routeHandlers[method];
-                    for (const middleware of this.middlewares) {
-                        handler = middleware.handle(handler);
-                    }
-                    wrappedHandlers[method] = handler;
+        const rawGroups = [];
+        let routeGroups = {};
+        if (this.hasRaw(routes)) {
+            const routeList = Array.isArray(routes) ? routes.flat() : [routes];
+            const routerGroups = routeList.filter((value) => !this.hasRaw(value));
+            const rawRoutes = routeList.filter((value) => this.hasRaw(value));
+            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], wrappedHandlers);
+                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 (isNotEmpty(routeGroups))
+            return {
+                raws: rawGroups,
+                routes: routeGroups
+            };
+        if (isEmpty(routes))
+            return {};
+        if (Array.isArray(routes)) {
+            return routes.map((value) => {
+                if (isNotEmpty(value.raws))
+                    return value.raws;
+                return value;
+            })
+                .flat()
+                .map((route) => this.applyGroup(route));
         }
-        return newRoutes;
+        return this.applyGroup(routes);
     }
-    resources(controller, options) {
+    resource(path, controller, options) {
+        const ClassController = new controller();
+        const cleanPath = this.joinPaths(this.basePath, path);
         const allRoutes = {
-            "": {
+            [cleanPath]: {
                 GET: "index",
                 POST: "store"
             },
-            ":id": {
+            [`${cleanPath}/:id`]: {
                 GET: "show",
                 PUT: "update",
                 DELETE: "destroy"
             }
         };
         const includedActions = this.resolveIncludedActions(options);
-        const filteredRoutes = {};
+        const raws = [];
+        const routes = {};
         for (const path in allRoutes) {
             const methods = allRoutes[path];
-            const methodHandlers = {};
+            const methodMap = {};
             for (const method in methods) {
                 const action = methods[method];
-                if (includedActions.has(action) && controller[action]) {
-                    methodHandlers[method] = controller[action];
+                let handler = ClassController[action];
+                if (includedActions.has(action) && isNotEmpty(handler)) {
+                    raws.push({
+                        raw: {
+                            prefix: this.basePath,
+                            middlewares: [],
+                            namespace: this.baseNamespace,
+                            method,
+                            path,
+                            handler
+                        },
+                        route: {
+                            [path]: {
+                                [method]: handler
+                            }
+                        }
+                    });
                 }
             }
-            if (Object.keys(methodHandlers).length > 0) {
-                filteredRoutes[path] = methodHandlers;
+            if (Object.keys(methodMap).length > 0) {
+                routes[path] = methodMap;
             }
         }
-        return this.group(filteredRoutes);
+        return this.applyGroup({
+            raws,
+            routes
+        });
     }
     buildSingle(method, path, handler) {
         const cleanPath = this.joinPaths(this.basePath, path);
         let resolvedHandler = typeof handler === "string" ?
             this.resolveControllerString(handler) :
             handler;
-        for (const middleware of this.middlewares) {
+        for (const middleware of [...this.middlewares].reverse()) {
             resolvedHandler = middleware.handle(resolvedHandler);
         }
         return {
-            [cleanPath]: {
-                [method]: resolvedHandler
+            raw: {
+                prefix: this.basePath,
+                middlewares: this.middlewares,
+                namespace: this.baseNamespace,
+                method,
+                path,
+                handler
+            },
+            route: {
+                [cleanPath]: {
+                    [method]: resolvedHandler
+                }
             }
         };
     }
@@ -122,7 +180,7 @@ export default class RouterBuilder {
     match(methods, path, handler) {
         const routeMap = {};
         for (const method of methods) {
-            const single = this.buildSingle(method, path, handler);
+            const single = this.buildSingle(method, path, handler).route;
             const fullPath = Object.keys(single)[0];
             const handlers = single[fullPath];
             if (isEmpty(routeMap[fullPath]))
@@ -134,18 +192,60 @@ export default class RouterBuilder {
     any(path, handler) {
         return this.match(Enum.setEnums(HttpMethodEnum).toArray().map((value) => value.value), path, handler);
     }
+    serialize(routes) {
+        if (Array.isArray(routes)) {
+            if (this.hasRaw(routes))
+                routes = routes.map((value) => value.route);
+        }
+        else {
+            if (this.hasRaw(routes))
+                routes = routes.route;
+        }
+        const mergedRoutes = this.mergeRoutes(routes);
+        if (Array.isArray(mergedRoutes))
+            return Object.assign({}, ...mergedRoutes);
+        return mergedRoutes;
+    }
+    mergeRoutes(routes) {
+        const merged = {};
+        const routeEntries = Array.isArray(routes) ?
+            routes :
+            Object.entries(routes).map(([path, methods]) => ({
+                [path]: methods
+            }));
+        for (const route of routeEntries) {
+            for (const [path, methods] of Object.entries(route)) {
+                if (isEmpty(merged[path]))
+                    merged[path] = {};
+                for (const [method, handler] of Object.entries(methods)) {
+                    if (isNotEmpty(merged[path][method]))
+                        Logger.setContext("Router").warn(`Duplicate route: ${method} ${path} - overwriting.`);
+                    merged[path][method] = handler;
+                }
+            }
+        }
+        return merged;
+    }
     joinPaths(base, path) {
         base = base.replace(/\/+$/, "");
         path = path.replace(/^\/+/, "");
         return `/${[base, path].filter(Boolean).join("/")}`;
     }
-    resolveControllerString(definition) {
+    resolveControllerString(definition, overrideNamespace) {
         const [controllerName, methodName] = definition.split("@");
         if (isEmpty(controllerName) || isEmpty(methodName)) {
             throw new RouterException(`Invalid router controller definition: ${definition}.`);
         }
-        const controllerPath = path.resolve(App.Path.rootPath(), this.baseNamespace);
-        const location = Bun.resolveSync(`./${controllerName}.ts`, controllerPath);
+        const controllerPath = path.resolve(App.Path.rootPath(), defineValue(overrideNamespace, this.baseNamespace));
+        let location = null;
+        try {
+            location = Bun.resolveSync(`./${controllerName}.ts`, controllerPath);
+        }
+        catch {
+            return async () => {
+                throw new RouterException(`Invalid router for controller location [${controllerPath}]`);
+            };
+        }
         let ControllerClass;
         try {
             ControllerClass = require(location).default;
@@ -180,4 +280,66 @@ export default class RouterBuilder {
         }
         return new Set(all);
     }
+    hasRaw(routes) {
+        if (Array.isArray(routes))
+            return routes.flat().some(route => isNotEmpty(route) && "raw" in route);
+        return (isNotEmpty(routes) &&
+            typeof routes === "object" &&
+            "raw" in routes);
+    }
+    isMethodMap(value) {
+        return (isNotEmpty(value) &&
+            typeof value === "object" &&
+            Object.values(value).every(v => typeof v === "function"));
+    }
+    applyGroup(route) {
+        if (isEmpty(route))
+            return route;
+        if (this.hasRaw(route)) {
+            const routeList = Array.isArray(route) ? route.flat() : [route];
+            const rawRoutes = routeList.filter((value) => this.hasRaw(value));
+            const newRoutes = {};
+            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);
+                const effectiveNamespace = defineValue(this.baseNamespace === "app/controllers" ?
+                    null :
+                    this.baseNamespace, route.raw.namespace);
+                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
+                });
+            }
+            return newRoutes;
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(route)) {
+            const newKey = key.startsWith("/") ? this.joinPaths(this.basePath, key) : key;
+            if (this.isMethodMap(value)) {
+                const wrappedMethods = {};
+                for (const [method, handler] of Object.entries(value)) {
+                    let resolvedHandler = handler;
+                    for (const middleware of [...this.middlewares].reverse()) {
+                        resolvedHandler = middleware.handle(resolvedHandler);
+                    }
+                    wrappedMethods[method] = resolvedHandler;
+                }
+                result[newKey] = wrappedMethods;
+                continue;
+            }
+            if (isNotEmpty(value) && typeof value === "object") {
+                result[newKey] = this.applyGroup(value);
+                continue;
+            }
+            result[newKey] = value;
+        }
+        return result;
+    }
 }

package/facades/Router.d.ts

@@ -1,23 +1,27 @@
+import type { ResourceOptions } from "../builders/RouterBuilder";
 import type { IMiddleware } from "../types/middleware";
 import type { HandlerType, RouterGroup } from "../types/router";
 import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
-import RouterBuilder, { ResourceOptions } from "../builders/RouterBuilder";
+import BaseController from "../bases/BaseController";
+import RouterBuilder from "../builders/RouterBuilder";
+import { Route } from "../types/router";
 export default class Router {
     static prefix(basePath: string): RouterBuilder;
     static middleware(...middlewares: Array<IMiddleware>): RouterBuilder;
     static namespace(baseNamespace: string): RouterBuilder;
     static x402(): RouterBuilder;
-    static resources(controller: Record<string, HandlerType>, options?: ResourceOptions): RouterGroup;
-    static group(routes: RouterGroup, prefix?: string, middlewares?: Array<IMiddleware>): RouterGroup;
-    static connect(path: string, handler: string | HandlerType): RouterGroup;
-    static delete(path: string, handler: string | HandlerType): RouterGroup;
-    static get(path: string, handler: string | HandlerType): RouterGroup;
-    static head(path: string, handler: string | HandlerType): RouterGroup;
-    static options(path: string, handler: string | HandlerType): RouterGroup;
-    static patch(path: string, handler: string | HandlerType): RouterGroup;
-    static post(path: string, handler: string | HandlerType): RouterGroup;
-    static put(path: string, handler: string | HandlerType): RouterGroup;
-    static trace(path: string, handler: string | HandlerType): RouterGroup;
+    static resource(path: string, controller: typeof BaseController, options?: ResourceOptions): RouterGroup;
+    static group(routes: Route | Array<Route> | RouterGroup): RouterGroup | Array<RouterGroup>;
+    static connect(path: string, handler: string | HandlerType): Route;
+    static delete(path: string, handler: string | HandlerType): Route;
+    static get(path: string, handler: string | HandlerType): Route;
+    static head(path: string, handler: string | HandlerType): Route;
+    static options(path: string, handler: string | HandlerType): Route;
+    static patch(path: string, handler: string | HandlerType): Route;
+    static post(path: string, handler: string | HandlerType): Route;
+    static put(path: string, handler: string | HandlerType): Route;
+    static trace(path: string, handler: string | HandlerType): Route;
     static match(methods: Array<HttpMethodEnum>, path: string, handler: string | HandlerType): RouterGroup;
     static any(path: string, handler: string | HandlerType): RouterGroup;
+    static serialize(routes: Route | Array<Route> | RouterGroup | Array<RouterGroup>): RouterGroup;
 }

package/facades/Router.js

@@ -12,16 +12,11 @@ export default class Router {
     static x402() {
         return new RouterBuilder().x402();
     }
-    static resources(controller, options) {
-        return new RouterBuilder().resources(controller, options);
+    static resource(path, controller, options) {
+        return new RouterBuilder().resource(path, controller, options);
     }
-    static group(routes, prefix, middlewares) {
-        const builder = new RouterBuilder();
-        if (prefix)
-            builder.prefix(prefix);
-        if (middlewares?.length)
-            builder.middleware(...middlewares);
-        return builder.group(routes);
+    static group(routes) {
+        return new RouterBuilder().group(routes);
     }
     static connect(path, handler) {
         return new RouterBuilder().connect(path, handler);
@@ -56,4 +51,7 @@ export default class Router {
     static any(path, handler) {
         return new RouterBuilder().any(path, handler);
     }
+    static serialize(routes) {
+        return new RouterBuilder().serialize(routes);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.64",
+    "version": "0.1.66",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",

package/server.d.ts

@@ -1 +1,6 @@
-export {};
+export default class Server {
+    private get exceptionHandler();
+    private get apiRoutes();
+    private get webRoutes();
+    run(): void;
+}

package/server.js

@@ -1,50 +1,59 @@
 import App from "@bejibun/app";
 import Logger from "@bejibun/logger";
+import { defineValue } from "@bejibun/utils";
 import RuntimeException from "./exceptions/RuntimeException";
 import Router from "./facades/Router";
 import MaintenanceMiddleware from "./middlewares/MaintenanceMiddleware";
 import RateLimiterMiddleware from "./middlewares/RateLimiterMiddleware";
 import(App.Path.rootPath("bootstrap.ts"));
-const exceptionHandlerPath = App.Path.appPath("exceptions/handler.ts");
-let ExceptionHandler;
-try {
-    ExceptionHandler = require(exceptionHandlerPath).default;
-}
-catch (error) {
-    throw new RuntimeException(`Missing exception handler class [${exceptionHandlerPath}].`, null, error.message);
-}
-const apiRoutesPath = App.Path.routesPath("api.ts");
-let ApiRoutes;
-try {
-    ApiRoutes = require(apiRoutesPath).default;
-}
-catch (error) {
-    throw new RuntimeException(`Missing api file on routes directory [${apiRoutesPath}].`, null, error.message);
-}
-const webRoutesPath = App.Path.routesPath("web.ts");
-let WebRoutes;
-try {
-    WebRoutes = require(webRoutesPath).default;
-}
-catch (error) {
-    throw new RuntimeException(`Missing web file on routes directory [${webRoutesPath}].`, null, error.message);
-}
-const server = Bun.serve({
-    development: Bun.env.NODE_ENV !== "production" && {
-        // Enable browser hot reloading in development
-        hmr: true,
-        // Echo console logs from the browser to the server
-        console: true
-    },
-    error: new ExceptionHandler().handle,
-    port: Bun.env.APP_PORT,
-    routes: {
-        "/": require(App.Path.publicPath("index.html")),
-        ...Router.middleware(new MaintenanceMiddleware(), new RateLimiterMiddleware()).group([
-            Router.namespace("app/exceptions").any("/*", "Handler@route"),
-            ApiRoutes,
-            WebRoutes
-        ])
+export default class Server {
+    get exceptionHandler() {
+        const exceptionHandlerPath = App.Path.appPath("exceptions/handler.ts");
+        try {
+            return require(exceptionHandlerPath).default;
+        }
+        catch (error) {
+            throw new RuntimeException(`Missing exception handler class [${exceptionHandlerPath}].`, null, error.message);
+        }
+    }
+    get apiRoutes() {
+        const apiRoutesPath = App.Path.routesPath("api.ts");
+        try {
+            return require(apiRoutesPath).default;
+        }
+        catch (error) {
+            throw new RuntimeException(`Missing api file on routes directory [${apiRoutesPath}].`, null, error.message);
+        }
+    }
+    get webRoutes() {
+        const webRoutesPath = App.Path.routesPath("web.ts");
+        try {
+            return require(webRoutesPath).default;
+        }
+        catch (error) {
+            throw new RuntimeException(`Missing web file on routes directory [${webRoutesPath}].`, null, error.message);
+        }
     }
-});
-Logger.setContext("APP").info(`🚀 Server running at ${server.url.origin}`);
+    run() {
+        const server = Bun.serve({
+            development: Bun.env.NODE_ENV !== "production" && {
+                // Enable browser hot reloading in development
+                hmr: true,
+                // Echo console logs from the browser to the server
+                console: true
+            },
+            error: new this.exceptionHandler().handle,
+            port: Bun.env.APP_PORT,
+            routes: {
+                "/": require(App.Path.publicPath("index.html")),
+                ...Object.assign({}, ...defineValue(Router.middleware(new MaintenanceMiddleware(), new RateLimiterMiddleware()).group([
+                    Router.namespace("app/exceptions").any("/*", "Handler@route"),
+                    Router.serialize(this.apiRoutes),
+                    Router.serialize(this.webRoutes)
+                ]), []))
+            }
+        });
+        Logger.setContext("APP").info(`🚀 Server running at ${server.url.origin}`);
+    }
+}
+new Server().run();

package/types/router.d.ts

@@ -1,3 +1,18 @@
+import {IMiddleware} from "../types/middleware";
+
 export type HandlerType = (request: Bun.BunRequest, server: Bun.Server) => Promise<Response>;
-export type RouterGroup = Record<string, Record<string, HandlerType>>;
+export type RouterMethodMap = Record<string, HandlerType>;
+export type RouterGroup = Record<string, RouterMethodMap | RouterGroup>;
+export type RawRoute = {
+    prefix: string,
+    middlewares: Array<IMiddleware>,
+    namespace: string,
+    method: string,
+    path: string,
+    handler: string | HandlerType
+};
+export type Route = {
+    raw: RawRoute,
+    route: RouterGroup
+};
 export type ResourceAction = "index" | "store" | "show" | "update" | "destroy";