@joint-ops/hitlimit-bun 1.3.0 → 1.4.0

package/README.md

@@ -2,7 +2,9 @@
 
 > Rate limiting built for Bun. Not ported — built.
 
-**12.38M ops/sec** on memory. **8.32M at 10K IPs**. Native bun:sqlite. Atomic Redis Lua. Postgres. Zero dependencies.
+<!-- BENCH:BUN_HERO -->
+**7.73M ops/sec** on memory. **5.57M at 10K IPs**. Native bun:sqlite. Atomic Redis Lua. Postgres. Zero dependencies.
+<!-- /BENCH:BUN_HERO -->
 
 ```bash
 bun add @joint-ops/hitlimit-bun
@@ -94,80 +96,123 @@ new Elysia()
 
 ---
 
-## 6 Storage Backends
+## Pick Your Store
 
-All built in. No extra packages to install.
+Every store is built in. Swap one line — your rate limiting code stays the same.
 
-| Store | Best For | Peer Dependency |
-|---|---|---|
-| Memory | Development, single server | None |
-| bun:sqlite | Single server + persistence | None (built-in) |
-| Redis | Distributed, production | `ioredis` |
-| **Valkey** | **Distributed, open-source Redis alternative** | `ioredis` |
-| **DragonflyDB** | **High-throughput distributed** | `ioredis` |
-| PostgreSQL | Shared database infrastructure | `pg` |
+```
+               Single Server                          Multi-Server
+          ┌──────────────────────┐          ┌──────────────────────────┐
+          │  Memory  │  SQLite   │          │  Redis   │  Postgres    │
+          │  (default) (bun:sqlite)         │  Valkey  │  MongoDB     │
+          │                      │          │  Dragonfly  MySQL       │
+          └──────────────────────┘          └──────────────────────────┘
+             No dependencies at all            Your existing infra, zero lock-in
+```
+
+<!-- BENCH:BUN_STORE_TABLE -->
+| Store | Ops/sec | Latency | When to use |
+|-------|---------|---------|-------------|
+| Memory | 5,574,103 | 179ns | Single server, maximum speed |
+| bun:sqlite | 372,247 | 2.7μs | Single server, need persistence |
+| MongoDB | 2,132 | 469μs | Multi-server / NoSQL infrastructure |
+<!-- /BENCH:BUN_STORE_TABLE -->
+
+> Redis, Valkey, DragonflyDB, Postgres, and MySQL are network-bound (~200–3,500 ops/sec). Benchmarks at [hitlimit.jointops.dev/docs/benchmarks](https://hitlimit.jointops.dev/docs/benchmarks).
+
+### The pattern is always the same
 
 ```typescript
 import { hitlimit } from '@joint-ops/hitlimit-bun'
+import { ______Store } from '@joint-ops/hitlimit-bun/stores/______'
 
-// Memory (default) — fastest, no config
-Bun.serve({ fetch: hitlimit({}, handler) })
+Bun.serve({ fetch: hitlimit({ store: ______Store({ /* config */ }) }, handler) })
+```
 
-// bun:sqlite — persists across restarts, native performance
+<details>
+<summary><b>Memory</b> — default, zero config</summary>
+
+```typescript
+Bun.serve({ fetch: hitlimit({}, handler) }) // that's it
+```
+</details>
+
+<details>
+<summary><b>bun:sqlite</b> — native, no N-API, no FFI, survives restarts</summary>
+
+```typescript
 import { sqliteStore } from '@joint-ops/hitlimit-bun'
 Bun.serve({ fetch: hitlimit({ store: sqliteStore({ path: './ratelimit.db' }) }, handler) })
+```
+No peer dependency — `bun:sqlite` is built into Bun.
+</details>
 
-// Redis — distributed, atomic Lua scripts
+<details>
+<summary><b>Redis</b> — distributed, atomic Lua scripts</summary>
+
+```typescript
 import { redisStore } from '@joint-ops/hitlimit-bun/stores/redis'
 Bun.serve({ fetch: hitlimit({ store: redisStore({ url: 'redis://localhost:6379' }) }, handler) })
