@bejibun/core 0.1.65 → 0.1.66

package/CHANGELOG.md

@@ -3,6 +3,37 @@ 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

package/builders/RouterBuilder.d.ts

@@ -2,6 +2,7 @@ import type { TFacilitator, TPaywall, TX402Config } from "@bejibun/x402";
 import type { IMiddleware } from "../types/middleware";
 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>;
@@ -15,7 +16,7 @@ export default class RouterBuilder {
     namespace(baseNamespace: string): RouterBuilder;
     x402(config?: TX402Config, facilitatorConfig?: TFacilitator, paywallConfig?: TPaywall): RouterBuilder;
     group(routes: Route | Array<Route> | RouterGroup): RouterGroup | Array<RouterGroup>;
-    resources(controller: Record<string, HandlerType>, options?: ResourceOptions): 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;
@@ -28,7 +29,8 @@ 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 | Array<RouterGroup>;
+    serialize(routes: Route | Array<Route> | RouterGroup | Array<RouterGroup>): RouterGroup;
+    private mergeRoutes;
     private joinPaths;
     private resolveControllerString;
     private resolveIncludedActions;

package/builders/RouterBuilder.js

@@ -1,4 +1,5 @@
 import App from "@bejibun/app";
+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";
@@ -65,43 +66,65 @@ export default class RouterBuilder {
         if (isEmpty(routes))
             return {};
         if (Array.isArray(routes)) {
-            if (routes.some(value => isNotEmpty(value.raws)))
-                return routes.map(value => value.raws)
-                    .flat()
-                    .map((route) => this.applyGroup(route));
-            return routes.map((route) => this.applyGroup(route));
+            return routes.map((value) => {
+                if (isNotEmpty(value.raws))
+                    return value.raws;
+                return value;
+            })
+                .flat()
+                .map((route) => this.applyGroup(route));
         }
         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 filteredRoutes;
-        // return this.group(filteredRoutes);
+        return this.applyGroup({
+            raws,
+            routes
+        });
     }
     buildSingle(method, path, handler) {
         const cleanPath = this.joinPaths(this.basePath, path);
@@ -172,13 +195,36 @@ export default class RouterBuilder {
     serialize(routes) {
         if (Array.isArray(routes)) {
             if (this.hasRaw(routes))
-                return routes.map((value) => value.route);
+                routes = routes.map((value) => value.route);
         }
         else {
             if (this.hasRaw(routes))
-                return routes.route;
+                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 routes;
+        return merged;
     }
     joinPaths(base, path) {
         base = base.replace(/\/+$/, "");

package/facades/Router.d.ts

@@ -2,6 +2,7 @@ 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 BaseController from "../bases/BaseController";
 import RouterBuilder from "../builders/RouterBuilder";
 import { Route } from "../types/router";
 export default class Router {
@@ -9,7 +10,7 @@ export default class Router {
     static middleware(...middlewares: Array<IMiddleware>): RouterBuilder;
     static namespace(baseNamespace: string): RouterBuilder;
     static x402(): RouterBuilder;
-    static resources(controller: Record<string, HandlerType>, options?: ResourceOptions): 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;
@@ -22,5 +23,5 @@ export default class Router {
     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 | Array<RouterGroup>;
+    static serialize(routes: Route | Array<Route> | RouterGroup | Array<RouterGroup>): RouterGroup;
 }

package/facades/Router.js

@@ -12,8 +12,8 @@ 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) {
         return new RouterBuilder().group(routes);

package/package.json

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

package/server.d.ts

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

package/server.js

@@ -34,12 +34,6 @@ export default class Server {
             throw new RuntimeException(`Missing web file on routes directory [${webRoutesPath}].`, null, error.message);
         }
     }
-    routeWrapper(routes) {
-        routes = Router.serialize(routes);
-        if (Array.isArray(routes))
-            return Object.assign({}, ...routes);
-        return routes;
-    }
     run() {
         const server = Bun.serve({
             development: Bun.env.NODE_ENV !== "production" && {
@@ -54,8 +48,8 @@ export default class Server {
                 "/": require(App.Path.publicPath("index.html")),
                 ...Object.assign({}, ...defineValue(Router.middleware(new MaintenanceMiddleware(), new RateLimiterMiddleware()).group([
                     Router.namespace("app/exceptions").any("/*", "Handler@route"),
-                    this.routeWrapper(this.apiRoutes),
-                    this.routeWrapper(this.webRoutes)
+                    Router.serialize(this.apiRoutes),
+                    Router.serialize(this.webRoutes)
                 ]), []))
             }
         });