@joint-ops/hitlimit-bun 1.1.1 → 1.1.2

package/README.md

@@ -6,32 +6,32 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
 [![Bun](https://img.shields.io/badge/Bun-Native-black.svg)](https://bun.sh)
 
-> The fastest rate limiter for Bun - 7M+ ops/sec with memory-first design | Elysia, Hono & Bun.serve
+> The fastest rate limiter for Bun - 5M+ ops/sec under real-world load | Elysia, Hono & Bun.serve
 
-**hitlimit-bun** is a blazing-fast, Bun-native rate limiting library for Bun.serve, Elysia, and Hono applications. **Memory-first by default** with 7.29M ops/sec performance (14.6x faster than SQLite). Optional persistence with native bun:sqlite or Redis when you need it.
+**hitlimit-bun** is a blazing-fast, Bun-native rate limiting library for Bun.serve, Elysia, and Hono applications. **Memory-first by default** with 5.62M ops/sec under real-world load (~15x faster than SQLite). Optional persistence with native bun:sqlite or Redis when you need it.
 
 **[Documentation](https://hitlimit.jointops.dev/docs/bun)** | **[GitHub](https://github.com/JointOps/hitlimit-monorepo)** | **[npm](https://www.npmjs.com/package/@joint-ops/hitlimit-bun)**
 
 ## ⚡ Why hitlimit-bun?
 
-**Memory-first for maximum performance.** 14.6x faster than SQLite.
+**Memory-first for maximum performance.** ~15x faster than SQLite.
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │                                                                 │
-│  Memory (v1.1+)     ██████████████████████████████  7.29M ops/s │
-│  SQLite (v1.0)      █░░░░░░░░░░░░░░░░░░░░░░░░░░░░  500K ops/s  │
+│  Memory (v1.1+)     ██████████████████████████████  5.62M ops/s │
+│  SQLite (v1.0)      █░░░░░░░░░░░░░░░░░░░░░░░░░░░░  383K ops/s  │
 │                                                                 │
-│  14.6x performance improvement with memory default             │
+│  ~15x performance improvement with memory default (10K IPs)    │
 │                                                                 │
 └─────────────────────────────────────────────────────────────────┘
 ```
 
-- **🚀 Memory-First** - 7.29M ops/sec by default (v1.1.0+), 14.6x faster than SQLite
+- **🚀 Memory-First** - 5.62M ops/sec under real-world load (v1.1+), ~15x faster than SQLite
 - **Bun Native** - Built specifically for Bun's runtime, not a Node.js port
 - **Zero Config** - Works out of the box with sensible defaults
 - **Framework Support** - First-class Elysia and Hono integration
-- **Optional Persistence** - SQLite (500K ops/sec) or Redis (6.6K ops/sec) when needed
+- **Optional Persistence** - SQLite (383K ops/sec) or Redis (6.6K ops/sec) when needed
 - **TypeScript First** - Full type safety and IntelliSense support
 - **Auto-Ban** - Automatically ban repeat offenders after threshold violations
 - **Shared Limits** - Group rate limits via groupId for teams/tenants
@@ -356,8 +356,8 @@ hitlimit-bun is optimized for Bun's runtime with native performance:
 
 | Store | Operations/sec | vs Node.js |
 |-------|----------------|------------|
-| **Memory** | 7,290,000+ | +52% faster |
-| **bun:sqlite** | 500,000+ | ~same |
+| **Memory** | 5,620,000+ | +68% faster |
+| **bun:sqlite** | 383,000+ | ~same |
 | **Redis** | 6,600+ | ~same |
 
 ### HTTP Throughput

package/dist/elysia.js

@@ -5,46 +5,62 @@ class MemoryStore {
   hits = new Map;
   bans = new Map;
   violations = new Map;
+  _result = { count: 0, resetAt: 0 };
+  sweepInterval;
+  constructor() {
+    this.sweepInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [key, entry] of this.hits) {
+        if (now >= entry.resetAt)
+          this.hits.delete(key);
+      }
+      for (const [key, ban] of this.bans) {
+        if (now >= ban.expiresAt)
+          this.bans.delete(key);
+      }
+      for (const [key, violation] of this.violations) {
+        if (now >= violation.resetAt)
+          this.violations.delete(key);
+      }
+    }, 1e4);
+    if (typeof this.sweepInterval.unref === "function") {
+      this.sweepInterval.unref();
+    }
+  }
   hit(key, windowMs, _limit) {
     const entry = this.hits.get(key);
     if (entry !== undefined) {
-      entry.count++;
-      return { count: entry.count, resetAt: entry.resetAt };
+      const now2 = Date.now();
+      if (now2 >= entry.resetAt) {
+        entry.count = 1;
+        entry.resetAt = now2 + windowMs;
+      } else {
+        entry.count++;
+      }
+      this._result.count = entry.count;
+      this._result.resetAt = entry.resetAt;
+      return this._result;
     }
     const now = Date.now();
     const resetAt = now + windowMs;
-    const timeoutId = setTimeout(() => {
-      this.hits.delete(key);
-    }, windowMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.hits.set(key, { count: 1, resetAt, timeoutId });
-    return { count: 1, resetAt };
+    this.hits.set(key, { count: 1, resetAt });
+    this._result.count = 1;
+    this._result.resetAt = resetAt;
+    return this._result;
   }
   isBanned(key) {
     const ban = this.bans.get(key);
     if (!ban)
       return false;
     if (Date.now() >= ban.expiresAt) {
-      clearTimeout(ban.timeoutId);
       this.bans.delete(key);
       return false;
     }
     return true;
   }
   ban(key, durationMs) {
-    const existing = this.bans.get(key);
-    if (existing)
-      clearTimeout(existing.timeoutId);
     const expiresAt = Date.now() + durationMs;
-    const timeoutId = setTimeout(() => {
-      this.bans.delete(key);
-    }, durationMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.bans.set(key, { expiresAt, timeoutId });
+    this.bans.set(key, { expiresAt });
   }
   recordViolation(key, windowMs) {
     const entry = this.violations.get(key);
@@ -52,47 +68,19 @@ class MemoryStore {
       entry.count++;
       return entry.count;
     }
-    if (entry)
-      clearTimeout(entry.timeoutId);
     const resetAt = Date.now() + windowMs;
-    const timeoutId = setTimeout(() => {
-      this.violations.delete(key);
-    }, windowMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.violations.set(key, { count: 1, resetAt, timeoutId });
+    this.violations.set(key, { count: 1, resetAt });
     return 1;
   }
   reset(key) {
-    const entry = this.hits.get(key);
-    if (entry) {
-      clearTimeout(entry.timeoutId);
-      this.hits.delete(key);
-    }
-    const ban = this.bans.get(key);
-    if (ban) {
-      clearTimeout(ban.timeoutId);
-      this.bans.delete(key);
-    }
-    const violation = this.violations.get(key);
-    if (violation) {
-      clearTimeout(violation.timeoutId);
-      this.violations.delete(key);
-    }
+    this.hits.delete(key);
+    this.bans.delete(key);
+    this.violations.delete(key);
   }
   shutdown() {
-    for (const [, entry] of this.hits) {
-      clearTimeout(entry.timeoutId);
-    }
+    clearInterval(this.sweepInterval);
     this.hits.clear();
-    for (const [, entry] of this.bans) {
-      clearTimeout(entry.timeoutId);
-    }
     this.bans.clear();
-    for (const [, entry] of this.violations) {
-      clearTimeout(entry.timeoutId);
-    }
     this.violations.clear();
   }
 }

package/dist/hono.js

@@ -5,46 +5,62 @@ class MemoryStore {
   hits = new Map;
   bans = new Map;
   violations = new Map;
+  _result = { count: 0, resetAt: 0 };
+  sweepInterval;
+  constructor() {
+    this.sweepInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [key, entry] of this.hits) {
+        if (now >= entry.resetAt)
+          this.hits.delete(key);
+      }
+      for (const [key, ban] of this.bans) {
+        if (now >= ban.expiresAt)
+          this.bans.delete(key);
+      }
+      for (const [key, violation] of this.violations) {
+        if (now >= violation.resetAt)
+          this.violations.delete(key);
+      }
+    }, 1e4);
+    if (typeof this.sweepInterval.unref === "function") {
+      this.sweepInterval.unref();
+    }
+  }
   hit(key, windowMs, _limit) {
     const entry = this.hits.get(key);
     if (entry !== undefined) {
-      entry.count++;
-      return { count: entry.count, resetAt: entry.resetAt };
+      const now2 = Date.now();
+      if (now2 >= entry.resetAt) {
+        entry.count = 1;
+        entry.resetAt = now2 + windowMs;
+      } else {
+        entry.count++;
+      }
+      this._result.count = entry.count;
+      this._result.resetAt = entry.resetAt;
+      return this._result;
     }
     const now = Date.now();
     const resetAt = now + windowMs;
-    const timeoutId = setTimeout(() => {
-      this.hits.delete(key);
-    }, windowMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.hits.set(key, { count: 1, resetAt, timeoutId });
-    return { count: 1, resetAt };
+    this.hits.set(key, { count: 1, resetAt });
+    this._result.count = 1;
+    this._result.resetAt = resetAt;
+    return this._result;
   }
   isBanned(key) {
     const ban = this.bans.get(key);
     if (!ban)
       return false;
     if (Date.now() >= ban.expiresAt) {
-      clearTimeout(ban.timeoutId);
       this.bans.delete(key);
       return false;
     }
     return true;
   }
   ban(key, durationMs) {
-    const existing = this.bans.get(key);
-    if (existing)
-      clearTimeout(existing.timeoutId);
     const expiresAt = Date.now() + durationMs;
-    const timeoutId = setTimeout(() => {
-      this.bans.delete(key);
-    }, durationMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.bans.set(key, { expiresAt, timeoutId });
+    this.bans.set(key, { expiresAt });
   }
   recordViolation(key, windowMs) {
     const entry = this.violations.get(key);
@@ -52,47 +68,19 @@ class MemoryStore {
       entry.count++;
       return entry.count;
     }
-    if (entry)
-      clearTimeout(entry.timeoutId);
     const resetAt = Date.now() + windowMs;
-    const timeoutId = setTimeout(() => {
-      this.violations.delete(key);
-    }, windowMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.violations.set(key, { count: 1, resetAt, timeoutId });
+    this.violations.set(key, { count: 1, resetAt });
     return 1;
   }
   reset(key) {
-    const entry = this.hits.get(key);
-    if (entry) {
-      clearTimeout(entry.timeoutId);
-      this.hits.delete(key);
-    }
-    const ban = this.bans.get(key);
-    if (ban) {
-      clearTimeout(ban.timeoutId);
-      this.bans.delete(key);
-    }
-    const violation = this.violations.get(key);
-    if (violation) {
-      clearTimeout(violation.timeoutId);
-      this.violations.delete(key);
-    }
+    this.hits.delete(key);
+    this.bans.delete(key);
+    this.violations.delete(key);
   }
   shutdown() {
-    for (const [, entry] of this.hits) {
-      clearTimeout(entry.timeoutId);
-    }
+    clearInterval(this.sweepInterval);
     this.hits.clear();
-    for (const [, entry] of this.bans) {
-      clearTimeout(entry.timeoutId);
-    }
     this.bans.clear();
-    for (const [, entry] of this.violations) {
-      clearTimeout(entry.timeoutId);
-    }
     this.violations.clear();
   }
 }

package/dist/index.js

@@ -5,46 +5,62 @@ class MemoryStore {
   hits = new Map;
   bans = new Map;
   violations = new Map;
+  _result = { count: 0, resetAt: 0 };
+  sweepInterval;
+  constructor() {
+    this.sweepInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [key, entry] of this.hits) {
+        if (now >= entry.resetAt)
+          this.hits.delete(key);
+      }
+      for (const [key, ban] of this.bans) {
+        if (now >= ban.expiresAt)
+          this.bans.delete(key);
+      }
+      for (const [key, violation] of this.violations) {
+        if (now >= violation.resetAt)
+          this.violations.delete(key);
+      }
+    }, 1e4);
+    if (typeof this.sweepInterval.unref === "function") {
+      this.sweepInterval.unref();
+    }
+  }
   hit(key, windowMs, _limit) {
     const entry = this.hits.get(key);
     if (entry !== undefined) {
-      entry.count++;
-      return { count: entry.count, resetAt: entry.resetAt };
+      const now2 = Date.now();
+      if (now2 >= entry.resetAt) {
+        entry.count = 1;
+        entry.resetAt = now2 + windowMs;
+      } else {
+        entry.count++;
+      }
+      this._result.count = entry.count;
+      this._result.resetAt = entry.resetAt;
+      return this._result;
     }
     const now = Date.now();
     const resetAt = now + windowMs;
-    const timeoutId = setTimeout(() => {
-      this.hits.delete(key);
-    }, windowMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.hits.set(key, { count: 1, resetAt, timeoutId });
-    return { count: 1, resetAt };
+    this.hits.set(key, { count: 1, resetAt });
+    this._result.count = 1;
+    this._result.resetAt = resetAt;
+    return this._result;
   }
   isBanned(key) {
     const ban = this.bans.get(key);
     if (!ban)
       return false;
     if (Date.now() >= ban.expiresAt) {
-      clearTimeout(ban.timeoutId);
       this.bans.delete(key);
       return false;
     }
     return true;
   }
   ban(key, durationMs) {
-    const existing = this.bans.get(key);
-    if (existing)
-      clearTimeout(existing.timeoutId);
     const expiresAt = Date.now() + durationMs;
-    const timeoutId = setTimeout(() => {
-      this.bans.delete(key);
-    }, durationMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.bans.set(key, { expiresAt, timeoutId });
+    this.bans.set(key, { expiresAt });
   }
   recordViolation(key, windowMs) {
     const entry = this.violations.get(key);
@@ -52,47 +68,19 @@ class MemoryStore {
       entry.count++;
       return entry.count;
     }
-    if (entry)
-      clearTimeout(entry.timeoutId);
     const resetAt = Date.now() + windowMs;
-    const timeoutId = setTimeout(() => {
-      this.violations.delete(key);
-    }, windowMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.violations.set(key, { count: 1, resetAt, timeoutId });
+    this.violations.set(key, { count: 1, resetAt });
     return 1;
   }
   reset(key) {
-    const entry = this.hits.get(key);
-    if (entry) {
-      clearTimeout(entry.timeoutId);
-      this.hits.delete(key);
-    }
-    const ban = this.bans.get(key);
-    if (ban) {
-      clearTimeout(ban.timeoutId);
-      this.bans.delete(key);
-    }
-    const violation = this.violations.get(key);
-    if (violation) {
-      clearTimeout(violation.timeoutId);
-      this.violations.delete(key);
-    }
+    this.hits.delete(key);
+    this.bans.delete(key);
+    this.violations.delete(key);
   }
   shutdown() {
-    for (const [, entry] of this.hits) {
-      clearTimeout(entry.timeoutId);
-    }
+    clearInterval(this.sweepInterval);
     this.hits.clear();
-    for (const [, entry] of this.bans) {
-      clearTimeout(entry.timeoutId);
-    }
     this.bans.clear();
-    for (const [, entry] of this.violations) {
-      clearTimeout(entry.timeoutId);
-    }
     this.violations.clear();
   }
 }

package/dist/stores/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/stores/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAA;AAiJ3E,wBAAgB,WAAW,IAAI,aAAa,CAE3C"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/stores/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAA;AA2G3E,wBAAgB,WAAW,IAAI,aAAa,CAE3C"}

package/dist/stores/memory.js

@@ -5,46 +5,62 @@ class MemoryStore {
   hits = new Map;
   bans = new Map;
   violations = new Map;
+  _result = { count: 0, resetAt: 0 };
+  sweepInterval;
+  constructor() {
+    this.sweepInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [key, entry] of this.hits) {
+        if (now >= entry.resetAt)
+          this.hits.delete(key);
+      }
+      for (const [key, ban] of this.bans) {
+        if (now >= ban.expiresAt)
+          this.bans.delete(key);
+      }
+      for (const [key, violation] of this.violations) {
+        if (now >= violation.resetAt)
+          this.violations.delete(key);
+      }
+    }, 1e4);
+    if (typeof this.sweepInterval.unref === "function") {
+      this.sweepInterval.unref();
+    }
+  }
   hit(key, windowMs, _limit) {
     const entry = this.hits.get(key);
     if (entry !== undefined) {
-      entry.count++;
-      return { count: entry.count, resetAt: entry.resetAt };
+      const now2 = Date.now();
+      if (now2 >= entry.resetAt) {
+        entry.count = 1;
+        entry.resetAt = now2 + windowMs;
+      } else {
+        entry.count++;
+      }
+      this._result.count = entry.count;
+      this._result.resetAt = entry.resetAt;
+      return this._result;
     }
     const now = Date.now();
     const resetAt = now + windowMs;
-    const timeoutId = setTimeout(() => {
-      this.hits.delete(key);
-    }, windowMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.hits.set(key, { count: 1, resetAt, timeoutId });
-    return { count: 1, resetAt };
+    this.hits.set(key, { count: 1, resetAt });
+    this._result.count = 1;
+    this._result.resetAt = resetAt;
+    return this._result;
   }
   isBanned(key) {
     const ban = this.bans.get(key);
     if (!ban)
       return false;
     if (Date.now() >= ban.expiresAt) {
-      clearTimeout(ban.timeoutId);
       this.bans.delete(key);
       return false;
     }
     return true;
   }
   ban(key, durationMs) {
-    const existing = this.bans.get(key);
-    if (existing)
-      clearTimeout(existing.timeoutId);
     const expiresAt = Date.now() + durationMs;
-    const timeoutId = setTimeout(() => {
-      this.bans.delete(key);
-    }, durationMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.bans.set(key, { expiresAt, timeoutId });
+    this.bans.set(key, { expiresAt });
   }
   recordViolation(key, windowMs) {
     const entry = this.violations.get(key);
@@ -52,47 +68,19 @@ class MemoryStore {
       entry.count++;
       return entry.count;
     }
-    if (entry)
-      clearTimeout(entry.timeoutId);
     const resetAt = Date.now() + windowMs;
-    const timeoutId = setTimeout(() => {
-      this.violations.delete(key);
-    }, windowMs);
-    if (typeof timeoutId.unref === "function") {
-      timeoutId.unref();
-    }
-    this.violations.set(key, { count: 1, resetAt, timeoutId });
+    this.violations.set(key, { count: 1, resetAt });
     return 1;
   }
   reset(key) {
-    const entry = this.hits.get(key);
-    if (entry) {
-      clearTimeout(entry.timeoutId);
-      this.hits.delete(key);
-    }
-    const ban = this.bans.get(key);
-    if (ban) {
-      clearTimeout(ban.timeoutId);
-      this.bans.delete(key);
-    }
-    const violation = this.violations.get(key);
-    if (violation) {
-      clearTimeout(violation.timeoutId);
-      this.violations.delete(key);
-    }
+    this.hits.delete(key);
+    this.bans.delete(key);
+    this.violations.delete(key);
   }
   shutdown() {
-    for (const [, entry] of this.hits) {
-      clearTimeout(entry.timeoutId);
-    }
+    clearInterval(this.sweepInterval);
     this.hits.clear();
-    for (const [, entry] of this.bans) {
-      clearTimeout(entry.timeoutId);
-    }
     this.bans.clear();
-    for (const [, entry] of this.violations) {
-      clearTimeout(entry.timeoutId);
-    }
     this.violations.clear();
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joint-ops/hitlimit-bun",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Ultra-fast Bun-native rate limiting - Memory-first with 6M+ ops/sec for Bun.serve, Elysia & Hono",
   "author": {
     "name": "Shayan M Hussain",
@@ -117,7 +117,7 @@
     "test:watch": "bun test --watch"
   },
   "dependencies": {
-    "@joint-ops/hitlimit-types": "1.1.1"
+    "@joint-ops/hitlimit-types": "1.1.2"
   },
   "peerDependencies": {
     "elysia": ">=1.0.0",