+```
+Peer dep: `ioredis`
+</details>
+
+<details>
+<summary><b>Valkey</b> — open-source Redis fork, drop-in replacement</summary>
 
-// Valkey — open-source Redis alternative
+```typescript
 import { valkeyStore } from '@joint-ops/hitlimit-bun/stores/valkey'
 Bun.serve({ fetch: hitlimit({ store: valkeyStore({ url: 'redis://localhost:6379' }) }, handler) })
+```
+Peer dep: `ioredis`
+</details>
+
+<details>
+<summary><b>DragonflyDB</b> — Redis-compatible, higher throughput</summary>
 
-// DragonflyDB — high-throughput Redis alternative
+```typescript
 import { dragonflyStore } from '@joint-ops/hitlimit-bun/stores/dragonfly'
 Bun.serve({ fetch: hitlimit({ store: dragonflyStore({ url: 'redis://localhost:6379' }) }, handler) })
+```
+Peer dep: `ioredis`
+</details>
 
-// Postgres — distributed, atomic upserts
+<details>
+<summary><b>PostgreSQL</b> — use your existing database</summary>
+
+```typescript
 import { postgresStore } from '@joint-ops/hitlimit-bun/stores/postgres'
 Bun.serve({ fetch: hitlimit({ store: postgresStore({ url: 'postgres://localhost:5432/mydb' }) }, handler) })
 ```
+Peer dep: `pg`
+</details>
 
-| Store | Ops/sec | Latency | When to use |
-|-------|---------|---------|-------------|
-| Memory | 8,320,000 | 120ns | Single server, maximum speed |
-| bun:sqlite | 325,000 | 3.1μs | Single server, need persistence |
-| Redis | 6,700 | 148μs | Multi-server / distributed |
-| Postgres | 3,700 | 273μs | Multi-server / already using Postgres |
+<details>
+<summary><b>MongoDB</b> — NoSQL, TTL indexes, MEAN/MERN stacks</summary>
 
-### Valkey (Redis Alternative)
 ```typescript
-import { hitlimit } from '@joint-ops/hitlimit-bun'
-import { valkeyStore } from '@joint-ops/hitlimit-bun/stores/valkey'
+import { mongoStore } from '@joint-ops/hitlimit-bun/stores/mongodb'
+import { MongoClient } from 'mongodb'
 
-Bun.serve({
-  fetch: hitlimit({
-    store: valkeyStore({ url: 'redis://localhost:6379' }),
-    limit: 100,
-    window: '1m'
-  }, handler)
-})
+const client = new MongoClient('mongodb://localhost:27017')
+const db = client.db('myapp')
+Bun.serve({ fetch: hitlimit({ store: mongoStore({ db }) }, handler) })
 ```
+Peer dep: `mongodb`
+</details>
+
+<details>
+<summary><b>MySQL</b> — SQL distributed, LAMP stacks</summary>
 
-### DragonflyDB
 ```typescript
-import { hitlimit } from '@joint-ops/hitlimit-bun'
-import { dragonflyStore } from '@joint-ops/hitlimit-bun/stores/dragonfly'
+import { mysqlStore } from '@joint-ops/hitlimit-bun/stores/mysql'
+import mysql from 'mysql2/promise'
 
-Bun.serve({
-  fetch: hitlimit({
-    store: dragonflyStore({ url: 'redis://localhost:6379' }),
-    limit: 100,
-    window: '1m'
-  }, handler)
-})
+const pool = mysql.createPool('mysql://root@localhost:3306/mydb')
+Bun.serve({ fetch: hitlimit({ store: mysqlStore({ pool }) }, handler) })
 ```
+Peer dep: `mysql2`
+</details>
 
 ---
 
@@ -175,14 +220,18 @@ Bun.serve({
 
 ### Bun vs Node.js — Memory Store, 10K unique IPs
 
+<!-- BENCH:BUN_VS_NODE_TABLE -->
 | Runtime | Ops/sec | |
 |---------|---------|---|
-| **Bun** | **8,320,000** | ████████████████████ |
-| Node.js | 3,160,000 | ████████ |
+| **Bun** | **5,574,103** | ████████████████████ |
+| Node.js | 4,082,874 | ███████████████ |
+<!-- /BENCH:BUN_VS_NODE_TABLE -->
 
-Bun leads at 10K IPs (8.32M vs 3.16M) and single-IP (12.38M vs 4.83M). Same library, same algorithm, **memory store**. For Redis, Postgres, and cross-store breakdowns, see the [full benchmark results](https://github.com/JointOps/hitlimit-monorepo/tree/main/benchmarks). Controlled-environment microbenchmarks with transparent methodology. Run them yourself.
+<!-- BENCH:BUN_VS_NODE_TEXT -->
+Bun leads at 10K IPs (5.57M vs 4.08M) and single-IP (7.73M vs 5.96M). Same library, same algorithm, **memory store**. For Redis, Postgres, and cross-store breakdowns, see the [full benchmark results](https://github.com/JointOps/hitlimit-monorepo/tree/main/benchmarks). Controlled-environment microbenchmarks with transparent methodology. Run them yourself.
+<!-- /BENCH:BUN_VS_NODE_TEXT -->
 
-### Why bun:sqlite is faster than better-sqlite3
+### Why bun:sqlite doesn't need bindings
 
 ```
 Node.js: JS → N-API → C++ binding → SQLite

