@open-mercato/cache 0.3.2

package/dist/strategies/memory.js

@@ -0,0 +1,166 @@
+/**
+ * In-memory cache strategy with tag support
+ * Fast but data is lost when process restarts
+ */
+export function createMemoryStrategy(options) {
+    const store = new Map();
+    const tagIndex = new Map(); // tag -> Set of keys
+    const defaultTtl = options === null || options === void 0 ? void 0 : options.defaultTtl;
+    function isExpired(entry) {
+        if (entry.expiresAt === null)
+            return false;
+        return Date.now() > entry.expiresAt;
+    }
+    function cleanupExpiredEntry(key, entry) {
+        store.delete(key);
+        // Remove from tag index
+        for (const tag of entry.tags) {
+            const keys = tagIndex.get(tag);
+            if (keys) {
+                keys.delete(key);
+                if (keys.size === 0) {
+                    tagIndex.delete(tag);
+                }
+            }
+        }
+    }
+    function addToTagIndex(key, tags) {
+        for (const tag of tags) {
+            if (!tagIndex.has(tag)) {
+                tagIndex.set(tag, new Set());
+            }
+            tagIndex.get(tag).add(key);
+        }
+    }
+    function removeFromTagIndex(key, tags) {
+        for (const tag of tags) {
+            const keys = tagIndex.get(tag);
+            if (keys) {
+                keys.delete(key);
+                if (keys.size === 0) {
+                    tagIndex.delete(tag);
+                }
+            }
+        }
+    }
+    function matchPattern(key, pattern) {
+        const regexPattern = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars
+            .replace(/\*/g, '.*') // * matches any characters
+            .replace(/\?/g, '.'); // ? matches single character
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(key);
+    }
+    const get = async (key, options) => {
+        const entry = store.get(key);
+        if (!entry)
+            return null;
+        if (isExpired(entry)) {
+            if (options === null || options === void 0 ? void 0 : options.returnExpired) {
+                return entry.value;
+            }
+            cleanupExpiredEntry(key, entry);
+            return null;
+        }
+        return entry.value;
+    };
+    const set = async (key, value, options) => {
+        var _a;
+        // Remove old entry from tag index if it exists
+        const oldEntry = store.get(key);
+        if (oldEntry) {
+            removeFromTagIndex(key, oldEntry.tags);
+        }
+        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(),
+        };
+        store.set(key, entry);
+        addToTagIndex(key, tags);
+    };
+    const has = async (key) => {
+        const entry = store.get(key);
+        if (!entry)
+            return false;
+        if (isExpired(entry)) {
+            cleanupExpiredEntry(key, entry);
+            return false;
+        }
+        return true;
+    };
+    const deleteKey = async (key) => {
+        const entry = store.get(key);
+        if (!entry)
+            return false;
+        removeFromTagIndex(key, entry.tags);
+        return store.delete(key);
+    };
+    const deleteByTags = async (tags) => {
+        const keysToDelete = new Set();
+        // Collect all keys that have any of the specified tags
+        for (const tag of tags) {
+            const keys = tagIndex.get(tag);
+            if (keys) {
+                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 size = store.size;
+        store.clear();
+        tagIndex.clear();
+        return size;
+    };
+    const keys = async (pattern) => {
+        const allKeys = Array.from(store.keys());
+        if (!pattern)
+            return allKeys;
+        return allKeys.filter((key) => matchPattern(key, pattern));
+    };
+    const stats = async () => {
+        let expired = 0;
+        for (const entry of store.values()) {
+            if (isExpired(entry)) {
+                expired++;
+            }
+        }
+        return { size: store.size, expired };
+    };
+    const cleanup = async () => {
+        let removed = 0;
+        for (const [key, entry] of store.entries()) {
+            if (isExpired(entry)) {
+                cleanupExpiredEntry(key, entry);
+                removed++;
+            }
+        }
+        return removed;
+    };
+    return {
+        get,
+        set,
+        has,
+        delete: deleteKey,
+        deleteByTags,
+        clear,
+        keys,
+        stats,
+        cleanup,
+    };
+}

package/dist/strategies/redis.d.ts

@@ -0,0 +1,5 @@
+import type { CacheStrategy } from '../types';
+export declare function createRedisStrategy(redisUrl?: string, options?: {
+    defaultTtl?: number;
+}): CacheStrategy;
+//# sourceMappingURL=redis.d.ts.map

package/dist/strategies/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../src/strategies/redis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAA4D,MAAM,UAAU,CAAA;AAwJvG,wBAAgB,mBAAmB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAkSvG"}

package/dist/strategies/redis.js

@@ -0,0 +1,388 @@
+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
+ */
+let redisModulePromise = null;
+const redisRegistry = 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;
+}
+function loadRedisModuleViaRequire() {
+    const resolver = resolveRequire();
+    if (!resolver)
+        return null;
+    try {
+        return resolver('ioredis');
+    }
+    catch (_a) {
+        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);
+        }
+    }
+    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;
+}
+function retainRedisEntry(key) {
+    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;
+    });
+    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
+        }
+        finally {
+            entry.client = undefined;
+        }
+    }
+}
+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;
+    }
+    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, 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;
+        try {
+            const entry = JSON.parse(data);
+            if (isExpired(entry)) {
+                await deleteKey(key);
+                return false;
+            }
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    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;
+        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 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,
+    };
+}

package/dist/strategies/sqlite.d.ts

@@ -0,0 +1,13 @@
+import type { CacheStrategy } from '../types';
+/**
+ * SQLite cache strategy with tag support
+ * Persistent across process restarts, stored in a SQLite database file
+ *
+ * Uses two tables:
+ * - cache_entries: stores cache data
+ * - cache_tags: stores tag associations (many-to-many)
+ */
+export declare function createSqliteStrategy(dbPath?: string, options?: {
+    defaultTtl?: number;
+}): CacheStrategy;
+//# sourceMappingURL=sqlite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/strategies/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgD,MAAM,UAAU,CAAA;AAuB3F;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CA6PtG"}