@bejibun/core 0.1.53 → 0.1.55

package/CHANGELOG.md

@@ -3,6 +3,38 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [v0.1.55](https://github.com/crenata/bejibun-core/compare/v0.1.54...v0.1.55) - 2025-11-29
+
+### 🩹 Fixes
+- Body parser for multiple keys - [#2](https://github.com/crenata/bejibun-core/issues/2)
+- x402 on nester router - [#3](https://github.com/crenata/bejibun-core/issues/3)
+- Storage directory undefined - [#4](https://github.com/crenata/bejibun-core/issues/4)
+- Unknown actual error on runtime exception - [#5](https://github.com/crenata/bejibun-core/issues/5)
+
+### 📖 Changes
+- Storage adjustment: random string filename.
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/crenata/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
+## [v0.1.54](https://github.com/crenata/bejibun-core/compare/v0.1.53...v0.1.54) - 2025-11-28
+
+### 🩹 Fixes
+- Fix x402 middleware for optional
+
+### 📖 Changes
+
+### ❤️Contributors
+- Ghulje ([@ghulje](https://github.com/ghulje))
+
+**Full Changelog**: https://github.com/crenata/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
 ## [v0.1.53](https://github.com/crenata/bejibun-core/compare/v0.1.52...v0.1.53) - 2025-11-24
 
 ### 🩹 Fixes

package/bases/BaseController.js

@@ -111,7 +111,7 @@ export default class BaseController {
                     else if (Array.isArray(current[part]))
                         current[part].push(convertedValue);
                     else
-                        current[part] = [current[part], convertedValue];
+                        continue;
                 }
                 else {
                     const isArrayIndex = /^\d+$/.test(nextPart);

package/builders/RouterBuilder.d.ts

@@ -17,6 +17,15 @@ export default class 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;
     match(methods: Array<HttpMethodEnum>, path: string, handler: string | HandlerType): RouterGroup;
     any(path: string, handler: string | HandlerType): RouterGroup;
     private joinPaths;

package/builders/RouterBuilder.js

@@ -4,7 +4,6 @@ import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
 import Enum from "@bejibun/utils/facades/Enum";
 import path from "path";
 import RouterInvalidException from "../exceptions/RouterInvalidException";
-import X402Middleware from "../middlewares/X402Middleware";
 export default class RouterBuilder {
     basePath = "";
     middlewares = [];
@@ -24,6 +23,7 @@ export default class RouterBuilder {
     x402(config, facilitatorConfig, paywallConfig) {
         if (!isModuleExists("@bejibun/x402"))
             throw new RouterInvalidException("@bejibun/x402 is not installed.");
+        const X402Middleware = require("../middlewares/X402Middleware").default;
         this.middlewares.push(new X402Middleware(config, facilitatorConfig, paywallConfig));
         return this;
     }
@@ -92,6 +92,33 @@ export default class RouterBuilder {
             }
         };
     }
+    connect(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Connect, path, handler);
+    }
+    delete(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Delete, path, handler);
+    }
+    get(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Get, path, handler);
+    }
+    head(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Head, path, handler);
+    }
+    options(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Options, path, handler);
+    }
+    patch(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Patch, path, handler);
+    }
+    post(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Post, path, handler);
+    }
+    put(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Put, path, handler);
+    }
+    trace(path, handler) {
+        return this.buildSingle(HttpMethodEnum.Trace, path, handler);
+    }
     match(methods, path, handler) {
         const routeMap = {};
         for (const method of methods) {

package/builders/StorageBuilder.d.ts

@@ -0,0 +1,10 @@
+export default class StorageBuilder {
+    protected file: any;
+    protected directory?: string;
+    protected name?: string;
+    constructor();
+    setFile(file: any): StorageBuilder;
+    setDirectory(directory: string): StorageBuilder;
+    setName(name: string): StorageBuilder;
+    save(): Promise<any>;
+}

package/builders/StorageBuilder.js

@@ -0,0 +1,31 @@
+import App from "@bejibun/app";
+import { isEmpty } from "@bejibun/utils";
+import Luxon from "@bejibun/utils/facades/Luxon";
+import Str from "@bejibun/utils/facades/Str";
+import path from "path";
+export default class StorageBuilder {
+    file;
+    directory;
+    name;
+    constructor() {
+        this.name = "";
+        this.directory = "general";
+    }
+    setFile(file) {
+        this.file = file;
+        return this;
+    }
+    setDirectory(directory) {
+        this.directory = directory;
+        return this;
+    }
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    async save() {
+        if (isEmpty(this.name))
+            this.name = Str.random();
+        await Bun.write(App.Path.storagePath(`app/public/${this.directory}/${Luxon.DateTime.now().toUnixInteger()}-${this.name}${path.extname(this.file?.name)}`), this.file);
+    }
+}

package/exceptions/RuntimeException.d.ts

@@ -1,4 +1,4 @@
 export default class RuntimeException extends Error {
     code: number;
-    constructor(message?: string, code?: number);
+    constructor(message?: string, code?: number | undefined | null, stack?: string);
 }

package/exceptions/RuntimeException.js

@@ -2,10 +2,11 @@ import Logger from "@bejibun/logger";
 import { defineValue } from "@bejibun/utils";
 export default class RuntimeException extends Error {
     code;
-    constructor(message, code) {
+    constructor(message, code, stack) {
         super(message);
         this.name = "RuntimeException";
         this.code = defineValue(code, 500);
+        this.stack = stack;
         Logger.setContext(this.name).error(this.message).trace(this.stack);
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, RuntimeException);

package/facades/Router.js

@@ -1,4 +1,3 @@
-import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
 import RouterBuilder from "../builders/RouterBuilder";
 export default class Router {
     static prefix(basePath) {
@@ -25,31 +24,31 @@ export default class Router {
         return builder.group(routes);
     }
     static connect(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Connect, path, handler);
+        return new RouterBuilder().connect(path, handler);
     }
     static delete(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Delete, path, handler);
+        return new RouterBuilder().delete(path, handler);
     }
     static get(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Get, path, handler);
+        return new RouterBuilder().get(path, handler);
     }
     static head(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Head, path, handler);
+        return new RouterBuilder().head(path, handler);
     }
     static options(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Options, path, handler);
+        return new RouterBuilder().options(path, handler);
     }
     static patch(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Patch, path, handler);
+        return new RouterBuilder().patch(path, handler);
     }
     static post(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Post, path, handler);