package/dist/stores/mongodb.d.ts

@@ -0,0 +1,11 @@
+import type { HitLimitStore } from '@joint-ops/hitlimit-types';
+export interface MongoStoreOptions {
+    /** MongoDB Db instance (from MongoClient.db()) */
+    db: any;
+    /** Collection name prefix. Default: 'hitlimit' */
+    collectionPrefix?: string;
+    /** Skip TTL index creation (if you manage indexes yourself). Default: false */
+    skipIndexCreation?: boolean;
+}
+export declare function mongoStore(options: MongoStoreOptions): HitLimitStore;
+//# sourceMappingURL=mongodb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb.d.ts","sourceRoot":"","sources":["../../src/stores/mongodb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAiC,MAAM,2BAA2B,CAAA;AAE7F,MAAM,WAAW,iBAAiB;IAChC,kDAAkD;IAClD,EAAE,EAAE,GAAG,CAAA;IACP,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AA+KD,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,aAAa,CAEpE"}

package/dist/stores/mongodb.js

@@ -0,0 +1,133 @@
+// @bun
+// src/stores/mongodb.ts
+class MongoStore {
+  db;
+  prefix;
+  indexesReady = null;
+  ready;
+  constructor(options) {
+    this.db = options.db;
+    this.prefix = options.collectionPrefix ?? "hitlimit";
+    if (options.skipIndexCreation) {
+      this.ready = true;
+    } else {
+      this.ready = false;
+      this.indexesReady = this.createIndexes().then(() => {
+        this.ready = true;
+      });
+    }
+  }
+  col(name) {
+    return this.db.collection(`${this.prefix}_${name}`);
+  }
+  async createIndexes() {
+    await this.col("hits").createIndex({ expireAt: 1 }, { expireAfterSeconds: 0 });
+    await this.col("bans").createIndex({ expireAt: 1 }, { expireAfterSeconds: 0 });
+    await this.col("violations").createIndex({ expireAt: 1 }, { expireAfterSeconds: 0 });
+    await this.col("hits").createIndex({ key: 1 }, { unique: true });
+    await this.col("bans").createIndex({ key: 1 }, { unique: true });
+    await this.col("violations").createIndex({ key: 1 }, { unique: true });
+  }
+  async atomicIncrement(collection, key, windowMs) {
+    const now = Date.now();
+    const resetAt = now + windowMs;
+    const expireAt = new Date(resetAt);
+    try {
+      const result = await collection.findOneAndUpdate({ key, resetAt: { $gt: now } }, {
+        $inc: { count: 1 },
+        $setOnInsert: { key, resetAt, expireAt }
+      }, { upsert: true, returnDocument: "after" });
+      return { count: result.count, resetAt: result.resetAt };
+    } catch (err) {
+      if (err?.code === 11000) {
+        const replaced = await collection.findOneAndUpdate({ key, resetAt: { $lte: now } }, { $set: { count: 1, resetAt, expireAt } }, { returnDocument: "after" });
+        if (replaced) {
+          return { count: replaced.count, resetAt: replaced.resetAt };
+        }
+        return this.atomicIncrement(collection, key, windowMs);
+      }
+      throw err;
+    }
+  }
+  async hit(key, windowMs, _limit) {
+    if (!this.ready)
+      await this.indexesReady;
+    return this.atomicIncrement(this.col("hits"), key, windowMs);
+  }
+  async hitWithBan(key, windowMs, limit, banThreshold, banDurationMs) {
+    if (!this.ready)
+      await this.indexesReady;
+    const now = Date.now();
+    const resetAt = now + windowMs;
+    const banExpiresAt = now + banDurationMs;
+    const ban = await this.col("bans").findOne({ key, expiresAt: { $gt: now } });
+    if (ban) {
+      return {
+        count: 0,
+        resetAt,
+        banned: true,
+        violations: 0,
+        banExpiresAt: ban.expiresAt
+      };
+    }
+    const hitResult = await this.atomicIncrement(this.col("hits"), key, windowMs);
+    const hitCount = hitResult.count;
+    const hitResetAt = hitResult.resetAt;
+    if (hitCount > limit) {
+      const violationResult = await this.atomicIncrement(this.col("violations"), key, banDurationMs);
+      const violations = violationResult.count;
+      const shouldBan = violations >= banThreshold;
+      if (shouldBan) {
+        await this.col("bans").updateOne({ key }, { $set: { expiresAt: banExpiresAt, expireAt: new Date(banExpiresAt) } }, { upsert: true });
+      }
+      return {
+        count: hitCount,
+        resetAt: hitResetAt,
+        banned: shouldBan,
+        violations,
+        banExpiresAt: shouldBan ? banExpiresAt : 0
+      };
+    }
+    return {
+      count: hitCount,
+      resetAt: hitResetAt,
+      banned: false,
+      violations: 0,
+      banExpiresAt: 0
+    };
+  }
+  async isBanned(key) {
+    if (!this.ready)
+      await this.indexesReady;
+    const ban = await this.col("bans").findOne({ key, expiresAt: { $gt: Date.now() } });
+    return ban !== null;
+  }
+  async ban(key, durationMs) {
+    if (!this.ready)
+      await this.indexesReady;
+    const expiresAt = Date.now() + durationMs;
+    await this.col("bans").updateOne({ key }, { $set: { expiresAt, expireAt: new Date(expiresAt) } }, { upsert: true });
+  }
+  async recordViolation(key, windowMs) {
+    if (!this.ready)
+      await this.indexesReady;
+    const result = await this.atomicIncrement(this.col("violations"), key, windowMs);
+    return result.count;
+  }
+  async reset(key) {
+    if (!this.ready)
+      await this.indexesReady;
+    await Promise.all([
+      this.col("hits").deleteOne({ key }),
+      this.col("bans").deleteOne({ key }),
+      this.col("violations").deleteOne({ key })
+    ]);
+  }
+  shutdown() {}
+}
+function mongoStore(options) {
+  return new MongoStore(options);
+}
+export {
+  mongoStore
+};

