@parsrun/cache 0.1.0

package/dist/index.js

@@ -0,0 +1,978 @@
+// src/types.ts
+import {
+  type,
+  cacheSetOptions,
+  cacheGetResult,
+  cacheStats,
+  memoryCacheConfig,
+  redisCacheConfig,
+  upstashCacheConfig,
+  cloudflareKvConfig,
+  multiTierCacheConfig,
+  cacheConfig
+} from "@parsrun/types";
+var CacheError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "CacheError";
+  }
+};
+var CacheErrorCodes = {
+  CONNECTION_FAILED: "CONNECTION_FAILED",
+  OPERATION_FAILED: "OPERATION_FAILED",
+  SERIALIZATION_ERROR: "SERIALIZATION_ERROR",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  NOT_IMPLEMENTED: "NOT_IMPLEMENTED"
+};
+
+// src/adapters/memory.ts
+var MemoryCacheAdapter = class {
+  type = "memory";
+  cache = /* @__PURE__ */ new Map();
+  tagIndex = /* @__PURE__ */ new Map();
+  maxEntries;
+  cleanupInterval;
+  cleanupTimer = null;
+  constructor(config) {
+    this.maxEntries = config?.maxEntries ?? 1e4;
+    this.cleanupInterval = config?.cleanupInterval ?? 6e4;
+    if (this.cleanupInterval > 0) {
+      this.cleanupTimer = setInterval(() => this.cleanup(), this.cleanupInterval);
+    }
+  }
+  async get(key, options) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.removeFromTagIndex(key, entry.tags);
+      return null;
+    }
+    if (options?.refresh && entry.expiresAt && entry.ttlSeconds) {
+      entry.expiresAt = Date.now() + entry.ttlSeconds * 1e3;
+    }
+    return entry.value;
+  }
+  async set(key, value, options) {
+    if (this.cache.size >= this.maxEntries && !this.cache.has(key)) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        const oldEntry = this.cache.get(oldestKey);
+        this.cache.delete(oldestKey);
+        if (oldEntry?.tags) {
+          this.removeFromTagIndex(oldestKey, oldEntry.tags);
+        }
+      }
+    }
+    const entry = {
+      value,
+      metadata: options?.metadata
+    };
+    if (options?.ttl) {
+      entry.expiresAt = Date.now() + options.ttl * 1e3;
+      entry.ttlSeconds = options.ttl;
+    }
+    if (options?.tags && options.tags.length > 0) {
+      entry.tags = options.tags;
+      this.addToTagIndex(key, options.tags);
+    }
+    this.cache.set(key, entry);
+  }
+  async delete(key) {
+    const entry = this.cache.get(key);
+    if (entry?.tags) {
+      this.removeFromTagIndex(key, entry.tags);
+    }
+    this.cache.delete(key);
+  }
+  async has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return false;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.removeFromTagIndex(key, entry.tags);
+      return false;
+    }
+    return true;
+  }
+  async clear() {
+    this.cache.clear();
+    this.tagIndex.clear();
+  }
+  async getMany(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      result.set(key, await this.get(key));
+    }
+    return result;
+  }
+  async setMany(entries, options) {
+    for (const [key, value] of entries) {
+      await this.set(key, value, options);
+    }
+  }
+  async deleteMany(keys) {
+    for (const key of keys) {
+      await this.delete(key);
+    }
+  }
+  async invalidateByTags(tags) {
+    const keysToDelete = /* @__PURE__ */ new Set();
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        for (const key of keys) {
+          keysToDelete.add(key);
+        }
+      }
+    }
+    for (const key of keysToDelete) {
+      await this.delete(key);
+    }
+  }
+  async ttl(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return -2;
+    }
+    if (!entry.expiresAt) {
+      return -1;
+    }
+    const remaining = entry.expiresAt - Date.now();
+    if (remaining <= 0) {
+      return -2;
+    }
+    return Math.ceil(remaining / 1e3);
+  }
+  async close() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    await this.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxEntries: this.maxEntries
+    };
+  }
+  addToTagIndex(key, tags) {
+    for (const tag of tags) {
+      let keys = this.tagIndex.get(tag);
+      if (!keys) {
+        keys = /* @__PURE__ */ new Set();
+        this.tagIndex.set(tag, keys);
+      }
+      keys.add(key);
+    }
+  }
+  removeFromTagIndex(key, tags) {
+    if (!tags) return;
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        keys.delete(key);
+        if (keys.size === 0) {
+          this.tagIndex.delete(tag);
+        }
+      }
+    }
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (entry.expiresAt && now > entry.expiresAt) {
+        this.removeFromTagIndex(key, entry.tags);
+        this.cache.delete(key);
+      }
+    }
+  }
+};
+function createMemoryCacheAdapter(config) {
+  return new MemoryCacheAdapter(config);
+}
+
+// src/adapters/redis.ts
+var RedisCacheAdapter = class {
+  type = "redis";
+  client;
+  keyPrefix;
+  isExternalClient;
+  constructor(config) {
+    this.client = config.client;
+    this.keyPrefix = config.keyPrefix ?? "";
+    this.isExternalClient = true;
+  }
+  prefixKey(key) {
+    return this.keyPrefix ? `${this.keyPrefix}:${key}` : key;
+  }
+  async get(key, _options) {
+    try {
+      const data = await this.client.get(this.prefixKey(key));
+      if (!data) {
+        return null;
+      }
+      const parsed = JSON.parse(data);
+      return parsed.value;
+    } catch (err) {
+      throw new CacheError(
+        `Redis get failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async set(key, value, options) {
+    try {
+      const data = JSON.stringify({
+        value,
+        tags: options?.tags,
+        metadata: options?.metadata
+      });
+      const prefixedKey = this.prefixKey(key);
+      if (options?.ttl) {
+        await this.client.set(prefixedKey, data, "EX", options.ttl);
+      } else {
+        await this.client.set(prefixedKey, data);
+      }
+      if (options?.tags && options.tags.length > 0) {
+        const pipeline = this.client.pipeline();
+        for (const tag of options.tags) {
+          const tagKey = this.prefixKey(`__tag:${tag}`);
+          pipeline.set(tagKey, JSON.stringify([...await this.getTagKeys(tag), key]));
+        }
+        await pipeline.exec();
+      }
+    } catch (err) {
+      throw new CacheError(
+        `Redis set failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async delete(key) {
+    try {
+      await this.client.del(this.prefixKey(key));
+    } catch (err) {
+      throw new CacheError(
+        `Redis delete failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async has(key) {
+    try {
+      const exists = await this.client.exists(this.prefixKey(key));
+      return exists > 0;
+    } catch (err) {
+      throw new CacheError(
+        `Redis exists failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async clear() {
+    try {
+      if (this.keyPrefix) {
+        const keys = await this.client.keys(`${this.keyPrefix}:*`);
+        if (keys.length > 0) {
+          await this.client.del(...keys);
+        }
+      } else {
+        await this.client.flushdb();
+      }
+    } catch (err) {
+      throw new CacheError(
+        `Redis clear failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async getMany(keys) {
+    try {
+      const prefixedKeys = keys.map((k) => this.prefixKey(k));
+      const results = await this.client.mget(...prefixedKeys);
+      const map = /* @__PURE__ */ new Map();
+      for (let i = 0; i < keys.length; i++) {
+        const data = results[i];
+        if (data) {
+          const parsed = JSON.parse(data);
+          map.set(keys[i] ?? "", parsed.value);
+        } else {
+          map.set(keys[i] ?? "", null);
+        }
+      }
+      return map;
+    } catch (err) {
+      throw new CacheError(
+        `Redis mget failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async setMany(entries, options) {
+    try {
+      const pipeline = this.client.pipeline();
+      for (const [key, value] of entries) {
+        const data = JSON.stringify({
+          value,
+          tags: options?.tags,
+          metadata: options?.metadata
+        });
+        const prefixedKey = this.prefixKey(key);
+        if (options?.ttl) {
+          pipeline.set(prefixedKey, data, "EX", options.ttl);
+        } else {
+          pipeline.set(prefixedKey, data);
+        }
+      }
+      await pipeline.exec();
+    } catch (err) {
+      throw new CacheError(
+        `Redis mset failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async deleteMany(keys) {
+    try {
+      const prefixedKeys = keys.map((k) => this.prefixKey(k));
+      await this.client.del(...prefixedKeys);
+    } catch (err) {
+      throw new CacheError(
+        `Redis mdel failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async invalidateByTags(tags) {
+    try {
+      const keysToDelete = [];
+      for (const tag of tags) {
+        const keys = await this.getTagKeys(tag);
+        keysToDelete.push(...keys);
+      }
+      if (keysToDelete.length > 0) {
+        await this.deleteMany(keysToDelete);
+      }
+      const tagKeys = tags.map((tag) => this.prefixKey(`__tag:${tag}`));
+      await this.client.del(...tagKeys);
+    } catch (err) {
+      throw new CacheError(
+        `Redis invalidate by tags failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async ttl(key) {
+    try {
+      return await this.client.ttl(this.prefixKey(key));
+    } catch (err) {
+      throw new CacheError(
+        `Redis ttl failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async close() {
+    if (!this.isExternalClient) {
+      await this.client.quit();
+    }
+  }
+  async getTagKeys(tag) {
+    const tagKey = this.prefixKey(`__tag:${tag}`);
+    const data = await this.client.get(tagKey);
+    if (data) {
+      return JSON.parse(data);
+    }
+    return [];
+  }
+};
+function createRedisCacheAdapter(config) {
+  return new RedisCacheAdapter(config);
+}
+
+// src/adapters/upstash.ts
+var UpstashCacheAdapter = class {
+  type = "upstash";
+  url;
+  token;
+  keyPrefix;
+  constructor(config) {
+    this.url = config.url.replace(/\/$/, "");
+    this.token = config.token;
+    this.keyPrefix = config.keyPrefix ?? "";
+  }
+  prefixKey(key) {
+    return this.keyPrefix ? `${this.keyPrefix}:${key}` : key;
+  }
+  async command(...args) {
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(args)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Upstash API error: ${error}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return data.result;
+    } catch (err) {
+      throw new CacheError(
+        `Upstash command failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async pipeline(commands) {
+    try {
+      const response = await fetch(`${this.url}/pipeline`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(commands)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Upstash API error: ${error}`);
+      }
+      const data = await response.json();
+      return data.map((item) => {
+        if (item.error) {
+          throw new Error(item.error);
+        }
+        return item.result;
+      });
+    } catch (err) {
+      throw new CacheError(
+        `Upstash pipeline failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async get(key, _options) {
+    const data = await this.command("GET", this.prefixKey(key));
+    if (!data) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(data);
+      return parsed.value;
+    } catch {
+      return data;
+    }
+  }
+  async set(key, value, options) {
+    const data = JSON.stringify({
+      value,
+      tags: options?.tags,
+      metadata: options?.metadata
+    });
+    const prefixedKey = this.prefixKey(key);
+    if (options?.ttl) {
+      await this.command("SET", prefixedKey, data, "EX", options.ttl);
+    } else {
+      await this.command("SET", prefixedKey, data);
+    }
+    if (options?.tags && options.tags.length > 0) {
+      const commands = [];
+      for (const tag of options.tags) {
+        commands.push(["SADD", this.prefixKey(`__tag:${tag}`), key]);
+      }
+      await this.pipeline(commands);
+    }
+  }
+  async delete(key) {
+    await this.command("DEL", this.prefixKey(key));
+  }
+  async has(key) {
+    const exists = await this.command("EXISTS", this.prefixKey(key));
+    return exists > 0;
+  }
+  async clear() {
+    if (this.keyPrefix) {
+      let cursor = "0";
+      do {
+        const result = await this.command(
+          "SCAN",
+          cursor,
+          "MATCH",
+          `${this.keyPrefix}:*`,
+          "COUNT",
+          100
+        );
+        cursor = result[0];
+        const keys = result[1];
+        if (keys.length > 0) {
+          await this.command("DEL", ...keys);
+        }
+      } while (cursor !== "0");
+    } else {
+      await this.command("FLUSHDB");
+    }
+  }
+  async getMany(keys) {
+    const prefixedKeys = keys.map((k) => this.prefixKey(k));
+    const results = await this.command("MGET", ...prefixedKeys);
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < keys.length; i++) {
+      const data = results[i];
+      const key = keys[i];
+      if (key !== void 0) {
+        if (data) {
+          try {
+            const parsed = JSON.parse(data);
+            map.set(key, parsed.value);
+          } catch {
+            map.set(key, data);
+          }
+        } else {
+          map.set(key, null);
+        }
+      }
+    }
+    return map;
+  }
+  async setMany(entries, options) {
+    const commands = [];
+    for (const [key, value] of entries) {
+      const data = JSON.stringify({
+        value,
+        tags: options?.tags,
+        metadata: options?.metadata
+      });
+      const prefixedKey = this.prefixKey(key);
+      if (options?.ttl) {
+        commands.push(["SET", prefixedKey, data, "EX", options.ttl]);
+      } else {
+        commands.push(["SET", prefixedKey, data]);
+      }
+    }
+    await this.pipeline(commands);
+  }
+  async deleteMany(keys) {
+    const prefixedKeys = keys.map((k) => this.prefixKey(k));
+    await this.command("DEL", ...prefixedKeys);
+  }
+  async invalidateByTags(tags) {
+    const keysToDelete = [];
+    for (const tag of tags) {
+      const keys = await this.command("SMEMBERS", this.prefixKey(`__tag:${tag}`));
+      keysToDelete.push(...keys);
+    }
+    if (keysToDelete.length > 0) {
+      await this.deleteMany(keysToDelete);
+    }
+    const tagKeys = tags.map((tag) => this.prefixKey(`__tag:${tag}`));
+    await this.command("DEL", ...tagKeys);
+  }
+  async ttl(key) {
+    return await this.command("TTL", this.prefixKey(key));
+  }
+  async close() {
+  }
+};
+function createUpstashCacheAdapter(config) {
+  return new UpstashCacheAdapter(config);
+}
+
+// src/adapters/cloudflare-kv.ts
+var CloudflareKVCacheAdapter = class {
+  type = "cloudflare-kv";
+  kv;
+  keyPrefix;
+  constructor(config) {
+    this.kv = config.namespace;
+    this.keyPrefix = config.keyPrefix ?? "";
+  }
+  prefixKey(key) {
+    return this.keyPrefix ? `${this.keyPrefix}:${key}` : key;
+  }
+  async get(key, _options) {
+    try {
+      const data = await this.kv.get(this.prefixKey(key), { type: "json" });
+      if (!data) {
+        return null;
+      }
+      return data.value;
+    } catch (err) {
+      throw new CacheError(
+        `Cloudflare KV get failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async set(key, value, options) {
+    try {
+      const data = {
+        value,
+        tags: options?.tags,
+        metadata: options?.metadata
+      };
+      const putOptions = {};
+      if (options?.ttl) {
+        putOptions.expirationTtl = options.ttl;
+      }
+      if (options?.tags || options?.metadata) {
+        putOptions.metadata = {
+          tags: options.tags,
+          ...options.metadata
+        };
+      }
+      await this.kv.put(this.prefixKey(key), JSON.stringify(data), putOptions);
+      if (options?.tags && options.tags.length > 0) {
+        for (const tag of options.tags) {
+          const tagKey = this.prefixKey(`__tag:${tag}`);
+          const existing = await this.kv.get(tagKey, { type: "json" });
+          const keys = existing ? [.../* @__PURE__ */ new Set([...existing, key])] : [key];
+          await this.kv.put(tagKey, JSON.stringify(keys));
+        }
+      }
+    } catch (err) {
+      throw new CacheError(
+        `Cloudflare KV set failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async delete(key) {
+    try {
+      await this.kv.delete(this.prefixKey(key));
+    } catch (err) {
+      throw new CacheError(
+        `Cloudflare KV delete failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async has(key) {
+    try {
+      const value = await this.kv.get(this.prefixKey(key));
+      return value !== null;
+    } catch (err) {
+      throw new CacheError(
+        `Cloudflare KV has failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async clear() {
+    try {
+      const prefix = this.keyPrefix ? `${this.keyPrefix}:` : "";
+      let cursor;
+      do {
+        const result = await this.kv.list({
+          prefix,
+          limit: 1e3,
+          cursor
+        });
+        for (const key of result.keys) {
+          await this.kv.delete(key.name);
+        }
+        cursor = result.list_complete ? void 0 : result.cursor;
+      } while (cursor);
+    } catch (err) {
+      throw new CacheError(
+        `Cloudflare KV clear failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async getMany(keys) {
+    const map = /* @__PURE__ */ new Map();
+    const promises = keys.map(async (key) => {
+      const value = await this.get(key);
+      return { key, value };
+    });
+    const results = await Promise.all(promises);
+    for (const { key, value } of results) {
+      map.set(key, value);
+    }
+    return map;
+  }
+  async setMany(entries, options) {
+    const promises = [];
+    for (const [key, value] of entries) {
+      promises.push(this.set(key, value, options));
+    }
+    await Promise.all(promises);
+  }
+  async deleteMany(keys) {
+    const promises = keys.map((key) => this.delete(key));
+    await Promise.all(promises);
+  }
+  async invalidateByTags(tags) {
+    try {
+      const keysToDelete = /* @__PURE__ */ new Set();
+      for (const tag of tags) {
+        const tagKey = this.prefixKey(`__tag:${tag}`);
+        const keys = await this.kv.get(tagKey, { type: "json" });
+        if (keys) {
+          for (const key of keys) {
+            keysToDelete.add(key);
+          }
+          await this.kv.delete(tagKey);
+        }
+      }
+      if (keysToDelete.size > 0) {
+        await this.deleteMany([...keysToDelete]);
+      }
+    } catch (err) {
+      throw new CacheError(
+        `Cloudflare KV invalidate by tags failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        CacheErrorCodes.OPERATION_FAILED,
+        err
+      );
+    }
+  }
+  async ttl(_key) {
+    return -1;
+  }
+  async close() {
+  }
+};
+function createCloudflareKVCacheAdapter(config) {
+  return new CloudflareKVCacheAdapter(config);
+}
+
+// src/index.ts
+var CacheService = class {
+  adapter;
+  defaultTtl;
+  keyPrefix;
+  debug;
+  constructor(config) {
+    this.adapter = config.adapter;
+    this.defaultTtl = config.defaultTtl;
+    this.keyPrefix = config.keyPrefix ?? "";
+    this.debug = config.debug ?? false;
+  }
+  prefixKey(key) {
+    return this.keyPrefix ? `${this.keyPrefix}:${key}` : key;
+  }
+  /**
+   * Get adapter type
+   */
+  get adapterType() {
+    return this.adapter.type;
+  }
+  /**
+   * Get a value from cache
+   */
+  async get(key, options) {
+    const prefixedKey = this.prefixKey(key);
+    if (this.debug) {
+      console.log(`[Cache] GET ${prefixedKey}`);
+    }
+    return this.adapter.get(prefixedKey, options);
+  }
+  /**
+   * Set a value in cache
+   */
+  async set(key, value, options) {
+    const prefixedKey = this.prefixKey(key);
+    const ttl = options?.ttl ?? this.defaultTtl;
+    if (this.debug) {
+      console.log(`[Cache] SET ${prefixedKey} (ttl: ${ttl ?? "none"})`);
+    }
+    await this.adapter.set(prefixedKey, value, { ...options, ttl });
+  }
+  /**
+   * Delete a value from cache
+   */
+  async delete(key) {
+    const prefixedKey = this.prefixKey(key);
+    if (this.debug) {
+      console.log(`[Cache] DELETE ${prefixedKey}`);
+    }
+    await this.adapter.delete(prefixedKey);
+  }
+  /**
+   * Check if a key exists in cache
+   */
+  async has(key) {
+    return this.adapter.has(this.prefixKey(key));
+  }
+  /**
+   * Clear all entries from cache
+   */
+  async clear() {
+    if (this.adapter.clear) {
+      await this.adapter.clear();
+    }
+  }
+  /**
+   * Get multiple values at once
+   */
+  async getMany(keys) {
+    const prefixedKeys = keys.map((k) => this.prefixKey(k));
+    if (this.adapter.getMany) {
+      const results2 = await this.adapter.getMany(prefixedKeys);
+      const unprefixed = /* @__PURE__ */ new Map();
+      let i = 0;
+      for (const key of keys) {
+        const prefixedKey = prefixedKeys[i];
+        if (prefixedKey) {
+          unprefixed.set(key, results2.get(prefixedKey) ?? null);
+        }
+        i++;
+      }
+      return unprefixed;
+    }
+    const results = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      results.set(key, await this.get(key));
+    }
+    return results;
+  }
+  /**
+   * Set multiple values at once
+   */
+  async setMany(entries, options) {
+    const prefixedEntries = /* @__PURE__ */ new Map();
+    for (const [key, value] of entries) {
+      prefixedEntries.set(this.prefixKey(key), value);
+    }
+    const ttl = options?.ttl ?? this.defaultTtl;
+    const opts = { ...options, ttl };
+    if (this.adapter.setMany) {
+      await this.adapter.setMany(prefixedEntries, opts);
+      return;
+    }
+    for (const [key, value] of entries) {
+      await this.set(key, value, opts);
+    }
+  }
+  /**
+   * Delete multiple keys
+   */
+  async deleteMany(keys) {
+    const prefixedKeys = keys.map((k) => this.prefixKey(k));
+    if (this.adapter.deleteMany) {
+      await this.adapter.deleteMany(prefixedKeys);
+      return;
+    }
+    for (const key of keys) {
+      await this.delete(key);
+    }
+  }
+  /**
+   * Invalidate entries by tags
+   */
+  async invalidateByTags(tags) {
+    if (this.adapter.invalidateByTags) {
+      await this.adapter.invalidateByTags(tags);
+    }
+  }
+  /**
+   * Get TTL for a key (in seconds)
+   * @returns TTL in seconds, -1 if no expiry, -2 if key doesn't exist
+   */
+  async ttl(key) {
+    if (this.adapter.ttl) {
+      return this.adapter.ttl(this.prefixKey(key));
+    }
+    return -1;
+  }
+  /**
+   * Get or set a value with callback
+   * @param key Cache key
+   * @param fn Function to compute value if not cached
+   * @param options Set options (applied if value is computed)
+   */
+  async getOrSet(key, fn, options) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await fn();
+    await this.set(key, value, options);
+    return value;
+  }
+  /**
+   * Wrap a function with caching
+   */
+  wrap(fn, keyFn, options) {
+    return async (...args) => {
+      const key = keyFn(...args);
+      return this.getOrSet(key, () => fn(...args), options);
+    };
+  }
+  /**
+   * Close/cleanup cache resources
+   */
+  async close() {
+    if (this.adapter.close) {
+      await this.adapter.close();
+    }
+  }
+};
+function createCacheService(config) {
+  return new CacheService(config);
+}
+var index_default = {
+  CacheService,
+  createCacheService
+};
+export {
+  CacheError,
+  CacheErrorCodes,
+  CacheService,
+  CloudflareKVCacheAdapter,
+  MemoryCacheAdapter,
+  RedisCacheAdapter,
+  UpstashCacheAdapter,
+  cacheConfig,
+  cacheGetResult,
+  cacheStats,
+  cloudflareKvConfig,
+  createCacheService,
+  createCloudflareKVCacheAdapter,
+  createMemoryCacheAdapter,
+  createRedisCacheAdapter,
+  createUpstashCacheAdapter,
+  index_default as default,
+  memoryCacheConfig,
+  multiTierCacheConfig,
+  cacheSetOptions as parsCacheSetOptions,
+  redisCacheConfig,
+  type,
+  upstashCacheConfig
+};
+//# sourceMappingURL=index.js.map