@http-client-toolkit/store-sqlite 0.0.1

package/lib/index.js

@@ -0,0 +1,1299 @@
+import Database from 'better-sqlite3';
+import { sql, eq, count, and, gt, lt, gte } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { sqliteTable, integer, blob, text } from 'drizzle-orm/sqlite-core';
+import { randomUUID } from 'crypto';
+import { DEFAULT_RATE_LIMIT, AdaptiveCapacityCalculator } from '@http-client-toolkit/core';
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var cacheTable = sqliteTable("cache", {
+  hash: text("hash").primaryKey(),
+  value: blob("value", { mode: "json" }).notNull(),
+  expiresAt: integer("expires_at").notNull(),
+  createdAt: integer("created_at").notNull()
+});
+var dedupeTable = sqliteTable("dedupe_jobs", {
+  hash: text("hash").primaryKey(),
+  jobId: text("job_id").notNull(),
+  status: text("status").notNull(),
+  // 'pending', 'completed', 'failed'
+  result: blob("result", { mode: "json" }),
+  error: text("error"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull()
+});
+var rateLimitTable = sqliteTable("rate_limits", {
+  resource: text("resource").notNull(),
+  timestamp: integer("timestamp").notNull(),
+  id: integer("id").primaryKey({ autoIncrement: true })
+});
+
+// src/sqlite-cache-store.ts
+var SQLiteCacheStore = class {
+  constructor({
+    /** File path or existing `better-sqlite3` connection. Defaults to `':memory:'`. */
+    database = ":memory:",
+    /** Cleanup interval in milliseconds. Defaults to 1 minute. */
+    cleanupIntervalMs = 6e4,
+    /** Maximum allowed size (in bytes) for a single cache entry. Defaults to 5 MiB. */
+    maxEntrySizeBytes = 5 * 1024 * 1024
+  } = {}) {
+    /** Indicates whether this store is responsible for managing (and therefore closing) the SQLite connection */
+    this.isConnectionManaged = false;
+    this.isDestroyed = false;
+    let sqliteInstance;
+    let isConnectionManaged = false;
+    if (typeof database === "string") {
+      sqliteInstance = new Database(database);
+      isConnectionManaged = true;
+    } else {
+      sqliteInstance = database;
+    }
+    this.sqlite = sqliteInstance;
+    this.isConnectionManaged = isConnectionManaged;
+    this.db = drizzle(sqliteInstance);
+    this.cleanupIntervalMs = cleanupIntervalMs;
+    this.maxEntrySizeBytes = maxEntrySizeBytes;
+    this.initializeDatabase();
+    this.startCleanupInterval();
+  }
+  get(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Cache store has been destroyed");
+      }
+      const result = yield this.db.select().from(cacheTable).where(eq(cacheTable.hash, hash)).limit(1);
+      if (result.length === 0) {
+        return void 0;
+      }
+      const item = result[0];
+      if (!item) {
+        return void 0;
+      }
+      const now = Date.now();
+      if (item.expiresAt > 0 && now >= item.expiresAt) {
+        yield this.db.delete(cacheTable).where(eq(cacheTable.hash, hash));
+        return void 0;
+      }
+      try {
+        if (item.value === "__UNDEFINED__") {
+          return void 0;
+        }
+        return JSON.parse(item.value);
+      } catch (e) {
+        yield this.db.delete(cacheTable).where(eq(cacheTable.hash, hash));
+        return void 0;
+      }
+    });
+  }
+  set(hash, value, ttlSeconds) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Cache store has been destroyed");
+      }
+      const now = Date.now();
+      const expiresAt = ttlSeconds < 0 ? now : ttlSeconds === 0 ? 0 : now + ttlSeconds * 1e3;
+      let serializedValue;
+      try {
+        if (value === void 0) {
+          serializedValue = "__UNDEFINED__";
+        } else {
+          serializedValue = JSON.stringify(value);
+        }
+      } catch (error) {
+        throw new Error(
+          `Failed to serialize value: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (Buffer.byteLength(serializedValue, "utf8") > this.maxEntrySizeBytes) {
+        return;
+      }
+      yield this.db.insert(cacheTable).values({
+        hash,
+        value: serializedValue,
+        expiresAt,
+        createdAt: now
+      }).onConflictDoUpdate({
+        target: cacheTable.hash,
+        set: {
+          value: serializedValue,
+          expiresAt,
+          createdAt: now
+        }
+      });
+    });
+  }
+  delete(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Cache store has been destroyed");
+      }
+      yield this.db.delete(cacheTable).where(eq(cacheTable.hash, hash));
+    });
+  }
+  clear() {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Cache store has been destroyed");
+      }
+      yield this.db.delete(cacheTable);
+    });
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const now = Date.now();
+      const totalResult = yield this.db.select({ count: count() }).from(cacheTable);
+      const expiredResult = yield this.db.select({ count: count() }).from(cacheTable).where(and(gt(cacheTable.expiresAt, 0), lt(cacheTable.expiresAt, now)));
+      const pageCount = Number(
+        this.sqlite.pragma("page_count", { simple: true })
+      );
+      const pageSize = Number(this.sqlite.pragma("page_size", { simple: true }));
+      const safePageCount = Number.isFinite(pageCount) ? pageCount : 0;
+      const safePageSize = Number.isFinite(pageSize) ? pageSize : 0;
+      const databaseSizeKB = Math.round(safePageCount * safePageSize / 1024);
+      return {
+        databaseSizeKB,
+        expiredItems: (_b = (_a = expiredResult[0]) == null ? void 0 : _a.count) != null ? _b : 0,
+        totalItems: (_d = (_c = totalResult[0]) == null ? void 0 : _c.count) != null ? _d : 0
+      };
+    });
+  }
+  /**
+   * Manually trigger cleanup of expired items
+   */
+  cleanup() {
+    return __async(this, null, function* () {
+      const now = Date.now();
+      yield this.db.delete(cacheTable).where(and(gt(cacheTable.expiresAt, 0), lt(cacheTable.expiresAt, now)));
+    });
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    return __async(this, null, function* () {
+      if (this.cleanupInterval) {
+        clearInterval(this.cleanupInterval);
+        this.cleanupInterval = void 0;
+      }
+      this.isDestroyed = true;
+      if (this.isConnectionManaged && typeof this.sqlite.close === "function") {
+        this.sqlite.close();
+      }
+    });
+  }
+  /**
+   * Alias for close() to match test expectations
+   */
+  destroy() {
+    this.close();
+  }
+  initializeDatabase() {
+    this.db.run(sql`
+      CREATE TABLE IF NOT EXISTS cache (
+        hash TEXT PRIMARY KEY,
+        value BLOB NOT NULL,
+        expires_at INTEGER NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    this.db.run(sql`
+      CREATE INDEX IF NOT EXISTS idx_cache_expires_at ON cache(expires_at)
+    `);
+  }
+  startCleanupInterval() {
+    if (this.cleanupIntervalMs <= 0) {
+      return;
+    }
+    this.cleanupInterval = setInterval(() => __async(this, null, function* () {
+      yield this.cleanup();
+    }), this.cleanupIntervalMs);
+    if (typeof this.cleanupInterval.unref === "function") {
+      this.cleanupInterval.unref();
+    }
+  }
+  cleanupExpiredItems() {
+    return __async(this, null, function* () {
+      const now = Date.now();
+      yield this.db.delete(cacheTable).where(lt(cacheTable.expiresAt, now));
+    });
+  }
+};
+var SQLiteDedupeStore = class {
+  constructor({
+    /** File path or existing `better-sqlite3` Database instance. Defaults to `':memory:'`. */
+    database = ":memory:",
+    /** Job timeout in milliseconds. Preferred over timeoutMs. */
+    jobTimeoutMs,
+    /** Legacy alias for jobTimeoutMs. */
+    timeoutMs,
+    /** Cleanup interval in milliseconds. Defaults to 1 minute. */
+    cleanupIntervalMs = 6e4,
+    /** Poll interval for checking pending jobs in milliseconds. Defaults to 100ms. */
+    pollIntervalMs = 100
+  } = {}) {
+    /** Indicates whether this store manages (and should close) the SQLite connection */
+    this.isConnectionManaged = false;
+    this.jobPromises = /* @__PURE__ */ new Map();
+    this.jobSettlers = /* @__PURE__ */ new Map();
+    this.isDestroyed = false;
+    var _a;
+    let sqliteInstance;
+    let isConnectionManaged = false;
+    if (typeof database === "string") {
+      sqliteInstance = new Database(database);
+      isConnectionManaged = true;
+    } else {
+      sqliteInstance = database;
+    }
+    this.sqlite = sqliteInstance;
+    this.isConnectionManaged = isConnectionManaged;
+    this.db = drizzle(sqliteInstance);
+    this.jobTimeoutMs = (_a = timeoutMs != null ? timeoutMs : jobTimeoutMs) != null ? _a : 3e5;
+    this.cleanupIntervalMs = cleanupIntervalMs;
+    this.pollIntervalMs = pollIntervalMs;
+    this.initializeDatabase();
+    this.startCleanupInterval();
+  }
+  startCleanupInterval() {
+    if (this.cleanupIntervalMs > 0) {
+      this.cleanupInterval = setInterval(() => {
+        this.cleanupExpiredJobs().catch(() => {
+        });
+      }, this.cleanupIntervalMs);
+      if (typeof this.cleanupInterval.unref === "function") {
+        this.cleanupInterval.unref();
+      }
+    }
+  }
+  cleanupExpiredJobs() {
+    return __async(this, null, function* () {
+      const noTimeoutConfigured = this.jobTimeoutMs <= 0;
+      if (noTimeoutConfigured) {
+        return;
+      }
+      const now = Date.now();
+      const expiredThreshold = now - this.jobTimeoutMs;
+      yield this.db.delete(dedupeTable).where(
+        and(
+          eq(dedupeTable.status, "pending"),
+          lt(dedupeTable.createdAt, expiredThreshold)
+        )
+      );
+    });
+  }
+  waitFor(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      const existingPromise = this.jobPromises.get(hash);
+      if (existingPromise) {
+        return existingPromise;
+      }
+      let result;
+      try {
+        result = yield this.db.select().from(dedupeTable).where(eq(dedupeTable.hash, hash)).limit(1);
+      } catch (e) {
+        return void 0;
+      }
+      if (result.length === 0) {
+        return void 0;
+      }
+      const job = result[0];
+      if (!job) {
+        return void 0;
+      }
+      if (job.status === "completed") {
+        return this.deserializeResult(job.result);
+      }
+      if (job.status === "failed") {
+        return void 0;
+      }
+      const promise = new Promise((resolve) => {
+        let settled = false;
+        let timeoutHandle;
+        const settle = (value) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+          }
+          clearInterval(pollHandle);
+          this.jobSettlers.delete(hash);
+          this.jobPromises.delete(hash);
+          resolve(value);
+        };
+        this.jobSettlers.set(hash, settle);
+        const poll = () => __async(this, null, function* () {
+          if (this.isDestroyed) {
+            settle(void 0);
+            return;
+          }
+          try {
+            const latest = yield this.db.select().from(dedupeTable).where(eq(dedupeTable.hash, hash)).limit(1);
+            const latestJob = latest[0];
+            if (!latestJob) {
+              settle(void 0);
+              return;
+            }
+            const isExpired = this.jobTimeoutMs > 0 && Date.now() - latestJob.createdAt >= this.jobTimeoutMs;
+            if (isExpired) {
+              yield this.db.update(dedupeTable).set({
+                status: "failed",
+                error: "Job timed out",
+                updatedAt: Date.now()
+              }).where(eq(dedupeTable.hash, hash));
+              settle(void 0);
+              return;
+            }
+            if (latestJob.status === "completed") {
+              settle(this.deserializeResult(latestJob.result));
+              return;
+            }
+            if (latestJob.status === "failed") {
+              settle(void 0);
+            }
+          } catch (e) {
+            settle(void 0);
+          }
+        });
+        const pollHandle = setInterval(() => {
+          void poll();
+        }, this.pollIntervalMs);
+        if (typeof pollHandle.unref === "function") {
+          pollHandle.unref();
+        }
+        void poll();
+        if (this.jobTimeoutMs > 0) {
+          timeoutHandle = setTimeout(() => {
+            if (this.isDestroyed) {
+              settle(void 0);
+              return;
+            }
+            void (() => __async(this, null, function* () {
+              try {
+                yield this.db.update(dedupeTable).set({
+                  status: "failed",
+                  error: "Job timed out",
+                  updatedAt: Date.now()
+                }).where(eq(dedupeTable.hash, hash));
+              } catch (e) {
+              } finally {
+                settle(void 0);
+              }
+            }))();
+          }, this.jobTimeoutMs);
+          if (typeof timeoutHandle.unref === "function") {
+            timeoutHandle.unref();
+          }
+        }
+      });
+      this.jobPromises.set(hash, promise);
+      return promise;
+    });
+  }
+  register(hash) {
+    return __async(this, null, function* () {
+      const registration = yield this.registerOrJoin(hash);
+      return registration.jobId;
+    });
+  }
+  registerOrJoin(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      const now = Date.now();
+      const candidateJobId = randomUUID();
+      const registerTransaction = this.sqlite.transaction(
+        (requestHash, createdAt, jobId) => {
+          const existing = this.sqlite.prepare(
+            "SELECT job_id as jobId, status FROM dedupe_jobs WHERE hash = ? LIMIT 1"
+          ).get(requestHash);
+          if (existing && existing.status === "pending") {
+            return {
+              jobId: existing.jobId,
+              isOwner: false
+            };
+          }
+          this.sqlite.prepare(
+            `
+            INSERT INTO dedupe_jobs (hash, job_id, status, result, error, created_at, updated_at)
+            VALUES (?, ?, 'pending', NULL, NULL, ?, ?)
+            ON CONFLICT(hash) DO UPDATE SET
+              job_id = excluded.job_id,
+              status = excluded.status,
+              result = NULL,
+              error = NULL,
+              created_at = excluded.created_at,
+              updated_at = excluded.updated_at
+            `
+          ).run(requestHash, jobId, createdAt, createdAt);
+          return {
+            jobId,
+            isOwner: true
+          };
+        }
+      );
+      return registerTransaction(hash, now, candidateJobId);
+    });
+  }
+  complete(hash, value) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      let serializedResult;
+      if (value === void 0) {
+        serializedResult = "__UNDEFINED__";
+      } else if (value === null) {
+        serializedResult = "__NULL__";
+      } else {
+        try {
+          serializedResult = JSON.stringify(value);
+        } catch (error) {
+          throw new Error(
+            `Failed to serialize result: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      const now = Date.now();
+      const existingJob = yield this.db.select().from(dedupeTable).where(eq(dedupeTable.hash, hash)).limit(1);
+      if (existingJob.length > 0 && ((_a = existingJob[0]) == null ? void 0 : _a.status) === "completed") {
+        return;
+      }
+      yield this.db.update(dedupeTable).set({
+        status: "completed",
+        result: serializedResult,
+        updatedAt: now
+      }).where(eq(dedupeTable.hash, hash));
+      const settle = this.jobSettlers.get(hash);
+      if (settle) {
+        settle(value);
+      }
+    });
+  }
+  fail(hash, error) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      const now = Date.now();
+      yield this.db.update(dedupeTable).set({
+        status: "failed",
+        error: error.message,
+        updatedAt: now
+      }).where(eq(dedupeTable.hash, hash));
+      const settle = this.jobSettlers.get(hash);
+      if (settle) {
+        settle(void 0);
+      }
+    });
+  }
+  isInProgress(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      const result = yield this.db.select().from(dedupeTable).where(eq(dedupeTable.hash, hash)).limit(1);
+      if (result.length === 0) {
+        return false;
+      }
+      const job = result[0];
+      if (!job) {
+        return false;
+      }
+      const jobExpired = this.jobTimeoutMs > 0 && Date.now() - job.createdAt >= this.jobTimeoutMs;
+      if (jobExpired) {
+        yield this.db.delete(dedupeTable).where(eq(dedupeTable.hash, hash));
+        return false;
+      }
+      return job.status === "pending";
+    });
+  }
+  getResult(hash) {
+    return __async(this, null, function* () {
+      const result = yield this.db.select().from(dedupeTable).where(eq(dedupeTable.hash, hash)).limit(1);
+      if (result.length === 0) {
+        return void 0;
+      }
+      const job = result[0];
+      if (!job) {
+        return void 0;
+      }
+      const now = Date.now();
+      const isExpired = now - job.createdAt > this.jobTimeoutMs;
+      if (isExpired) {
+        yield this.db.delete(dedupeTable).where(eq(dedupeTable.hash, hash));
+        return void 0;
+      }
+      if (job.status === "completed") {
+        try {
+          if (job.result === "__UNDEFINED__") {
+            return void 0;
+          } else if (job.result === "__NULL__") {
+            return null;
+          } else if (job.result) {
+            return JSON.parse(job.result);
+          }
+          return void 0;
+        } catch (e) {
+          return void 0;
+        }
+      }
+      return void 0;
+    });
+  }
+  /**
+   * Get statistics about dedupe jobs
+   */
+  getStats() {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      const now = Date.now();
+      const expiredTime = now - this.jobTimeoutMs;
+      const totalResult = yield this.db.select({ count: count() }).from(dedupeTable);
+      const pendingResult = yield this.db.select({ count: count() }).from(dedupeTable).where(eq(dedupeTable.status, "pending"));
+      const completedResult = yield this.db.select({ count: count() }).from(dedupeTable).where(eq(dedupeTable.status, "completed"));
+      const failedResult = yield this.db.select({ count: count() }).from(dedupeTable).where(eq(dedupeTable.status, "failed"));
+      const expiredResult = yield this.db.select({ count: count() }).from(dedupeTable).where(lt(dedupeTable.createdAt, expiredTime));
+      return {
+        totalJobs: ((_a = totalResult[0]) == null ? void 0 : _a.count) || 0,
+        pendingJobs: ((_b = pendingResult[0]) == null ? void 0 : _b.count) || 0,
+        completedJobs: ((_c = completedResult[0]) == null ? void 0 : _c.count) || 0,
+        failedJobs: ((_d = failedResult[0]) == null ? void 0 : _d.count) || 0,
+        expiredJobs: ((_e = expiredResult[0]) == null ? void 0 : _e.count) || 0
+      };
+    });
+  }
+  /**
+   * Clean up expired jobs
+   */
+  cleanup() {
+    return __async(this, null, function* () {
+      const now = Date.now();
+      const expiredTime = now - this.jobTimeoutMs;
+      yield this.db.delete(dedupeTable).where(lt(dedupeTable.createdAt, expiredTime));
+    });
+  }
+  /**
+   * Clear all jobs
+   */
+  clear() {
+    return __async(this, null, function* () {
+      yield this.db.delete(dedupeTable);
+      for (const settle of this.jobSettlers.values()) {
+        settle(void 0);
+      }
+      this.jobPromises.clear();
+      this.jobSettlers.clear();
+    });
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    return __async(this, null, function* () {
+      if (this.cleanupInterval) {
+        clearInterval(this.cleanupInterval);
+        this.cleanupInterval = void 0;
+      }
+      this.isDestroyed = true;
+      for (const settle of this.jobSettlers.values()) {
+        settle(void 0);
+      }
+      this.jobPromises.clear();
+      this.jobSettlers.clear();
+      if (this.isConnectionManaged && typeof this.sqlite.close === "function") {
+        this.sqlite.close();
+      }
+    });
+  }
+  /**
+   * Alias for close() to match test expectations
+   */
+  destroy() {
+    this.close();
+  }
+  deserializeResult(serializedResult) {
+    try {
+      if (serializedResult === "__UNDEFINED__") {
+        return void 0;
+      }
+      if (serializedResult === "__NULL__") {
+        return null;
+      }
+      if (serializedResult) {
+        return JSON.parse(serializedResult);
+      }
+      return void 0;
+    } catch (e) {
+      return void 0;
+    }
+  }
+  initializeDatabase() {
+    this.db.run(sql`
+      CREATE TABLE IF NOT EXISTS dedupe_jobs (
+        hash TEXT PRIMARY KEY,
+        job_id TEXT NOT NULL,
+        status TEXT NOT NULL,
+        result BLOB,
+        error TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    this.db.run(sql`
+      CREATE INDEX IF NOT EXISTS idx_dedupe_status ON dedupe_jobs(status)
+    `);
+  }
+};
+var SQLiteRateLimitStore = class {
+  constructor({
+    /** File path or existing `better-sqlite3` Database instance. Defaults to `':memory:'`. */
+    database = ":memory:",
+    /** Global/default rate-limit config applied when a resource-specific override is not provided. */
+    defaultConfig = DEFAULT_RATE_LIMIT,
+    /** Optional per-resource overrides. */
+    resourceConfigs = /* @__PURE__ */ new Map()
+  } = {}) {
+    /** Indicates whether this store manages (and should close) the SQLite connection */
+    this.isConnectionManaged = false;
+    this.resourceConfigs = /* @__PURE__ */ new Map();
+    this.isDestroyed = false;
+    let sqliteInstance;
+    let isConnectionManaged = false;
+    if (typeof database === "string") {
+      sqliteInstance = new Database(database);
+      isConnectionManaged = true;
+    } else {
+      sqliteInstance = database;
+    }
+    this.sqlite = sqliteInstance;
+    this.isConnectionManaged = isConnectionManaged;
+    this.db = drizzle(sqliteInstance);
+    this.defaultConfig = defaultConfig;
+    this.resourceConfigs = resourceConfigs;
+    this.initializeDatabase();
+  }
+  canProceed(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      yield this.cleanupExpiredRequests(resource, windowStart);
+      const result = yield this.db.select({ count: count() }).from(rateLimitTable).where(
+        and(
+          eq(rateLimitTable.resource, resource),
+          gte(rateLimitTable.timestamp, windowStart)
+        )
+      );
+      const currentCount = ((_a = result[0]) == null ? void 0 : _a.count) || 0;
+      return currentCount < config.limit;
+    });
+  }
+  record(resource) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      const now = Date.now();
+      yield this.db.insert(rateLimitTable).values({
+        resource,
+        timestamp: now
+      });
+    });
+  }
+  getStatus(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      yield this.cleanupExpiredRequests(resource, windowStart);
+      const result = yield this.db.select({ count: count() }).from(rateLimitTable).where(
+        and(
+          eq(rateLimitTable.resource, resource),
+          gte(rateLimitTable.timestamp, windowStart)
+        )
+      );
+      const currentRequests = ((_a = result[0]) == null ? void 0 : _a.count) || 0;
+      const remaining = Math.max(0, config.limit - currentRequests);
+      const resetTime = new Date(now + config.windowMs);
+      return {
+        remaining,
+        resetTime,
+        limit: config.limit
+      };
+    });
+  }
+  reset(resource) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      yield this.db.delete(rateLimitTable).where(eq(rateLimitTable.resource, resource));
+    });
+  }
+  getWaitTime(resource) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+      if (config.limit === 0) {
+        return config.windowMs;
+      }
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      yield this.cleanupExpiredRequests(resource, windowStart);
+      const countResult = yield this.db.select({ count: count() }).from(rateLimitTable).where(
+        and(
+          eq(rateLimitTable.resource, resource),
+          gte(rateLimitTable.timestamp, windowStart)
+        )
+      );
+      const currentRequests = ((_a = countResult[0]) == null ? void 0 : _a.count) || 0;
+      if (currentRequests < config.limit) {
+        return 0;
+      }
+      const oldestResult = yield this.db.select({ timestamp: rateLimitTable.timestamp }).from(rateLimitTable).where(
+        and(
+          eq(rateLimitTable.resource, resource),
+          gte(rateLimitTable.timestamp, windowStart)
+        )
+      ).orderBy(rateLimitTable.timestamp).limit(1);
+      if (oldestResult.length === 0) {
+        return 0;
+      }
+      const oldestTimestamp = (_b = oldestResult[0]) == null ? void 0 : _b.timestamp;
+      if (oldestTimestamp === void 0) {
+        return 0;
+      }
+      const timeUntilOldestExpires = oldestTimestamp + config.windowMs - now;
+      return Math.max(0, timeUntilOldestExpires);
+    });
+  }
+  /**
+   * Set rate limit configuration for a specific resource
+   */
+  setResourceConfig(resource, config) {
+    this.resourceConfigs.set(resource, config);
+  }
+  /**
+   * Get rate limit configuration for a resource
+   */
+  getResourceConfig(resource) {
+    return this.resourceConfigs.get(resource) || this.defaultConfig;
+  }
+  /**
+   * Get statistics for all resources
+   */
+  getStats() {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      const totalResult = yield this.db.select({ count: count() }).from(rateLimitTable);
+      const resourcesResult = yield this.db.select({ resource: rateLimitTable.resource }).from(rateLimitTable).groupBy(rateLimitTable.resource);
+      const uniqueResources = resourcesResult.length;
+      const rateLimitedResources = [];
+      for (const { resource } of resourcesResult) {
+        const canProceed = yield this.canProceed(resource);
+        if (!canProceed) {
+          rateLimitedResources.push(resource);
+        }
+      }
+      return {
+        totalRequests: ((_a = totalResult[0]) == null ? void 0 : _a.count) || 0,
+        uniqueResources,
+        rateLimitedResources
+      };
+    });
+  }
+  /**
+   * Clean up all rate limit data
+   */
+  clear() {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      yield this.db.delete(rateLimitTable);
+    });
+  }
+  /**
+   * Clean up expired requests for all resources
+   */
+  cleanup() {
+    return __async(this, null, function* () {
+      const now = Date.now();
+      const resources = yield this.db.select({ resource: rateLimitTable.resource }).from(rateLimitTable).groupBy(rateLimitTable.resource);
+      for (const { resource } of resources) {
+        const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+        const windowStart = now - config.windowMs;
+        yield this.cleanupExpiredRequests(resource, windowStart);
+      }
+    });
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    return __async(this, null, function* () {
+      this.isDestroyed = true;
+      if (this.isConnectionManaged && typeof this.sqlite.close === "function") {
+        this.sqlite.close();
+      }
+    });
+  }
+  /**
+   * Alias for close() to match test expectations
+   */
+  destroy() {
+    this.close();
+  }
+  cleanupExpiredRequests(resource, windowStart) {
+    return __async(this, null, function* () {
+      yield this.db.delete(rateLimitTable).where(
+        and(
+          eq(rateLimitTable.resource, resource),
+          lt(rateLimitTable.timestamp, windowStart)
+        )
+      );
+    });
+  }
+  initializeDatabase() {
+    this.db.run(sql`
+      CREATE TABLE IF NOT EXISTS rate_limits (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        resource TEXT NOT NULL,
+        timestamp INTEGER NOT NULL
+      )
+    `);
+    this.db.run(sql`
+      CREATE INDEX IF NOT EXISTS idx_rate_limit_resource ON rate_limits(resource)
+    `);
+    this.db.run(sql`
+      CREATE INDEX IF NOT EXISTS idx_rate_limit_timestamp ON rate_limits(timestamp)
+    `);
+  }
+};
+var DEFAULT_RATE_LIMIT2 = {
+  limit: 200,
+  windowMs: 36e5
+  // 1 hour
+};
+var SqliteAdaptiveRateLimitStore = class {
+  constructor({
+    database = ":memory:",
+    defaultConfig = DEFAULT_RATE_LIMIT2,
+    resourceConfigs = /* @__PURE__ */ new Map(),
+    adaptiveConfig = {}
+  } = {}) {
+    /** Indicates whether this store manages (and should close) the SQLite connection */
+    this.isConnectionManaged = false;
+    this.resourceConfigs = /* @__PURE__ */ new Map();
+    this.isDestroyed = false;
+    this.activityMetrics = /* @__PURE__ */ new Map();
+    this.lastCapacityUpdate = /* @__PURE__ */ new Map();
+    this.cachedCapacity = /* @__PURE__ */ new Map();
+    let sqliteInstance;
+    let isConnectionManaged = false;
+    if (typeof database === "string") {
+      sqliteInstance = new Database(database);
+      isConnectionManaged = true;
+    } else {
+      sqliteInstance = database;
+    }
+    this.sqlite = sqliteInstance;
+    this.isConnectionManaged = isConnectionManaged;
+    this.db = drizzle(sqliteInstance);
+    this.defaultConfig = defaultConfig;
+    this.resourceConfigs = resourceConfigs;
+    this.capacityCalculator = new AdaptiveCapacityCalculator(adaptiveConfig);
+    this.initializeDatabase();
+  }
+  canProceed(resource, priority = "background") {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      yield this.ensureActivityMetrics(resource);
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      const capacity = this.calculateCurrentCapacity(resource, metrics);
+      if (priority === "background" && capacity.backgroundPaused) {
+        return false;
+      }
+      const currentUserRequests = yield this.getCurrentUsage(resource, "user");
+      const currentBackgroundRequests = yield this.getCurrentUsage(
+        resource,
+        "background"
+      );
+      if (priority === "user") {
+        return currentUserRequests < capacity.userReserved;
+      } else {
+        return currentBackgroundRequests < capacity.backgroundMax;
+      }
+    });
+  }
+  record(resource, priority = "background") {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      const now = Date.now();
+      this.db.run(sql`
+      INSERT INTO rate_limits (resource, timestamp, priority)
+      VALUES (${resource}, ${now}, ${priority})
+    `);
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      if (priority === "user") {
+        metrics.recentUserRequests.push(now);
+        this.cleanupOldRequests(metrics.recentUserRequests);
+      } else {
+        metrics.recentBackgroundRequests.push(now);
+        this.cleanupOldRequests(metrics.recentBackgroundRequests);
+      }
+      metrics.userActivityTrend = this.capacityCalculator.calculateActivityTrend(
+        metrics.recentUserRequests
+      );
+    });
+  }
+  getStatus(resource) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      yield this.ensureActivityMetrics(resource);
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      const capacity = this.calculateCurrentCapacity(resource, metrics);
+      const currentUserUsage = yield this.getCurrentUsage(resource, "user");
+      const currentBackgroundUsage = yield this.getCurrentUsage(
+        resource,
+        "background"
+      );
+      const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+      return {
+        remaining: capacity.userReserved - currentUserUsage + (capacity.backgroundMax - currentBackgroundUsage),
+        resetTime: new Date(Date.now() + config.windowMs),
+        limit: this.getResourceLimit(resource),
+        adaptive: {
+          userReserved: capacity.userReserved,
+          backgroundMax: capacity.backgroundMax,
+          backgroundPaused: capacity.backgroundPaused,
+          recentUserActivity: this.capacityCalculator.getRecentActivity(
+            metrics.recentUserRequests
+          ),
+          reason: capacity.reason
+        }
+      };
+    });
+  }
+  reset(resource) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      yield this.db.delete(rateLimitTable).where(eq(rateLimitTable.resource, resource));
+      this.activityMetrics.delete(resource);
+      this.cachedCapacity.delete(resource);
+      this.lastCapacityUpdate.delete(resource);
+    });
+  }
+  getWaitTime(resource, priority = "background") {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+      if (config.limit === 0) {
+        return config.windowMs;
+      }
+      const canProceed = yield this.canProceed(resource, priority);
+      if (canProceed) {
+        return 0;
+      }
+      yield this.ensureActivityMetrics(resource);
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      const capacity = this.calculateCurrentCapacity(resource, metrics);
+      if (priority === "background" && capacity.backgroundPaused) {
+        return this.capacityCalculator.config.recalculationIntervalMs;
+      }
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      const oldestResult = this.sqlite.prepare(
+        `
+      SELECT timestamp
+      FROM rate_limits
+      WHERE resource = ? AND COALESCE(priority, 'background') = ? AND timestamp >= ?
+      ORDER BY timestamp
+      LIMIT 1
+    `
+      ).get(resource, priority, windowStart);
+      if (!oldestResult) {
+        return 0;
+      }
+      const oldestTimestamp = oldestResult.timestamp;
+      if (!oldestTimestamp) {
+        return 0;
+      }
+      const timeUntilOldestExpires = oldestTimestamp + config.windowMs - now;
+      return Math.max(0, timeUntilOldestExpires);
+    });
+  }
+  /**
+   * Set rate limit configuration for a specific resource
+   */
+  setResourceConfig(resource, config) {
+    this.resourceConfigs.set(resource, config);
+  }
+  /**
+   * Get rate limit configuration for a resource
+   */
+  getResourceConfig(resource) {
+    return this.resourceConfigs.get(resource) || this.defaultConfig;
+  }
+  /**
+   * Get statistics for all resources
+   */
+  getStats() {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      const totalResult = yield this.db.select({ count: count() }).from(rateLimitTable);
+      const resourcesResult = yield this.db.select({ resource: rateLimitTable.resource }).from(rateLimitTable).groupBy(rateLimitTable.resource);
+      const uniqueResources = resourcesResult.length;
+      const rateLimitedResources = [];
+      for (const { resource } of resourcesResult) {
+        const canProceed = yield this.canProceed(resource);
+        if (!canProceed) {
+          rateLimitedResources.push(resource);
+        }
+      }
+      return {
+        totalRequests: ((_a = totalResult[0]) == null ? void 0 : _a.count) || 0,
+        uniqueResources,
+        rateLimitedResources
+      };
+    });
+  }
+  /**
+   * Clean up all rate limit data
+   */
+  clear() {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      yield this.db.delete(rateLimitTable);
+      this.activityMetrics.clear();
+      this.cachedCapacity.clear();
+      this.lastCapacityUpdate.clear();
+    });
+  }
+  /**
+   * Clean up expired requests for all resources
+   */
+  cleanup() {
+    return __async(this, null, function* () {
+      const now = Date.now();
+      const resources = yield this.db.select({ resource: rateLimitTable.resource }).from(rateLimitTable).groupBy(rateLimitTable.resource);
+      for (const { resource } of resources) {
+        const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+        const windowStart = now - config.windowMs;
+        yield this.cleanupExpiredRequests(resource, windowStart);
+      }
+    });
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    return __async(this, null, function* () {
+      this.isDestroyed = true;
+      if (this.isConnectionManaged && typeof this.sqlite.close === "function") {
+        this.sqlite.close();
+      }
+    });
+  }
+  /**
+   * Alias for close() to match test expectations
+   */
+  destroy() {
+    this.close();
+  }
+  // Private helper methods for adaptive functionality
+  calculateCurrentCapacity(resource, metrics) {
+    const lastUpdate = this.lastCapacityUpdate.get(resource) || 0;
+    const recalcInterval = this.capacityCalculator.config.recalculationIntervalMs;
+    if (Date.now() - lastUpdate < recalcInterval) {
+      return this.cachedCapacity.get(resource) || this.getDefaultCapacity(resource);
+    }
+    const totalLimit = this.getResourceLimit(resource);
+    const capacity = this.capacityCalculator.calculateDynamicCapacity(
+      resource,
+      totalLimit,
+      metrics
+    );
+    this.cachedCapacity.set(resource, capacity);
+    this.lastCapacityUpdate.set(resource, Date.now());
+    return capacity;
+  }
+  getOrCreateActivityMetrics(resource) {
+    if (!this.activityMetrics.has(resource)) {
+      this.activityMetrics.set(resource, {
+        recentUserRequests: [],
+        recentBackgroundRequests: [],
+        userActivityTrend: "none"
+      });
+    }
+    return this.activityMetrics.get(resource);
+  }
+  ensureActivityMetrics(resource) {
+    return __async(this, null, function* () {
+      if (this.activityMetrics.has(resource)) {
+        return;
+      }
+      const now = Date.now();
+      const windowStart = now - this.capacityCalculator.config.monitoringWindowMs;
+      const recentRequests = this.sqlite.prepare(
+        `
+      SELECT timestamp, COALESCE(priority, 'background') as priority
+      FROM rate_limits
+      WHERE resource = ? AND timestamp >= ?
+      ORDER BY timestamp
+    `
+      ).all(resource, windowStart);
+      const metrics = {
+        recentUserRequests: [],
+        recentBackgroundRequests: [],
+        userActivityTrend: "none"
+      };
+      for (const request of recentRequests) {
+        if (request.priority === "user") {
+          metrics.recentUserRequests.push(request.timestamp);
+        } else {
+          metrics.recentBackgroundRequests.push(request.timestamp);
+        }
+      }
+      metrics.userActivityTrend = this.capacityCalculator.calculateActivityTrend(
+        metrics.recentUserRequests
+      );
+      this.activityMetrics.set(resource, metrics);
+    });
+  }
+  getCurrentUsage(resource, priority) {
+    return __async(this, null, function* () {
+      const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      yield this.cleanupExpiredRequests(resource, windowStart);
+      const result = this.sqlite.prepare(
+        `
+      SELECT COUNT(*) as count
+      FROM rate_limits
+      WHERE resource = ? AND priority = ? AND timestamp >= ?
+    `
+      ).get(resource, priority, windowStart);
+      return result.count || 0;
+    });
+  }
+  cleanupOldRequests(requests) {
+    const cutoff = Date.now() - this.capacityCalculator.config.monitoringWindowMs;
+    while (requests.length > 0 && requests[0] < cutoff) {
+      requests.shift();
+    }
+  }
+  getResourceLimit(resource) {
+    const config = this.resourceConfigs.get(resource) || this.defaultConfig;
+    return config.limit;
+  }
+  getDefaultCapacity(resource) {
+    const limit = this.getResourceLimit(resource);
+    return {
+      userReserved: Math.floor(limit * 0.3),
+      backgroundMax: Math.floor(limit * 0.7),
+      backgroundPaused: false,
+      reason: "Default capacity allocation"
+    };
+  }
+  cleanupExpiredRequests(resource, windowStart) {
+    return __async(this, null, function* () {
+      yield this.db.delete(rateLimitTable).where(
+        and(
+          eq(rateLimitTable.resource, resource),
+          lt(rateLimitTable.timestamp, windowStart)
+        )
+      );
+    });
+  }
+  initializeDatabase() {
+    this.db.run(sql`
+      CREATE TABLE IF NOT EXISTS rate_limits (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        resource TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        priority TEXT NOT NULL DEFAULT 'background'
+      )
+    `);
+    try {
+      this.db.run(sql`
+        ALTER TABLE rate_limits ADD COLUMN priority TEXT DEFAULT 'background'
+      `);
+    } catch (e) {
+    }
+    this.db.run(sql`
+      CREATE INDEX IF NOT EXISTS idx_rate_limit_resource ON rate_limits(resource)
+    `);
+    this.db.run(sql`
+      CREATE INDEX IF NOT EXISTS idx_rate_limit_timestamp ON rate_limits(timestamp)
+    `);
+    this.db.run(sql`
+      CREATE INDEX IF NOT EXISTS idx_rate_limit_resource_priority_timestamp
+      ON rate_limits(resource, priority, timestamp)
+    `);
+  }
+};
+
+export { SQLiteCacheStore, SQLiteDedupeStore, SQLiteRateLimitStore, SqliteAdaptiveRateLimitStore, cacheTable, dedupeTable, rateLimitTable };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map