@bejibun/core 0.1.54 → 0.1.56

package/CHANGELOG.md

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

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

@@ -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.js

@@ -1,6 +1,7 @@
 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;
@@ -8,6 +9,7 @@ export default class StorageBuilder {
     name;
     constructor() {
         this.name = "";
+        this.directory = "general";
     }
     setFile(file) {
         this.file = file;
@@ -23,7 +25,7 @@ export default class StorageBuilder {
     }
     async save() {
         if (isEmpty(this.name))
-            this.name = `${Luxon.DateTime.now().toUnixInteger()}-${Math.random().toString(36).substring(2, 2 + 16)}`;
-        await Bun.write(App.Path.storagePath(`app/public/${this.directory}/${this.name}${path.extname(this.file?.name)}`), this.file);
+            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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.54",
+    "version": "0.1.56",
     "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" && {

package/utils/vines/exists.js

@@ -4,6 +4,8 @@ import BaseModel from "../../bases/BaseModel";
 const exists = async (value, options, field) => {
     if (!field.isValid)
         return;
+    if (options.nullable)
+        return;
     const column = defineValue(options.column, field.name);
     let query = options.table;
     if (options.withTrashed)
@@ -16,10 +18,10 @@ const exists = async (value, options, field) => {
 };
 const existsRule = vine.createRule(exists, { isAsync: true });
 const registerExistsMacro = (Type) => {
-    Type.macro("exists", function (tableOrOptions, column, withTrashed) {
+    Type.macro("exists", function (tableOrOptions, column, withTrashed, nullable) {
         const isModel = typeof tableOrOptions === "function" && Object.prototype.isPrototypeOf.call(BaseModel, tableOrOptions);
         const options = isModel
-            ? { table: tableOrOptions, column, withTrashed }
+            ? { table: tableOrOptions, column, withTrashed, nullable }
             : tableOrOptions;
         return this.use(existsRule(options));
     });

package/utils/vines/unique.js

@@ -4,6 +4,8 @@ import BaseModel from "../../bases/BaseModel";
 const unique = async (value, options, field) => {
     if (!field.isValid)
         return;
+    if (options.nullable)
+        return;
     const column = defineValue(options.column, field.name);
     let query = options.table;
     if (options.withTrashed)
@@ -16,10 +18,10 @@ const unique = async (value, options, field) => {
 };
 const uniqueRule = vine.createRule(unique, { isAsync: true });
 const registerUniqueMacro = (Type) => {
-    Type.macro("unique", function (tableOrOptions, column, withTrashed) {
+    Type.macro("unique", function (tableOrOptions, column, withTrashed, nullable) {
         const isModel = typeof tableOrOptions === "function" && Object.prototype.isPrototypeOf.call(BaseModel, tableOrOptions);
         const options = isModel
-            ? { table: tableOrOptions, column, withTrashed }
+            ? { table: tableOrOptions, column, withTrashed, nullable }
             : tableOrOptions;
         return this.use(uniqueRule(options));
     });