@parsrun/cache 0.1.0

package/dist/adapters/index.js

@@ -0,0 +1,783 @@
+// 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/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/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);
+}
+export {
+  CloudflareKVCacheAdapter,
+  MemoryCacheAdapter,
+  RedisCacheAdapter,
+  UpstashCacheAdapter,
+  createCloudflareKVCacheAdapter,
+  createMemoryCacheAdapter,
+  createRedisCacheAdapter,
+  createUpstashCacheAdapter
+};
+//# sourceMappingURL=index.js.map