@bejibun/core 0.1.52 → 0.1.54

package/CHANGELOG.md

@@ -3,6 +3,41 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [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
+
+### 📖 Changes
+What's New :
+- Adding `Rate Limiter` to limit any action in a certain time.
+
+Available `Rate Limiter` functions :
+- `.attempt(key, limit, callback, duration)` throw an error if limit reached.
+- `.tooManyAttempts(key, limit, duration)` method to check if limit has reached.
+- `.clear(key)` reset the counter.
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+- Ghulje ([@ghulje](https://github.com/ghulje))
+
+**Full Changelog**: https://github.com/crenata/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
 ## [v0.1.52](https://github.com/crenata/bejibun-core/compare/v0.1.51...v0.1.52) - 2025-11-17
 
 ### 🩹 Fixes

package/builders/RateLimiterBuilder.d.ts

@@ -0,0 +1,12 @@
+export default class RateLimiterBuilder {
+    protected key: string;
+    protected limit: number;
+    protected duration: number;
+    constructor();
+    setKey(key: string): RateLimiterBuilder;
+    setLimit(limit: number): RateLimiterBuilder;
+    setDuration(duration: number): RateLimiterBuilder;
+    attempt(callback: Function): Promise<any>;
+    tooManyAttempts(): Promise<boolean>;
+    clear(): Promise<void>;
+}

package/builders/RateLimiterBuilder.js

@@ -0,0 +1,44 @@
+import Cache from "@bejibun/cache";
+import { isNotEmpty } from "@bejibun/utils";
+import RateLimiterException from "../exceptions/RateLimiterException";
+export default class RateLimiterBuilder {
+    key;
+    limit;
+    duration; // seconds
+    constructor() {
+        this.key = "";
+        this.limit = 60;
+        this.duration = 60;
+    }
+    setKey(key) {
+        this.key = key;
+        return this;
+    }
+    setLimit(limit) {
+        this.limit = limit;
+        return this;
+    }
+    setDuration(duration) {
+        this.duration = duration;
+        return this;
+    }
+    async attempt(callback) {
+        const count = Number(await Cache.increment(this.key, this.duration));
+        const canExecute = count <= this.limit;
+        if (isNotEmpty(callback) && typeof callback === "function") {
+            if (canExecute)
+                return callback();
+        }
+        else {
+            throw new RateLimiterException("Invalid callback.");
+        }
+        throw new RateLimiterException("Too many attempts.");
+    }
+    async tooManyAttempts() {
+        const count = Number(await Cache.get(this.key));
+        return count > this.limit;
+    }
+    async clear() {
+        return await Cache.forget(this.key);
+    }
+}

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;
     }

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,29 @@
+import App from "@bejibun/app";
+import { isEmpty } from "@bejibun/utils";
+import Luxon from "@bejibun/utils/facades/Luxon";
+import path from "path";
+export default class StorageBuilder {
+    file;
+    directory;
+    name;
+    constructor() {
+        this.name = "";
+    }
+    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 = `${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);
+    }
+}

package/config/limiter.d.ts

@@ -0,0 +1,2 @@
+declare const config: Record<string, any>;
+export default config;

package/config/limiter.js

@@ -0,0 +1,5 @@
+const config = {
+    limit: 60,
+    duration: 60 // seconds
+};
+export default config;

package/exceptions/ExceptionHandler.d.ts

@@ -1,7 +1,10 @@
 import { ValidationError } from "objection";
 import ModelNotFoundException from "../exceptions/ModelNotFoundException";
+import RateLimiterException from "../exceptions/RateLimiterException";
+import RouterInvalidException from "../exceptions/RouterInvalidException";
+import RuntimeException from "../exceptions/RuntimeException";
 import ValidatorException from "../exceptions/ValidatorException";
 export default class ExceptionHandler {
-    handle(error: Bun.ErrorLike | ModelNotFoundException | ValidatorException | ValidationError): globalThis.Response;
+    handle(error: Bun.ErrorLike | ModelNotFoundException | RateLimiterException | RouterInvalidException | RuntimeException | ValidatorException | ValidationError): globalThis.Response;
     route(request: Bun.BunRequest): globalThis.Response;
 }

package/exceptions/ExceptionHandler.js

@@ -3,12 +3,18 @@ import { defineValue } from "@bejibun/utils";
 import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
 import { ValidationError } from "objection";
 import ModelNotFoundException from "../exceptions/ModelNotFoundException";
+import RateLimiterException from "../exceptions/RateLimiterException";
+import RouterInvalidException from "../exceptions/RouterInvalidException";
+import RuntimeException from "../exceptions/RuntimeException";
 import ValidatorException from "../exceptions/ValidatorException";
 import Response from "../facades/Response";
 export default class ExceptionHandler {
     handle(error) {
         Logger.setContext("APP").error(error.message).trace(error.stack);
         if (error instanceof ModelNotFoundException ||
+            error instanceof RateLimiterException ||
+            error instanceof RouterInvalidException ||
+            error instanceof RuntimeException ||
             error instanceof ValidatorException)
             return Response
                 .setMessage(error.message)

package/exceptions/RateLimiterException.d.ts

@@ -0,0 +1,4 @@
+export default class RateLimiterException extends Error {
+    code: number;
+    constructor(message?: string, code?: number);
+}

package/exceptions/RateLimiterException.js

@@ -0,0 +1,14 @@
+import Logger from "@bejibun/logger";
+import { defineValue } from "@bejibun/utils";
+export default class RateLimiterException extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "RateLimiterException";
+        this.code = defineValue(code, 429);
+        Logger.setContext(this.name).error(this.message).trace(this.stack);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, RateLimiterException);
+        }
+    }
+}

package/facades/RateLimiter.d.ts

@@ -0,0 +1,5 @@
+export default class RateLimiter {
+    static attempt(key: string, limit: number, callback: Function, duration?: number): Promise<any>;
+    static tooManyAttempts(key: string, limit: number, duration?: number): Promise<boolean>;
+    static clear(key: string): Promise<void>;
+}

package/facades/RateLimiter.js

@@ -0,0 +1,23 @@
+import { defineValue } from "@bejibun/utils";
+import RateLimiterBuilder from "../builders/RateLimiterBuilder";
+export default class RateLimiter {
+    static async attempt(key, limit, callback, duration) {
+        return await new RateLimiterBuilder()
+            .setKey(key)
+            .setLimit(defineValue(limit, 60))
+            .setDuration(defineValue(duration, 60))
+            .attempt(callback);
+    }
+    static async tooManyAttempts(key, limit, duration) {
+        return await new RateLimiterBuilder()
+            .setKey(key)
+            .setLimit(defineValue(limit, 60))
+            .setDuration(defineValue(duration, 60))
+            .tooManyAttempts();
+    }
+    static async clear(key) {
+        return await new RateLimiterBuilder()
+            .setKey(key)
+            .clear();
+    }
+}

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/middlewares/MaintenanceMiddleware.js

@@ -2,7 +2,7 @@ import App from "@bejibun/app";
 import Response from "../facades/Response";
 export default class MaintenanceMiddleware {
     handle(handler) {
-        return async (request) => {
+        return async (request, server) => {
             if (await App.Maintenance.isMaintenanceMode()) {
                 const maintenance = await App.Maintenance.getData();
                 return Response
@@ -10,7 +10,7 @@ export default class MaintenanceMiddleware {
                     .setStatus(maintenance.status)
                     .send();
             }
-            return handler(request);
+            return handler(request, server);
         };
     }
 }

package/middlewares/RateLimiterMiddleware.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerType } from "../types/router";
+export default class RateLimiterMiddleware {
+    handle(handler: HandlerType): HandlerType;
+}

package/middlewares/RateLimiterMiddleware.js

@@ -0,0 +1,20 @@
+import App from "@bejibun/app";
+import { defineValue } from "@bejibun/utils";
+import LimiterConfig from "../config/limiter";
+import RateLimiter from "../facades/RateLimiter";
+export default class RateLimiterMiddleware {
+    handle(handler) {
+        return async (request, server) => {
+            const configPath = App.Path.configPath("limiter.ts");
+            let config;
+            if (await Bun.file(configPath).exists())
+                config = require(configPath).default;
+            else
+                config = LimiterConfig;
+            return await RateLimiter
+                .attempt(`rate-limiter/${defineValue(server.requestIP(request)?.address, "")}`, defineValue(config?.limit, 60), () => {
+                return handler(request, server);
+            });
+        };
+    }
+}

package/middlewares/X402Middleware.js

@@ -9,14 +9,14 @@ export default class X402Middleware {
         this.paywallConfig = paywallConfig;
     }
     handle(handler) {
-        return async (request) => {
+        return async (request, server) => {
             return X402
                 .setConfig(this.config)
                 .setFacilitator(this.facilitatorConfig)
                 .setPaywall(this.paywallConfig)
                 .setRequest(request)
                 .middleware(() => {
-                return handler(request);
+                return handler(request, server);
             });
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.52",
+    "version": "0.1.54",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -10,6 +10,7 @@
     "module": "index.js",
     "dependencies": {
         "@bejibun/app": "^0.1.22",
+        "@bejibun/cache": "^0.1.11",
         "@bejibun/cors": "^0.1.16",
         "@bejibun/database": "^0.1.19",
         "@bejibun/logger": "^0.1.22",

package/server.js

@@ -3,6 +3,7 @@ import Logger from "@bejibun/logger";
 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;
@@ -39,7 +40,7 @@ const server = Bun.serve({
     port: Bun.env.APP_PORT,
     routes: {
         "/": require(App.Path.publicPath("index.html")),
-        ...Router.middleware(new MaintenanceMiddleware()).group([
+        ...Router.middleware(new MaintenanceMiddleware(), new RateLimiterMiddleware()).group([
             Router.namespace("app/exceptions").any("/*", "Handler@route"),
             ApiRoutes,
             WebRoutes

package/types/router.d.ts

@@ -1,3 +1,3 @@
-export type HandlerType = (request: Bun.BunRequest) => Promise<Response>;
+export type HandlerType = (request: Bun.BunRequest, server: Bun.Server) => Promise<Response>;
 export type RouterGroup = Record<string, Record<string, HandlerType>>;
 export type ResourceAction = "index" | "store" | "show" | "update" | "destroy";