+        return new RouterBuilder().post(path, handler);
     }
     static put(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Put, path, handler);
+        return new RouterBuilder().put(path, handler);
     }
     static trace(path, handler) {
-        return new RouterBuilder().buildSingle(HttpMethodEnum.Trace, path, handler);
+        return new RouterBuilder().trace(path, handler);
     }
     static match(methods, path, handler) {
         return new RouterBuilder().match(methods, path, handler);

package/facades/Storage.d.ts

@@ -0,0 +1,3 @@
+export default class Storage {
+    static save(file: any, directory?: string, name?: string): Promise<any>;
+}

package/facades/Storage.js

@@ -0,0 +1,12 @@
+import { isNotEmpty } from "@bejibun/utils";
+import StorageBuilder from "../builders/StorageBuilder";
+export default class Storage {
+    static async save(file, directory, name) {
+        const builder = new StorageBuilder().setFile(file);
+        if (isNotEmpty(directory))
+            builder.setDirectory(directory);
+        if (isNotEmpty(name))
+            builder.setName(name);
+        return await builder.save();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.53",
+    "version": "0.1.55",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -14,7 +14,7 @@
         "@bejibun/cors": "^0.1.16",
         "@bejibun/database": "^0.1.19",
         "@bejibun/logger": "^0.1.22",
-        "@bejibun/utils": "^0.1.21",
+        "@bejibun/utils": "^0.1.22",
         "@vinejs/vine": "^3.0.1",
         "commander": "^14.0.2",
         "luxon": "^3.7.2",

package/server.js

@@ -10,24 +10,24 @@ let ExceptionHandler;
 try {
     ExceptionHandler = require(exceptionHandlerPath).default;
 }
-catch {
-    throw new RuntimeException(`Missing exception handler class [${exceptionHandlerPath}].`);
+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 {
-    throw new RuntimeException(`Missing api file on routes directory [${apiRoutesPath}].`);
+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 {
-    throw new RuntimeException(`Missing web file on routes directory [${webRoutesPath}].`);
+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" && {