@open-mercato/cache 0.3.2 → 0.4.2-canary-c02407ff85

package/dist/strategies/redis.js

@@ -1,388 +1,321 @@
-import { CacheDependencyUnavailableError } from '../errors';
-/**
- * Redis cache strategy with tag support
- * Persistent across process restarts, can be shared across multiple instances
- *
- * Uses Redis data structures:
- * - Hash for storing cache entries: cache:{key} -> {value, tags, expiresAt, createdAt}
- * - Sets for tag index: tag:{tag} -> Set of keys
- */
+import { CacheDependencyUnavailableError } from "../errors.js";
 let redisModulePromise = null;
-const redisRegistry = new Map();
+const redisRegistry = /* @__PURE__ */ new Map();
 function resolveRequire() {
-    const nonWebpack = globalThis.__non_webpack_require__;
-    if (typeof nonWebpack === 'function')
-        return nonWebpack;
-    if (typeof require === 'function')
-        return require;
-    if (typeof module !== 'undefined' && typeof module.require === 'function') {
-        return module.require.bind(module);
-    }
-    try {
-        const maybeRequire = Function('return typeof require !== "undefined" ? require : undefined')();
-        if (typeof maybeRequire === 'function')
-            return maybeRequire;
-    }
-    catch (_a) {
-        // ignore
-    }
-    return null;
+  const nonWebpack = globalThis.__non_webpack_require__;
+  if (typeof nonWebpack === "function") return nonWebpack;
+  if (typeof require === "function") return require;
+  if (typeof module !== "undefined" && typeof module.require === "function") {
+    return module.require.bind(module);
+  }
+  try {
+    const maybeRequire = Function('return typeof require !== "undefined" ? require : undefined')();
+    if (typeof maybeRequire === "function") return maybeRequire;
+  } catch {
+  }
+  return null;
 }
 function loadRedisModuleViaRequire() {
-    const resolver = resolveRequire();
-    if (!resolver)
-        return null;
-    try {
-        return resolver('ioredis');
-    }
-    catch (_a) {
-        return null;
-    }
+  const resolver = resolveRequire();
+  if (!resolver) return null;
+  try {
+    return resolver("ioredis");
+  } catch {
+    return null;
+  }
 }
 function pickRedisConstructor(mod) {
-    var _a;
-    const queue = [mod];
-    const seen = new Set();
-    while (queue.length) {
-        const current = queue.shift();
-        if (!current || seen.has(current))
-            continue;
-        seen.add(current);
-        if (typeof current === 'function')
-            return current;
-        if (typeof current === 'object') {
-            queue.push(current.default);
-            queue.push(current.Redis);
-            queue.push((_a = current.module) === null || _a === void 0 ? void 0 : _a.exports);
-            queue.push(current.exports);
-        }
+  const queue = [mod];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length) {
+    const current = queue.shift();
+    if (!current || seen.has(current)) continue;
+    seen.add(current);
+    if (typeof current === "function") return current;
+    if (typeof current === "object") {
+      queue.push(current.default);
+      queue.push(current.Redis);
+      queue.push(current.module?.exports);
+      queue.push(current.exports);
     }
-    return null;
+  }
+  return null;
 }
 async function loadRedisModule() {
-    if (!redisModulePromise) {
-        redisModulePromise = (async () => {
-            var _a;
-            const required = (_a = loadRedisModuleViaRequire()) !== null && _a !== void 0 ? _a : (await import('ioredis'));
-            return required;
-        })().catch((error) => {
-            redisModulePromise = null;
-            throw new CacheDependencyUnavailableError('redis', 'ioredis', error);
-        });
-    }
-    return redisModulePromise;
+  if (!redisModulePromise) {
+    redisModulePromise = (async () => {
+      const required = loadRedisModuleViaRequire() ?? await import("ioredis");
+      return required;
+    })().catch((error) => {
+      redisModulePromise = null;
+      throw new CacheDependencyUnavailableError("redis", "ioredis", error);
+    });
+  }
+  return redisModulePromise;
 }
 function retainRedisEntry(key) {
-    let entry = redisRegistry.get(key);
-    if (!entry) {
-        entry = { refs: 0 };
-        redisRegistry.set(key, entry);
-    }
-    entry.refs += 1;
-    return entry;
+  let entry = redisRegistry.get(key);
+  if (!entry) {
+    entry = { refs: 0 };
+    redisRegistry.set(key, entry);
+  }
+  entry.refs += 1;
+  return entry;
 }
 async function acquireRedisClient(key, entry) {
-    if (entry.client)
-        return entry.client;
-    if (entry.creating)
-        return entry.creating;
-    entry.creating = loadRedisModule()
-        .then((mod) => {
-        var _a;
-        const ctor = pickRedisConstructor(mod);
-        if (!ctor) {
-            throw new CacheDependencyUnavailableError('redis', 'ioredis', new Error('No usable Redis constructor'));
-        }
-        const client = new ctor(key);
-        entry.client = client;
-        entry.creating = undefined;
-        (_a = client.once) === null || _a === void 0 ? void 0 : _a.call(client, 'end', () => {
-            if (redisRegistry.get(key) === entry && entry.refs === 0) {
-                redisRegistry.delete(key);
-            }
-            else if (redisRegistry.get(key) === entry) {
-                entry.client = undefined;
-            }
-        });
-        return client;
-    })
-        .catch((error) => {
-        entry.creating = undefined;
-        throw error;
+  if (entry.client) return entry.client;
+  if (entry.creating) return entry.creating;
+  entry.creating = loadRedisModule().then((mod) => {
+    const ctor = pickRedisConstructor(mod);
+    if (!ctor) {
+      throw new CacheDependencyUnavailableError("redis", "ioredis", new Error("No usable Redis constructor"));
+    }
+    const client = new ctor(key);
+    entry.client = client;
+    entry.creating = void 0;
+    client.once?.("end", () => {
+      if (redisRegistry.get(key) === entry && entry.refs === 0) {
+        redisRegistry.delete(key);
+      } else if (redisRegistry.get(key) === entry) {
+        entry.client = void 0;
+      }
     });
-    return entry.creating;
+    return client;
+  }).catch((error) => {
+    entry.creating = void 0;
+    throw error;
+  });
+  return entry.creating;
 }
 async function releaseRedisEntry(key, entry) {
-    entry.refs = Math.max(0, entry.refs - 1);
-    if (entry.refs > 0)
-        return;
-    redisRegistry.delete(key);
-    if (entry.client) {
-        try {
-            await entry.client.quit();
-        }
-        catch (_a) {
-            // ignore shutdown errors
+  entry.refs = Math.max(0, entry.refs - 1);
+  if (entry.refs > 0) return;
+  redisRegistry.delete(key);
+  if (entry.client) {
+    try {
+      await entry.client.quit();
+    } catch {
+    } finally {
+      entry.client = void 0;
+    }
+  }
+}
+function createRedisStrategy(redisUrl, options) {
+  const defaultTtl = options?.defaultTtl;
+  const keyPrefix = "cache:";
+  const tagPrefix = "tag:";
+  const connectionUrl = redisUrl || process.env.REDIS_URL || process.env.CACHE_REDIS_URL || "redis://localhost:6379";
+  const registryEntry = retainRedisEntry(connectionUrl);
+  let redis = registryEntry.client ?? null;
+  async function getRedisClient() {
+    if (redis) return redis;
+    redis = await acquireRedisClient(connectionUrl, registryEntry);
+    return redis;
+  }
+  function getCacheKey(key) {
+    return `${keyPrefix}${key}`;
+  }
+  function getTagKey(tag) {
+    return `${tagPrefix}${tag}`;
+  }
+  function isExpired(entry) {
+    if (entry.expiresAt === null) return false;
+    return Date.now() > entry.expiresAt;
+  }
+  function matchPattern(key, pattern) {
+    const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(key);
+  }
+  const get = async (key, options2) => {
+    const client = await getRedisClient();
+    const cacheKey = getCacheKey(key);
+    const data = await client.get(cacheKey);
+    if (!data) return null;
+    try {
+      const entry = JSON.parse(data);
+      if (isExpired(entry)) {
+        if (options2?.returnExpired) {
+          return entry.value;
         }
-        finally {
-            entry.client = undefined;
+        await deleteKey(key);
+        return null;
+      }
+      return entry.value;
+    } catch {
+      await client.del(cacheKey);
+      return null;
+    }
+  };
+  const set = async (key, value, options2) => {
+    const client = await getRedisClient();
+    const cacheKey = getCacheKey(key);
+    const oldData = await client.get(cacheKey);
+    if (oldData) {
+      try {
+        const oldEntry = JSON.parse(oldData);
+        const pipeline2 = client.pipeline();
+        for (const tag of oldEntry.tags) {
+          pipeline2.srem(getTagKey(tag), key);
         }
+        await pipeline2.exec();
+      } catch {
+      }
     }
-}
-export function createRedisStrategy(redisUrl, options) {
-    var _a;
-    const defaultTtl = options === null || options === void 0 ? void 0 : options.defaultTtl;
-    const keyPrefix = 'cache:';
-    const tagPrefix = 'tag:';
-    const connectionUrl = redisUrl || process.env.REDIS_URL || process.env.CACHE_REDIS_URL || 'redis://localhost:6379';
-    const registryEntry = retainRedisEntry(connectionUrl);
-    let redis = (_a = registryEntry.client) !== null && _a !== void 0 ? _a : null;
-    async function getRedisClient() {
-        if (redis)
-            return redis;
-        redis = await acquireRedisClient(connectionUrl, registryEntry);
-        return redis;
+    const ttl = options2?.ttl ?? defaultTtl;
+    const tags = options2?.tags || [];
+    const expiresAt = ttl ? Date.now() + ttl : null;
+    const entry = {
+      key,
+      value,
+      tags,
+      expiresAt,
+      createdAt: Date.now()
+    };
+    const pipeline = client.pipeline();
+    const serialized = JSON.stringify(entry);
+    if (ttl) {
+      pipeline.setex(cacheKey, Math.ceil(ttl / 1e3), serialized);
+    } else {
+      pipeline.set(cacheKey, serialized);
     }
-    function getCacheKey(key) {
-        return `${keyPrefix}${key}`;
+    for (const tag of tags) {
+      pipeline.sadd(getTagKey(tag), key);
     }
-    function getTagKey(tag) {
-        return `${tagPrefix}${tag}`;
+    await pipeline.exec();
+  };
+  const has = async (key) => {
+    const client = await getRedisClient();
+    const cacheKey = getCacheKey(key);
+    const exists = await client.exists(cacheKey);
+    if (!exists) return false;
+    const data = await client.get(cacheKey);
+    if (!data) return false;
+    try {
+      const entry = JSON.parse(data);
+      if (isExpired(entry)) {
+        await deleteKey(key);
+        return false;
+      }
+      return true;
+    } catch {
+      return false;
     }
-    function isExpired(entry) {
-        if (entry.expiresAt === null)
-            return false;
-        return Date.now() > entry.expiresAt;
+  };
+  const deleteKey = async (key) => {
+    const client = await getRedisClient();
+    const cacheKey = getCacheKey(key);
+    const data = await client.get(cacheKey);
+    if (!data) return false;
+    try {
+      const entry = JSON.parse(data);
+      const pipeline = client.pipeline();
+      for (const tag of entry.tags) {
+        pipeline.srem(getTagKey(tag), key);
+      }
+      pipeline.del(cacheKey);
+      await pipeline.exec();
+      return true;
+    } catch {
+      await client.del(cacheKey);
+      return true;
     }
-    function matchPattern(key, pattern) {
-        const regexPattern = pattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-        const regex = new RegExp(`^${regexPattern}$`);
-        return regex.test(key);
+  };
+  const deleteByTags = async (tags) => {
+    const client = await getRedisClient();
+    const keysToDelete = /* @__PURE__ */ new Set();
+    for (const tag of tags) {
+      const tagKey = getTagKey(tag);
+      const keys2 = await client.smembers(tagKey);
+      for (const key of keys2) {
+        keysToDelete.add(key);
+      }
     }
-    const get = async (key, options) => {
-        const client = await getRedisClient();
-        const cacheKey = getCacheKey(key);
-        const data = await client.get(cacheKey);
-        if (!data)
-            return null;
-        try {
-            const entry = JSON.parse(data);
-            if (isExpired(entry)) {
-                if (options === null || options === void 0 ? void 0 : options.returnExpired) {
-                    return entry.value;
-                }
-                // Clean up expired entry
-                await deleteKey(key);
-                return null;
-            }
-            return entry.value;
-        }
-        catch (_a) {
-            // Invalid JSON, remove it
-            await client.del(cacheKey);
-            return null;
-        }
-    };
-    const set = async (key, value, options) => {
-        var _a;
-        const client = await getRedisClient();
-        const cacheKey = getCacheKey(key);
-        // Remove old entry from tag index if it exists
-        const oldData = await client.get(cacheKey);
-        if (oldData) {
-            try {
-                const oldEntry = JSON.parse(oldData);
-                // Remove from old tags
-                const pipeline = client.pipeline();
-                for (const tag of oldEntry.tags) {
-                    pipeline.srem(getTagKey(tag), key);
-                }
-                await pipeline.exec();
-            }
-            catch (_b) {
-                // Ignore parse errors
-            }
-        }
-        const ttl = (_a = options === null || options === void 0 ? void 0 : options.ttl) !== null && _a !== void 0 ? _a : defaultTtl;
-        const tags = (options === null || options === void 0 ? void 0 : options.tags) || [];
-        const expiresAt = ttl ? Date.now() + ttl : null;
-        const entry = {
-            key,
-            value,
-            tags,
-            expiresAt,
-            createdAt: Date.now(),
-        };
-        const pipeline = client.pipeline();
-        // Store the entry
-        const serialized = JSON.stringify(entry);
-        if (ttl) {
-            pipeline.setex(cacheKey, Math.ceil(ttl / 1000), serialized);
-        }
-        else {
-            pipeline.set(cacheKey, serialized);
-        }
-        // Add to tag index
-        for (const tag of tags) {
-            pipeline.sadd(getTagKey(tag), key);
-        }
-        await pipeline.exec();
-    };
-    const has = async (key) => {
-        const client = await getRedisClient();
-        const cacheKey = getCacheKey(key);
-        const exists = await client.exists(cacheKey);
-        if (!exists)
-            return false;
-        // Check if expired
-        const data = await client.get(cacheKey);
-        if (!data)
-            return false;
+    let deleted = 0;
+    for (const key of keysToDelete) {
+      const success = await deleteKey(key);
+      if (success) deleted++;
+    }
+    return deleted;
+  };
+  const clear = async () => {
+    const client = await getRedisClient();
+    const cacheKeys = await client.keys(`${keyPrefix}*`);
+    const tagKeys = await client.keys(`${tagPrefix}*`);
+    if (cacheKeys.length === 0 && tagKeys.length === 0) return 0;
+    const pipeline = client.pipeline();
+    for (const key of [...cacheKeys, ...tagKeys]) {
+      pipeline.del(key);
+    }
+    await pipeline.exec();
+    return cacheKeys.length;
+  };
+  const keys = async (pattern) => {
+    const client = await getRedisClient();
+    const searchPattern = pattern ? `${keyPrefix}${pattern}` : `${keyPrefix}*`;
+    const cacheKeys = await client.keys(searchPattern);
+    const result = cacheKeys.map((key) => key.substring(keyPrefix.length));
+    if (!pattern) return result;
+    return result.filter((key) => matchPattern(key, pattern));
+  };
+  const stats = async () => {
+    const client = await getRedisClient();
+    const cacheKeys = await client.keys(`${keyPrefix}*`);
+    let expired = 0;
+    for (const cacheKey of cacheKeys) {
+      const data = await client.get(cacheKey);
+      if (data) {
         try {
-            const entry = JSON.parse(data);
-            if (isExpired(entry)) {
-                await deleteKey(key);
-                return false;
-            }
-            return true;
-        }
-        catch (_a) {
-            return false;
+          const entry = JSON.parse(data);
+          if (isExpired(entry)) {
+            expired++;
+          }
+        } catch {
         }
-    };
-    const deleteKey = async (key) => {
-        const client = await getRedisClient();
-        const cacheKey = getCacheKey(key);
-        // Get entry to remove from tag index
-        const data = await client.get(cacheKey);
-        if (!data)
-            return false;
+      }
+    }
+    return { size: cacheKeys.length, expired };
+  };
+  const cleanup = async () => {
+    const client = await getRedisClient();
+    const cacheKeys = await client.keys(`${keyPrefix}*`);
+    let removed = 0;
+    for (const cacheKey of cacheKeys) {
+      const data = await client.get(cacheKey);
+      if (data) {
         try {
-            const entry = JSON.parse(data);
-            const pipeline = client.pipeline();
-            // Remove from tag index
-            for (const tag of entry.tags) {
-                pipeline.srem(getTagKey(tag), key);
-            }
-            // Delete the cache entry
-            pipeline.del(cacheKey);
-            await pipeline.exec();
-            return true;
-        }
-        catch (_a) {
-            // Just delete the key if we can't parse it
-            await client.del(cacheKey);
-            return true;
+          const entry = JSON.parse(data);
+          if (isExpired(entry)) {
+            const key = cacheKey.substring(keyPrefix.length);
+            await deleteKey(key);
+            removed++;
+          }
+        } catch {
+          await client.del(cacheKey);
+          removed++;
         }
-    };
-    const deleteByTags = async (tags) => {
-        const client = await getRedisClient();
-        const keysToDelete = new Set();
-        // Collect all keys that have any of the specified tags
-        for (const tag of tags) {
-            const tagKey = getTagKey(tag);
-            const keys = await client.smembers(tagKey);
-            for (const key of keys) {
-                keysToDelete.add(key);
-            }
-        }
-        // Delete all collected keys
-        let deleted = 0;
-        for (const key of keysToDelete) {
-            const success = await deleteKey(key);
-            if (success)
-                deleted++;
-        }
-        return deleted;
-    };
-    const clear = async () => {
-        const client = await getRedisClient();
-        // Get all cache keys
-        const cacheKeys = await client.keys(`${keyPrefix}*`);
-        const tagKeys = await client.keys(`${tagPrefix}*`);
-        if (cacheKeys.length === 0 && tagKeys.length === 0)
-            return 0;
-        const pipeline = client.pipeline();
-        for (const key of [...cacheKeys, ...tagKeys]) {
-            pipeline.del(key);
-        }
-        await pipeline.exec();
-        return cacheKeys.length;
-    };
-    const keys = async (pattern) => {
-        const client = await getRedisClient();
-        const searchPattern = pattern
-            ? `${keyPrefix}${pattern}`
-            : `${keyPrefix}*`;
-        const cacheKeys = await client.keys(searchPattern);
-        // Remove prefix from keys
-        const result = cacheKeys.map((key) => key.substring(keyPrefix.length));
-        if (!pattern)
-            return result;
-        // Apply pattern matching (Redis KEYS command uses glob pattern, but we want our pattern)
-        return result.filter((key) => matchPattern(key, pattern));
-    };
-    const stats = async () => {
-        const client = await getRedisClient();
-        const cacheKeys = await client.keys(`${keyPrefix}*`);
-        let expired = 0;
-        for (const cacheKey of cacheKeys) {
-            const data = await client.get(cacheKey);
-            if (data) {
-                try {
-                    const entry = JSON.parse(data);
-                    if (isExpired(entry)) {
-                        expired++;
-                    }
-                }
-                catch (_a) {
-                    // Ignore parse errors
-                }
-            }
-        }
-        return { size: cacheKeys.length, expired };
-    };
-    const cleanup = async () => {
-        const client = await getRedisClient();
-        const cacheKeys = await client.keys(`${keyPrefix}*`);
-        let removed = 0;
-        for (const cacheKey of cacheKeys) {
-            const data = await client.get(cacheKey);
-            if (data) {
-                try {
-                    const entry = JSON.parse(data);
-                    if (isExpired(entry)) {
-                        const key = cacheKey.substring(keyPrefix.length);
-                        await deleteKey(key);
-                        removed++;
-                    }
-                }
-                catch (_a) {
-                    // Remove invalid entries
-                    await client.del(cacheKey);
-                    removed++;
-                }
-            }
-        }
-        return removed;
-    };
-    const close = async () => {
-        await releaseRedisEntry(connectionUrl, registryEntry);
-        redis = null;
-    };
-    return {
-        get,
-        set,
-        has,
-        delete: deleteKey,
-        deleteByTags,
-        clear,
-        keys,
-        stats,
-        cleanup,
-        close,
-    };
+      }
+    }
+    return removed;
+  };
+  const close = async () => {
+    await releaseRedisEntry(connectionUrl, registryEntry);
+    redis = null;
+  };
+  return {
+    get,
+    set,
+    has,
+    delete: deleteKey,
+    deleteByTags,
+    clear,
+    keys,
+    stats,
+    cleanup,
+    close
+  };
 }
+export {
+  createRedisStrategy
+};
+//# sourceMappingURL=redis.js.map