ayiin 2.0.33 → 2.0.35

package/{index.js → dist/index.js}

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-ignore
-const package_json_1 = __importDefault(require("./package.json"));
+const package_json_1 = __importDefault(require("../package.json"));
 const methods_1 = __importDefault(require("./methods"));
 class Ayiin extends methods_1.default {
     version = package_json_1.default.version;

package/{methods → dist/methods}/index.d.ts

@@ -1,8 +1,9 @@
 import Crypt from "./crypt";
-import Tools from "./tools";
+import { Limiter } from "./limiter";
 import ResponseApi from "./response";
+import Tools from "./tools";
 declare class Methods {
 }
-interface Methods extends Crypt, Tools, ResponseApi {
+interface Methods extends Crypt, Tools, ResponseApi, Limiter {
 }
 export default Methods;

package/{methods → dist/methods}/index.js

@@ -4,12 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypt_1 = __importDefault(require("./crypt"));
-const tools_1 = __importDefault(require("./tools"));
+const limiter_1 = require("./limiter");
 const response_1 = __importDefault(require("./response"));
+const tools_1 = __importDefault(require("./tools"));
 class Methods {
 }
 // copy instance properties
 Object.assign(Methods.prototype, new tools_1.default());
 Object.assign(Methods.prototype, new crypt_1.default());
 Object.assign(Methods.prototype, new response_1.default());
+Object.assign(Methods.prototype, new limiter_1.Limiter());
 exports.default = Methods;

package/dist/methods/limiter.d.ts

@@ -0,0 +1,6 @@
+import { RequestHandler } from "express";
+import { RateLimiterOptions } from "../types";
+import Tools from "./tools";
+export declare class Limiter extends Tools {
+    createRateLimit: (options: RateLimiterOptions) => Promise<RequestHandler>;
+}

package/dist/methods/limiter.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Limiter = void 0;
+const tools_1 = __importDefault(require("./tools"));
+// 🔹 MemoryStore default
+class MemoryStore {
+    store = new Map();
+    async get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expireAt && Date.now() > entry.expireAt) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async set(key, value, ttlMs) {
+        this.store.set(key, {
+            value,
+            expireAt: ttlMs ? Date.now() + ttlMs : undefined,
+        });
+    }
+    async incr(key) {
+        const entry = this.store.get(key);
+        if (!entry) {
+            this.store.set(key, { value: "1", hits: 1 });
+            return 1;
+        }
+        entry.hits = (entry.hits ?? parseInt(entry.value)) + 1;
+        entry.value = entry.hits.toString();
+        return entry.hits;
+    }
+    async expire(key, ttlMs) {
+        const entry = this.store.get(key);
+        if (entry) {
+            entry.expireAt = Date.now() + ttlMs;
+        }
+    }
+}
+// 🔹 Class Limiter
+class Limiter extends tools_1.default {
+    createRateLimit = async (options) => {
+        const store = options.store ?? new MemoryStore(); // default ke MemoryStore
+        return async (req, res, next) => {
+            const now = Date.now();
+            const userId = options.identifyUser
+                ? options.identifyUser(req, res)
+                : (req.ip ?? "unknown");
+            const floodKey = `${options.keyPrefix}:flood:${userId}`;
+            const blockedUntilStr = await store.get(floodKey);
+            if (blockedUntilStr) {
+                const blockedUntil = new Date(blockedUntilStr).getTime();
+                const remainingMs = blockedUntil - now;
+                if (remainingMs > 0) {
+                    return res.status(429).json({
+                        success: false,
+                        error: `Floodwait aktif untuk ${options.keyPrefix}. Tunggu ${this.formatRemainingTime(remainingMs)}.`,
+                    });
+                }
+            }
+            const rateKey = `${options.keyPrefix}:rate:${userId}`;
+            const hits = await store.incr(rateKey);
+            const windowMs = this.toMilliseconds(options.windowMs);
+            const floodwaitMs = this.toMilliseconds(options.floodwaitMs);
+            if (hits === 1) {
+                await store.expire(rateKey, windowMs);
+            }
+            if (hits > options.limit) {
+                const untilDate = new Date(now + floodwaitMs).toISOString();
+                await store.set(floodKey, untilDate, floodwaitMs);
+                return res.status(429).json({
+                    success: false,
+                    error: `Terlalu banyak request ${options.keyPrefix}. Floodwait ${this.formatRemainingTime(floodwaitMs)}.`,
+                });
+            }
+            next();
+        };
+    };
+}
+exports.Limiter = Limiter;

package/{methods → dist/methods}/tools.d.ts

@@ -1,3 +1,4 @@
+import { DurationInput } from "../types";
 declare class Tools {
     /**
      * Format money ke string sesuai locale
@@ -80,5 +81,7 @@ declare class Tools {
     isEmptyObject: (obj: object) => boolean;
     sleep: (ms: number) => Promise<void>;
     retry: <T>(fn: () => Promise<T>, retries?: number) => Promise<T>;
+    toMilliseconds: ({ hours, minutes, seconds, }: DurationInput) => number;
+    formatRemainingTime: (ms: number) => string;
 }
 export default Tools;

package/{methods → dist/methods}/tools.js

@@ -174,5 +174,19 @@ class Tools {
         }
         throw error;
     };
+    toMilliseconds = ({ hours = 0, minutes = 0, seconds = 0, }) => {
+        return (hours * 3600 + minutes * 60 + seconds) * 1000;
+    };
+    formatRemainingTime = (ms) => {
+        if (ms <= 0)
+            return "0 detik";
+        const totalSeconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(totalSeconds / 60);
+        const seconds = totalSeconds % 60;
+        if (minutes > 0) {
+            return `${minutes} menit ${seconds} detik lagi`;
+        }
+        return `${seconds} detik lagi`;
+    };
 }
 exports.default = Tools;

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+import { Request, Response } from "express";
+export interface DurationInput {
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+export interface DurationInput {
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+export interface RateLimiterOptions {
+    keyPrefix: string;
+    limit: number;
+    windowMs: DurationInput;
+    floodwaitMs: DurationInput;
+    identifyUser?: (req: Request, res: Response) => string;
+    store?: RateLimitStore;
+}
+export interface RateLimitStore {
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string, ttlMs?: number): Promise<void>;
+    incr(key: string): Promise<number>;
+    expire(key: string, ttlMs: number): Promise<void>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "ayiin",
-  "version": "2.0.33",
+  "version": "2.0.35",
   "description": "Library Pribadi Yang Gak Ada Isinya",
-  "main": "index.js",
+  "main": "./dist/index.js",
   "bin": {
-    "axd": "./bin/cli.js"
+    "axd": "./dist/bin/cli.js"
   },
   "scripts": {
     "build": "tsc"
@@ -22,6 +22,7 @@
   ],
   "license": "GPL-3.0-only",
   "devDependencies": {
+    "@types/express": "^5.0.6",
     "@types/node": "^26.3.0",
     "typescript": "^7"
   }