package/dist/stores/mysql.d.ts

@@ -0,0 +1,13 @@
+import type { HitLimitStore } from '@joint-ops/hitlimit-types';
+export interface MySQLStoreOptions {
+    /** mysql2/promise Pool instance */
+    pool: any;
+    /** Table name prefix. Default: 'hitlimit' */
+    tablePrefix?: string;
+    /** Cleanup interval in ms. Default: 60000 (1 minute) */
+    cleanupInterval?: number;
+    /** Skip table creation (if you manage schema yourself). Default: false */
+    skipTableCreation?: boolean;
+}
+export declare function mysqlStore(options: MySQLStoreOptions): HitLimitStore;
+//# sourceMappingURL=mysql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../src/stores/mysql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAiC,MAAM,2BAA2B,CAAA;AAE7F,MAAM,WAAW,iBAAiB;IAChC,mCAAmC;IACnC,IAAI,EAAE,GAAG,CAAA;IACT,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,wDAAwD;IACxD,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,0EAA0E;IAC1E,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AA2ND,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,aAAa,CAEpE"}

package/dist/stores/mysql.js

@@ -0,0 +1,195 @@
+// @bun
+// src/stores/mysql.ts
+class MySQLStore {
+  pool;
+  prefix;
+  cleanupTimer = null;
+  tablesReady = null;
+  ready;
+  constructor(options) {
+    this.pool = options.pool;
+    this.prefix = options.tablePrefix ?? "hitlimit";
+    if (options.skipTableCreation) {
+      this.ready = true;
+    } else {
+      this.ready = false;
+      this.tablesReady = this.createTables().then(() => {
+        this.ready = true;
+      });
+    }
+    const interval = options.cleanupInterval ?? 60000;
+    this.cleanupTimer = setInterval(() => this.cleanup(), interval);
+    if (typeof this.cleanupTimer.unref === "function") {
+      this.cleanupTimer.unref();
+    }
+  }
+  async createTables() {
+    await this.pool.execute(`
+      CREATE TABLE IF NOT EXISTS ${this.prefix}_hits (
+        \`key\` VARCHAR(255) NOT NULL PRIMARY KEY,
+        count INT NOT NULL DEFAULT 1,
+        reset_at BIGINT NOT NULL
+      ) ENGINE=InnoDB
+    `);
+    await this.pool.execute(`
+      CREATE TABLE IF NOT EXISTS ${this.prefix}_bans (
+        \`key\` VARCHAR(255) NOT NULL PRIMARY KEY,
+        expires_at BIGINT NOT NULL
+      ) ENGINE=InnoDB
+    `);
+    await this.pool.execute(`
+      CREATE TABLE IF NOT EXISTS ${this.prefix}_violations (
+        \`key\` VARCHAR(255) NOT NULL PRIMARY KEY,
+        count INT NOT NULL DEFAULT 1,
+        reset_at BIGINT NOT NULL
+      ) ENGINE=InnoDB
+    `);
+  }
+  async hit(key, windowMs, _limit) {
+    if (!this.ready)
+      await this.tablesReady;
+    const now = Date.now();
+    const resetAt = now + windowMs;
+    const conn = await this.pool.getConnection();
+    try {
+      await conn.execute(`
+        INSERT INTO ${this.prefix}_hits (\`key\`, count, reset_at)
+        VALUES (?, LAST_INSERT_ID(1), ?)
+        ON DUPLICATE KEY UPDATE
+          count = LAST_INSERT_ID(IF(reset_at <= ?, 1, count + 1)),
+          reset_at = IF(reset_at <= ?, ?, reset_at)
+      `, [key, resetAt, now, now, resetAt]);
+      const [rows] = await conn.execute(`SELECT LAST_INSERT_ID() AS count, reset_at FROM ${this.prefix}_hits WHERE \`key\` = ?`, [key]);
+      return { count: Number(rows[0].count), resetAt: Number(rows[0].reset_at) };
+    } finally {
+      conn.release();
+    }
+  }
+  async hitWithBan(key, windowMs, limit, banThreshold, banDurationMs) {
+    if (!this.ready)
+      await this.tablesReady;
+    const now = Date.now();
+    const resetAt = now + windowMs;
+    const banExpiresAt = now + banDurationMs;
+    const [banRows] = await this.pool.execute(`SELECT expires_at FROM ${this.prefix}_bans WHERE \`key\` = ? AND expires_at > ?`, [key, now]);
+    if (banRows.length > 0) {
+      return {
+        count: 0,
+        resetAt,
+        banned: true,
+        violations: 0,
+        banExpiresAt: Number(banRows[0].expires_at)
+      };
+    }
+    const conn = await this.pool.getConnection();
+    try {
+      await conn.execute(`
+        INSERT INTO ${this.prefix}_hits (\`key\`, count, reset_at)
+        VALUES (?, LAST_INSERT_ID(1), ?)
+        ON DUPLICATE KEY UPDATE
+          count = LAST_INSERT_ID(IF(reset_at <= ?, 1, count + 1)),
+          reset_at = IF(reset_at <= ?, ?, reset_at)
+      `, [key, resetAt, now, now, resetAt]);
+      const [hitRows] = await conn.execute(`SELECT LAST_INSERT_ID() AS count, reset_at FROM ${this.prefix}_hits WHERE \`key\` = ?`, [key]);
+      const hitCount = Number(hitRows[0].count);
+      const hitResetAt = Number(hitRows[0].reset_at);
+      if (hitCount > limit) {
+        await conn.execute(`
+          INSERT INTO ${this.prefix}_violations (\`key\`, count, reset_at)
+          VALUES (?, LAST_INSERT_ID(1), ?)
+          ON DUPLICATE KEY UPDATE
+            count = LAST_INSERT_ID(IF(reset_at <= ?, 1, count + 1)),
+            reset_at = IF(reset_at <= ?, ?, reset_at)
+        `, [key, banExpiresAt, now, now, banExpiresAt]);
+        const [violRows] = await conn.execute(`SELECT LAST_INSERT_ID() AS count FROM ${this.prefix}_violations WHERE \`key\` = ?`, [key]);
+        const violations = Number(violRows[0].count);
+        const shouldBan = violations >= banThreshold;
+        if (shouldBan) {
+          await conn.execute(`
+            INSERT INTO ${this.prefix}_bans (\`key\`, expires_at) VALUES (?, ?)
+            ON DUPLICATE KEY UPDATE expires_at = ?
+          `, [key, banExpiresAt, banExpiresAt]);
+        }
+        return {
+          count: hitCount,
+          resetAt: hitResetAt,
+          banned: shouldBan,
+          violations,
+          banExpiresAt: shouldBan ? banExpiresAt : 0
+        };
+      }
+      return {
+        count: hitCount,
+        resetAt: hitResetAt,
+        banned: false,
+        violations: 0,
+        banExpiresAt: 0
+      };
+    } finally {
+      conn.release();
+    }
+  }
+  async isBanned(key) {
+    if (!this.ready)
+      await this.tablesReady;
+    const [rows] = await this.pool.execute(`SELECT 1 FROM ${this.prefix}_bans WHERE \`key\` = ? AND expires_at > ?`, [key, Date.now()]);
+    return rows.length > 0;
+  }
+  async ban(key, durationMs) {
+    if (!this.ready)
+      await this.tablesReady;
+    const expiresAt = Date.now() + durationMs;
+    await this.pool.execute(`
+      INSERT INTO ${this.prefix}_bans (\`key\`, expires_at) VALUES (?, ?)
+      ON DUPLICATE KEY UPDATE expires_at = ?
+    `, [key, expiresAt, expiresAt]);
+  }
+  async recordViolation(key, windowMs) {
+    if (!this.ready)
+      await this.tablesReady;
+    const now = Date.now();
+    const resetAt = now + windowMs;
+    const conn = await this.pool.getConnection();
+    try {
+      await conn.execute(`
+        INSERT INTO ${this.prefix}_violations (\`key\`, count, reset_at) VALUES (?, LAST_INSERT_ID(1), ?)
+        ON DUPLICATE KEY UPDATE
+          count = LAST_INSERT_ID(IF(reset_at <= ?, 1, count + 1)),
+          reset_at = IF(reset_at <= ?, ?, reset_at)
+      `, [key, resetAt, now, now, resetAt]);
+      const [rows] = await conn.execute(`SELECT LAST_INSERT_ID() AS count FROM ${this.prefix}_violations WHERE \`key\` = ?`, [key]);
+      return Number(rows[0].count);
+    } finally {
+      conn.release();
+    }
+  }
+  async reset(key) {
+    if (!this.ready)
+      await this.tablesReady;
+    await Promise.all([
+      this.pool.execute(`DELETE FROM ${this.prefix}_hits WHERE \`key\` = ?`, [key]),
+      this.pool.execute(`DELETE FROM ${this.prefix}_bans WHERE \`key\` = ?`, [key]),
+      this.pool.execute(`DELETE FROM ${this.prefix}_violations WHERE \`key\` = ?`, [key])
+    ]);
+  }
+  async cleanup() {
+    try {
+      const now = Date.now();
+      await this.pool.execute(`DELETE FROM ${this.prefix}_hits WHERE reset_at <= ?`, [now]);
+      await this.pool.execute(`DELETE FROM ${this.prefix}_bans WHERE expires_at <= ?`, [now]);
+      await this.pool.execute(`DELETE FROM ${this.prefix}_violations WHERE reset_at <= ?`, [now]);
+    } catch {}
+  }
+  shutdown() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+}
+function mysqlStore(options) {
+  return new MySQLStore(options);
+}
+export {
+  mysqlStore
+};

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

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/stores/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAA;AAE3E,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAgHD,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,aAAa,CAEvE"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/stores/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAA;AAE3E,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAiHD,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,aAAa,CAEvE"}

