@kangwifi-pro/waliwa 1.0.0

package/src/utils/retry.ts

@@ -0,0 +1,205 @@
+/**
+ * Waliwa - Retry & throttle utilities
+ * Implementasi efficient untuk retry exponential backoff dan rate limiting
+ */
+
+import { getRandomBytes } from '../core/crypto.js';
+
+// ============== Retry ==============
+
+export interface RetryOptions {
+  retries?: number;
+  minTimeout?: number;
+  maxTimeout?: number;
+  factor?: number;
+  randomize?: boolean;
+  onFailedAttempt?: (error: Error, attempt: number) => void;
+}
+
+/**
+ * Exponential backoff retry dengan jitter
+ */
+export async function retry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {}
+): Promise<T> {
+  const {
+    retries = 5,
+    minTimeout = 500,
+    maxTimeout = 30000,
+    factor = 2,
+    randomize = true,
+    onFailedAttempt
+  } = options;
+
+  let attempt = 0;
+  let lastError: Error;
+
+  while (attempt <= retries) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err as Error;
+      attempt++;
+      if (attempt > retries) {
+        throw lastError;
+      }
+      if (onFailedAttempt) {
+        onFailedAttempt(lastError, attempt);
+      }
+      // Exponential backoff dengan jitter
+      let delay = minTimeout * Math.pow(factor, attempt - 1);
+      if (randomize) {
+        const jitter = (getRandomBytes(1)[0] / 255) * 0.3;
+        delay = delay * (1 + jitter);
+      }
+      delay = Math.min(delay, maxTimeout);
+      await sleep(delay);
+    }
+  }
+  throw lastError!;
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// ============== Throttle / Rate Limiter ==============
+
+/**
+ * Token bucket rate limiter - RAM-efficient (single object per limiter)
+ */
+export class RateLimiter {
+  private tokens: number;
+  private lastRefill: number;
+  private readonly maxTokens: number;
+  private readonly refillRate: number; // tokens per ms
+  private readonly queue: Array<{ resolve: () => void; reject: (err: Error) => void }> = [];
+  private processing: boolean = false;
+
+  constructor(maxTokensPerSecond: number) {
+    this.maxTokens = maxTokensPerSecond;
+    this.tokens = maxTokensPerSecond;
+    this.refillRate = maxTokensPerSecond / 1000;
+    this.lastRefill = Date.now();
+  }
+
+  private refill(): void {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    this.tokens = Math.min(this.maxTokens, this.tokens + elapsed * this.refillRate);
+    this.lastRefill = now;
+  }
+
+  async acquire(): Promise<void> {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return;
+    }
+    // Queue
+    return new Promise((resolve, reject) => {
+      this.queue.push({ resolve, reject });
+      this.processQueue();
+    });
+  }
+
+  private processQueue(): void {
+    if (this.processing) return;
+    this.processing = true;
+    const tick = () => {
+      this.refill();
+      while (this.queue.length > 0 && this.tokens >= 1) {
+        this.tokens -= 1;
+        const item = this.queue.shift()!;
+        item.resolve();
+      }
+      if (this.queue.length > 0) {
+        setTimeout(tick, 50);
+      } else {
+        this.processing = false;
+      }
+    };
+    tick();
+  }
+
+  /** Destroy limiter dan reject semua queued requests */
+  destroy(): void {
+    while (this.queue.length > 0) {
+      const item = this.queue.shift()!;
+      item.reject(new Error('Rate limiter destroyed'));
+    }
+  }
+}
+
+// ============== Debounce ==============
+
+export function debounce<T extends (...args: any[]) => void>(
+  fn: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeout: NodeJS.Timeout | null = null;
+  return (...args: Parameters<T>) => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), wait);
+  };
+}
+
+// ============== Throttle (leading edge) ==============
+
+export function throttle<T extends (...args: any[]) => void>(
+  fn: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let lastCall = 0;
+  let timeout: NodeJS.Timeout | null = null;
+  return (...args: Parameters<T>) => {
+    const now = Date.now();
+    const remaining = wait - (now - lastCall);
+    if (remaining <= 0) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      lastCall = now;
+      fn(...args);
+    } else if (!timeout) {
+      timeout = setTimeout(() => {
+        lastCall = Date.now();
+        timeout = null;
+        fn(...args);
+      }, remaining);
+    }
+  };
+}
+
+// ============== Promise Queue (sequential execution) ==============
+
+export class PromiseQueue {
+  private queue: Array<() => Promise<void>> = [];
+  private running: boolean = false;
+
+  async add<T>(fn: () => Promise<T>): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          const result = await fn();
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        }
+      });
+      this.process();
+    });
+  }
+
+  private async process(): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+    while (this.queue.length > 0) {
+      const task = this.queue.shift()!;
+      await task();
+    }
+    this.running = false;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "examples", "**/*.test.ts"]
+}