ayiin 2.0.39 → 2.0.40

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import Methods from "./methods";
-export type { DurationInput, RateLimitStore, RateLimiterOptions, } from "./types";
+export type { DurationInput, FloodwaitPlaceholder, RateLimitStore, RateLimiterOptions, } from "./types";
 export default class Ayiin extends Methods {
     version: string;
     constructor();

package/dist/methods/limiter.d.ts

@@ -3,4 +3,5 @@ import { RateLimiterOptions } from "../types";
 import Tools from "./tools";
 export declare class Limiter extends Tools {
     createRateLimit: (options: RateLimiterOptions) => RequestHandler;
+    private formatMessage;
 }

package/dist/methods/limiter.js

@@ -57,43 +57,63 @@ class Limiter extends tools_1.default {
                 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 msg = options.messageFormat
+                        ? this.formatMessage(options.messageFormat, {
+                            api: options.keyPrefix,
+                            remainMs: remainingMs,
+                            remain: this.formatRemainingTime(remainingMs),
+                            limit: options.limit,
+                        })
+                        : `[FloodWait] - Silakan coba lagi dalam ${this.formatRemainingTime(remainingMs)}.`;
+                    return res.status(429).json({ success: false, error: msg });
                 }
             }
             const rateKey = `${options.keyPrefix}:rate:${userId}`;
             const hits = await store.incr(rateKey);
             const windowMs = this.toMilliseconds(options.windowMs);
-            const baseFloodwaitMs = this.toMilliseconds(options.floodwaitMs);
-            const levelTtlMs = this.toMilliseconds(options.levelTtl ?? { hours: 24 });
+            const refreshAtMs = this.toMilliseconds(options.refreshAt ?? { hours: 24 });
             if (hits === 1) {
                 await store.expire(rateKey, windowMs);
             }
             if (hits > options.limit) {
-                let floodwaitMs = baseFloodwaitMs;
-                if (options.levels && options.levels.length > 0) {
-                    let level = parseInt((await store.get(levelKey)) ?? "0", 10);
-                    level += 1;
-                    // simpan level dengan TTL (reset otomatis setelah levelTtlMs)
-                    await store.set(levelKey, level.toString(), levelTtlMs);
-                    // pilih durasi floodwait dari config levels
-                    const idx = Math.min(level - 1, options.levels.length - 1);
-                    const levelDuration = options.levels[idx];
-                    if (levelDuration) {
-                        floodwaitMs = this.toMilliseconds(levelDuration);
-                    }
+                let floodwaitMs;
+                let level;
+                if (Array.isArray(options.floodwaitMs)) {
+                    // escalation mode
+                    level = parseInt((await store.get(levelKey)) ?? "0", 10) + 1;
+                    await store.set(levelKey, level.toString(), refreshAtMs);
+                    const idx = Math.min(level - 1, options.floodwaitMs.length - 1);
+                    const floodwait = options.floodwaitMs[idx];
+                    floodwaitMs = this.toMilliseconds(floodwait ?? options.floodwaitMs[0]);
+                }
+                else {
+                    // fixed mode
+                    floodwaitMs = this.toMilliseconds(options.floodwaitMs);
                 }
                 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 aktif selama ${this.formatRemainingTime(floodwaitMs)}.`,
-                });
+                const msg = options.messageFormat
+                    ? this.formatMessage(options.messageFormat, {
+                        api: options.keyPrefix,
+                        remainMs: floodwaitMs,
+                        remain: this.formatRemainingTime(floodwaitMs),
+                        level,
+                        limit: options.limit,
+                    })
+                    : `[FloodWait] - Terlalu banyak permintaan. Silakan coba lagi dalam ${this.formatRemainingTime(floodwaitMs)}.`;
+                return res.status(429).json({ success: false, error: msg });
             }
             next();
         };
     };
+    // internal formatter
+    formatMessage(template, ctx) {
+        return template
+            .replace("%(api)s", ctx.api)
+            .replace("%(remainMs)s", ctx.remainMs.toString())
+            .replace("%(remain)s", ctx.remain)
+            .replace("%(level)s", ctx.level?.toString() ?? "1")
+            .replace("%(limit)s", ctx.limit?.toString() ?? "");
+    }
 }
 exports.Limiter = Limiter;

package/dist/types.d.ts

@@ -1,4 +1,10 @@
 import { Request, Response } from "express";
+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>;
+}
 export interface DurationInput {
     hours?: number;
     minutes?: number;
@@ -8,15 +14,10 @@ export interface RateLimiterOptions {
     keyPrefix: string;
     limit: number;
     windowMs: DurationInput;
-    floodwaitMs: DurationInput;
+    floodwaitMs: DurationInput | DurationInput[];
     identifyUser?: (req: Request, res: Response) => string | Response<any, Record<string, any>>;
     store?: RateLimitStore;
-    levels?: DurationInput[];
-    levelTtl?: DurationInput;
-}
-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>;
+    refreshAt?: DurationInput;
+    messageFormat?: string extends FloodwaitPlaceholder ? string : never;
 }
+export type FloodwaitPlaceholder = "%(api)s" | "%(remainMs)s" | "%(remain)s" | "%(level)s" | "%(limit)s";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ayiin",
-  "version": "2.0.39",
+  "version": "2.0.40",
   "description": "Library Pribadi Yang Gak Ada Isinya",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",