package/dist/stores/sqlite.js

@@ -17,6 +17,7 @@ class BunSqliteStore {
   cleanupTimer;
   constructor(options = {}) {
     this.db = new Database(options.path ?? ":memory:");
+    this.db.exec("PRAGMA journal_mode = WAL");
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS hitlimit (
         key TEXT PRIMARY KEY,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joint-ops/hitlimit-bun",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Ultra-fast Bun-native rate limiting - Memory-first with 6M+ ops/sec for Bun.serve, Elysia & Hono",
   "author": {
     "name": "Shayan M Hussain",
@@ -23,6 +23,14 @@
     {
       "name": "sultandilaram",
       "url": "https://github.com/sultandilaram"
+    },
+    {
+      "name": "MoizYousuf",
+      "url": "https://github.com/MoizYousuf"
+    },
+    {
+      "name": "shoaib-tumi",
+      "url": "https://github.com/shoaib-tumi"
     }
   ],
   "license": "MIT",
@@ -92,7 +100,14 @@
     "dragonfly",
     "dragonflydb",
     "dragonfly-rate-limit",
-    "redis-alternative"
+    "redis-alternative",
+    "mongodb",
+    "mongodb-rate-limit",
+    "mongoose-rate-limit",
+    "mysql",
+    "mysql-rate-limit",
+    "mysql2-rate-limit",
+    "database-rate-limit"
   ],
   "type": "module",
   "main": "./dist/index.js",
@@ -143,6 +158,16 @@
       "types": "./dist/stores/dragonfly.d.ts",
       "bun": "./dist/stores/dragonfly.js",
       "import": "./dist/stores/dragonfly.js"
+    },
+    "./stores/mongodb": {
+      "types": "./dist/stores/mongodb.d.ts",
+      "bun": "./dist/stores/mongodb.js",
+      "import": "./dist/stores/mongodb.js"
+    },
+    "./stores/mysql": {
+      "types": "./dist/stores/mysql.d.ts",
+      "bun": "./dist/stores/mysql.js",
+      "import": "./dist/stores/mysql.js"
     }
   },
   "files": [
@@ -150,18 +175,20 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "build": "bun build ./src/index.ts ./src/elysia.ts ./src/hono.ts ./src/stores/memory.ts ./src/stores/redis.ts ./src/stores/sqlite.ts ./src/stores/postgres.ts ./src/stores/valkey.ts ./src/stores/dragonfly.ts --outdir=./dist --root=./src --target=bun --external=elysia --external=hono --external=ioredis --external=pg --external=@sinclair/typebox && tsc --emitDeclarationOnly",
+    "build": "bun build ./src/index.ts ./src/elysia.ts ./src/hono.ts ./src/stores/memory.ts ./src/stores/redis.ts ./src/stores/sqlite.ts ./src/stores/postgres.ts ./src/stores/valkey.ts ./src/stores/dragonfly.ts ./src/stores/mongodb.ts ./src/stores/mysql.ts --outdir=./dist --root=./src --target=bun --external=elysia --external=hono --external=ioredis --external=pg --external=mongodb --external=mysql2 --external=@sinclair/typebox && tsc --emitDeclarationOnly",
     "clean": "rm -rf dist",
     "test": "bun test",
     "test:watch": "bun test --watch"
   },
   "dependencies": {
-    "@joint-ops/hitlimit-types": "1.3.0"
+    "@joint-ops/hitlimit-types": "1.4.0"
   },
   "peerDependencies": {
     "elysia": ">=1.0.0",
     "hono": ">=4.0.0",
     "ioredis": ">=5.0.0",
+    "mongodb": ">=6.0.0",
+    "mysql2": ">=3.0.0",
     "pg": ">=8.0.0"
   },
   "peerDependenciesMeta": {
@@ -174,6 +201,12 @@
     "ioredis": {
       "optional": true
     },
+    "mongodb": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
     "pg": {
       "optional": true
     }
@@ -185,6 +218,8 @@
     "elysia": "^1.0.0",
     "hono": "^4.11.9",
     "ioredis": "^5.3.0",
+    "mongodb": "^7.1.0",
+    "mysql2": "^3.18.2",
     "pg": "^8.13.0",
     "typescript": "^5.3.0"
   }