@bejibun/core 0.1.51 → 0.1.53

package/CHANGELOG.md

@@ -3,6 +3,55 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [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
+
+### 📖 Changes
+What's New :
+
+Adding support for x402 protocol. You can secure your paid endpoint by adding `.x402()` chaining on router.
+
+How to use it :
+
+First, you need to install the package by running `bun ace install @bejibun/x402`.
+
+Customize your `config/x402.ts` with your own configuration.
+
+Add `.x402()` chain into router you want to add for payment middleware.
+```ts
+Router.x402()
+```
+
+### ❤️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.51](https://github.com/crenata/bejibun-core/compare/v0.1.49...v0.1.51) - 2025-11-04
 
 ### 🩹 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.d.ts

@@ -1,6 +1,7 @@
-import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
+import type { TFacilitator, TPaywall, TX402Config } from "@bejibun/x402";
 import type { IMiddleware } from "../types/middleware";
 import type { HandlerType, ResourceAction, RouterGroup } from "../types/router";
+import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
 export interface ResourceOptions {
     only?: Array<ResourceAction>;
     except?: Array<ResourceAction>;
@@ -12,6 +13,7 @@ export default class RouterBuilder {
     prefix(basePath: string): 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;

package/builders/RouterBuilder.js

@@ -1,9 +1,10 @@
 import App from "@bejibun/app";
-import { isEmpty } from "@bejibun/utils";
+import { isEmpty, isModuleExists } from "@bejibun/utils";
 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 = [];
@@ -20,6 +21,12 @@ export default class RouterBuilder {
         this.baseNamespace = baseNamespace;
         return this;
     }
+    x402(config, facilitatorConfig, paywallConfig) {
+        if (!isModuleExists("@bejibun/x402"))
+            throw new RouterInvalidException("@bejibun/x402 is not installed.");
+        this.middlewares.push(new X402Middleware(config, facilitatorConfig, paywallConfig));
+        return this;
+    }
     group(routes) {
         const routeList = Array.isArray(routes) ? routes : [routes];
         const newRoutes = {};

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/Router.d.ts

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

package/facades/Router.js

@@ -10,6 +10,9 @@ export default class Router {
     static namespace(baseNamespace) {
         return new RouterBuilder().namespace(baseNamespace);
     }
+    static x402() {
+        return new RouterBuilder().x402();
+    }
     static resources(controller, options) {
         return new RouterBuilder().resources(controller, options);
     }

package/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./bases/index";
 export * from "./exceptions/index";
 export * from "./facades/index";
+export * from "./middlewares/index";

package/index.js

@@ -1,3 +1,4 @@
 export * from "./bases/index";
 export * from "./exceptions/index";
 export * from "./facades/index";
+export * from "./middlewares/index";

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.d.ts

@@ -0,0 +1,9 @@
+import type { TFacilitator, TPaywall, TX402Config } from "@bejibun/x402";
+import type { HandlerType } from "../types/router";
+export default class X402Middleware {
+    protected config?: TX402Config;
+    protected facilitatorConfig?: TFacilitator;
+    protected paywallConfig?: TPaywall;
+    constructor(config?: TX402Config, facilitatorConfig?: TFacilitator, paywallConfig?: TPaywall);
+    handle(handler: HandlerType): HandlerType;
+}

package/middlewares/X402Middleware.js

@@ -0,0 +1,23 @@
+import X402 from "@bejibun/x402";
+export default class X402Middleware {
+    config;
+    facilitatorConfig;
+    paywallConfig;
+    constructor(config, facilitatorConfig, paywallConfig) {
+        this.config = config;
+        this.facilitatorConfig = facilitatorConfig;
+        this.paywallConfig = paywallConfig;
+    }
+    handle(handler) {
+        return async (request, server) => {
+            return X402
+                .setConfig(this.config)
+                .setFacilitator(this.facilitatorConfig)
+                .setPaywall(this.paywallConfig)
+                .setRequest(request)
+                .middleware(() => {
+                return handler(request, server);
+            });
+        };
+    }
+}

package/middlewares/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../middlewares/MaintenanceMiddleware";
+export * from "../middlewares/X402Middleware";

package/middlewares/index.js

@@ -0,0 +1,2 @@
+export * from "../middlewares/MaintenanceMiddleware";
+export * from "../middlewares/X402Middleware";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.51",
+    "version": "0.1.53",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -10,16 +10,18 @@
     "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",
-        "@bejibun/utils": "^0.1.20",
+        "@bejibun/utils": "^0.1.21",
         "@vinejs/vine": "^3.0.1",
         "commander": "^14.0.2",
         "luxon": "^3.7.2",
         "objection": "^3.1.5"
     },
     "devDependencies": {
+        "@bejibun/x402": "^0.1.1",
         "@types/bun": "latest",
         "@types/luxon": "^3.7.1",
         "tsc-alias": "^1.8.16"

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