xytara 3.1.13 → 3.1.14

package/lib/rate_limiter.js

@@ -1,81 +1,81 @@
-"use strict";
-
-// Minimal in-memory fixed-window rate limiter. Dependency-free.
-//
-// Used to gate expensive unauthenticated work (e.g. L402 invoice creation, which
-// makes an outbound call to a Lightning provider on every UNPAID request) so a
-// flood cannot amplify into unbounded cost. Two independent ceilings apply:
-//   - per key (typically client IP): `max` hits per `windowMs`
-//   - global (all keys combined):    `maxGlobal` hits per `windowMs`
-// A hit counts against both; exceeding either denies the request.
-//
-// Scope: single process. Horizontally-scaled deployments should front this with a
-// shared store (Redis) or an edge/proxy limiter; this module is the in-process
-// floor, not a distributed guarantee. Callers should still deploy behind the
-// platform's own rate limiting for defense in depth.
-
-function now() {
-  return Date.now();
-}
-
-function createRateLimiter(options) {
-  const opts = options || {};
-  const windowMs = Math.max(1000, Number(opts.windowMs) || 60000);
-  const max = Math.max(1, Number(opts.max) || 30);
-  const maxGlobal = Math.max(max, Number(opts.maxGlobal) || max * 20);
-  // Map<key, { count, resetAt }>
-  const buckets = new Map();
-  let global = { count: 0, resetAt: now() + windowMs };
-  let lastSweep = now();
-
-  function sweep(t) {
-    // Opportunistic cleanup so the Map cannot grow without bound.
-    if (t - lastSweep < windowMs) return;
-    lastSweep = t;
-    for (const [key, bucket] of buckets) {
-      if (bucket.resetAt <= t) buckets.delete(key);
-    }
-  }
-
-  function rollGlobal(t) {
-    if (global.resetAt <= t) global = { count: 0, resetAt: t + windowMs };
-  }
-
-  // Record one hit for `key` and report whether it is allowed. The hit is only
-  // counted when allowed, so a denied caller does not push its own reset further
-  // out (no self-inflicted lockout extension).
-  function check(key) {
-    const t = now();
-    sweep(t);
-    rollGlobal(t);
-    const k = String(key == null ? "" : key);
-    let bucket = buckets.get(k);
-    if (!bucket || bucket.resetAt <= t) {
-      bucket = { count: 0, resetAt: t + windowMs };
-      buckets.set(k, bucket);
-    }
-    if (global.count >= maxGlobal) {
-      return { allowed: false, scope: "global", remaining: 0, retryAfterMs: Math.max(0, global.resetAt - t) };
-    }
-    if (bucket.count >= max) {
-      return { allowed: false, scope: "key", remaining: 0, retryAfterMs: Math.max(0, bucket.resetAt - t) };
-    }
-    bucket.count += 1;
-    global.count += 1;
-    return {
-      allowed: true,
-      scope: null,
-      remaining: Math.max(0, max - bucket.count),
-      retryAfterMs: Math.max(0, bucket.resetAt - t)
-    };
-  }
-
-  function reset() {
-    buckets.clear();
-    global = { count: 0, resetAt: now() + windowMs };
-  }
-
-  return { check, reset, config: { windowMs, max, maxGlobal } };
-}
-
-module.exports = { createRateLimiter };
+"use strict";
+
+// Minimal in-memory fixed-window rate limiter. Dependency-free.
+//
+// Used to gate expensive unauthenticated work (e.g. L402 invoice creation, which
+// makes an outbound call to a Lightning provider on every UNPAID request) so a
+// flood cannot amplify into unbounded cost. Two independent ceilings apply:
+//   - per key (typically client IP): `max` hits per `windowMs`
+//   - global (all keys combined):    `maxGlobal` hits per `windowMs`
+// A hit counts against both; exceeding either denies the request.
+//
+// Scope: single process. Horizontally-scaled deployments should front this with a
+// shared store (Redis) or an edge/proxy limiter; this module is the in-process
+// floor, not a distributed guarantee. Callers should still deploy behind the
+// platform's own rate limiting for defense in depth.
+
+function now() {
+  return Date.now();
+}
+
+function createRateLimiter(options) {
+  const opts = options || {};
+  const windowMs = Math.max(1000, Number(opts.windowMs) || 60000);
+  const max = Math.max(1, Number(opts.max) || 30);
+  const maxGlobal = Math.max(max, Number(opts.maxGlobal) || max * 20);
+  // Map<key, { count, resetAt }>
+  const buckets = new Map();
+  let global = { count: 0, resetAt: now() + windowMs };
+  let lastSweep = now();
+
+  function sweep(t) {
+    // Opportunistic cleanup so the Map cannot grow without bound.
+    if (t - lastSweep < windowMs) return;
+    lastSweep = t;
+    for (const [key, bucket] of buckets) {
+      if (bucket.resetAt <= t) buckets.delete(key);
+    }
+  }
+
+  function rollGlobal(t) {
+    if (global.resetAt <= t) global = { count: 0, resetAt: t + windowMs };
+  }
+
+  // Record one hit for `key` and report whether it is allowed. The hit is only
+  // counted when allowed, so a denied caller does not push its own reset further
+  // out (no self-inflicted lockout extension).
+  function check(key) {
+    const t = now();
+    sweep(t);
+    rollGlobal(t);
+    const k = String(key == null ? "" : key);
+    let bucket = buckets.get(k);
+    if (!bucket || bucket.resetAt <= t) {
+      bucket = { count: 0, resetAt: t + windowMs };
+      buckets.set(k, bucket);
+    }
+    if (global.count >= maxGlobal) {
+      return { allowed: false, scope: "global", remaining: 0, retryAfterMs: Math.max(0, global.resetAt - t) };
+    }
+    if (bucket.count >= max) {
+      return { allowed: false, scope: "key", remaining: 0, retryAfterMs: Math.max(0, bucket.resetAt - t) };
+    }
+    bucket.count += 1;
+    global.count += 1;
+    return {
+      allowed: true,
+      scope: null,
+      remaining: Math.max(0, max - bucket.count),
+      retryAfterMs: Math.max(0, bucket.resetAt - t)
+    };
+  }
+
+  function reset() {
+    buckets.clear();
+    global = { count: 0, resetAt: now() + windowMs };
+  }
+
+  return { check, reset, config: { windowMs, max, maxGlobal } };
+}
+
+module.exports = { createRateLimiter };