@open-mercato/cache 0.3.2

package/dist/service.js

@@ -0,0 +1,321 @@
+import { createMemoryStrategy } from './strategies/memory';
+import { createRedisStrategy } from './strategies/redis';
+import { createSqliteStrategy } from './strategies/sqlite';
+import { createJsonFileStrategy } from './strategies/jsonfile';
+import { getCurrentCacheTenant } from './tenantContext';
+import { createHash } from 'node:crypto';
+import { CacheDependencyUnavailableError } from './errors';
+function normalizeTenantKey(raw) {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (!value)
+        return 'global';
+    return value.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+function isCacheMetadata(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const record = value;
+    const hasValidKey = typeof record.key === 'string';
+    const hasValidExpiresAt = !('expiresAt' in record)
+        || record.expiresAt === null
+        || typeof record.expiresAt === 'number';
+    return hasValidKey && hasValidExpiresAt;
+}
+const KNOWN_STRATEGIES = ['memory', 'redis', 'sqlite', 'jsonfile'];
+function isCacheStrategyName(value) {
+    if (!value)
+        return false;
+    return KNOWN_STRATEGIES.includes(value);
+}
+function resolveTenantPrefixes() {
+    const tenant = normalizeTenantKey(getCurrentCacheTenant());
+    const base = `tenant:${tenant}:`;
+    return {
+        keyPrefix: `${base}key:`,
+        tagPrefix: `${base}tag:`,
+        scopeTag: `${base}tag:__scope__`,
+    };
+}
+function hashIdentifier(input) {
+    return createHash('sha1').update(input).digest('hex');
+}
+function storageKey(originalKey, prefixes) {
+    return `${prefixes.keyPrefix}k:${hashIdentifier(originalKey)}`;
+}
+function metaKey(originalKey, prefixes) {
+    return `${prefixes.keyPrefix}meta:${hashIdentifier(originalKey)}`;
+}
+function hashedTag(tag, prefixes) {
+    return `${prefixes.tagPrefix}t:${hashIdentifier(tag)}`;
+}
+function buildTagSet(tags, prefixes, includeScope) {
+    const scoped = new Set();
+    if (includeScope)
+        scoped.add(prefixes.scopeTag);
+    if (Array.isArray(tags)) {
+        for (const tag of tags) {
+            if (typeof tag === 'string' && tag.length > 0)
+                scoped.add(hashedTag(tag, prefixes));
+        }
+    }
+    return Array.from(scoped);
+}
+function matchPattern(value, pattern) {
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(value);
+}
+function createTenantAwareWrapper(base) {
+    function normalizeDeletionCount(raw) {
+        if (!raw)
+            return raw;
+        if (!Number.isFinite(raw))
+            return raw;
+        return Math.ceil(raw / 2);
+    }
+    const get = async (key, options) => {
+        const prefixes = resolveTenantPrefixes();
+        return base.get(storageKey(key, prefixes), options);
+    };
+    const set = async (key, value, options) => {
+        var _a;
+        const prefixes = resolveTenantPrefixes();
+        const hashedTags = buildTagSet(options === null || options === void 0 ? void 0 : options.tags, prefixes, true);
+        const ttl = (_a = options === null || options === void 0 ? void 0 : options.ttl) !== null && _a !== void 0 ? _a : undefined;
+        const nextOptions = options
+            ? Object.assign(Object.assign({}, options), { tags: hashedTags }) : { tags: hashedTags };
+        await base.set(storageKey(key, prefixes), value, nextOptions);
+        const metaPayload = { key, expiresAt: ttl ? Date.now() + ttl : null };
+        await base.set(metaKey(key, prefixes), metaPayload, {
+            ttl,
+            tags: hashedTags,
+        });
+    };
+    const has = async (key) => {
+        const prefixes = resolveTenantPrefixes();
+        return base.has(storageKey(key, prefixes));
+    };
+    const del = async (key) => {
+        const prefixes = resolveTenantPrefixes();
+        const primary = await base.delete(storageKey(key, prefixes));
+        await base.delete(metaKey(key, prefixes));
+        return primary;
+    };
+    const deleteByTags = async (tags) => {
+        const prefixes = resolveTenantPrefixes();
+        const scopedTags = buildTagSet(tags, prefixes, false);
+        if (!scopedTags.length)
+            return 0;
+        const removed = await base.deleteByTags(scopedTags);
+        return normalizeDeletionCount(removed);
+    };
+    const clear = async () => {
+        const prefixes = resolveTenantPrefixes();
+        const removed = await base.deleteByTags([prefixes.scopeTag]);
+        return normalizeDeletionCount(removed);
+    };
+    const keys = async (pattern) => {
+        const prefixes = resolveTenantPrefixes();
+        const metaPattern = `${prefixes.keyPrefix}meta:*`;
+        const metaKeys = await base.keys(metaPattern);
+        const originals = [];
+        for (const metaKey of metaKeys) {
+            const metaValue = await base.get(metaKey, { returnExpired: true });
+            if (!metaValue)
+                continue;
+            const metadata = typeof metaValue === 'string' ? null : (isCacheMetadata(metaValue) ? metaValue : null);
+            const original = typeof metaValue === 'string' ? metaValue : metadata === null || metadata === void 0 ? void 0 : metadata.key;
+            if (!original)
+                continue;
+            if (pattern && !matchPattern(original, pattern))
+                continue;
+            originals.push(original);
+        }
+        return originals;
+    };
+    const stats = async () => {
+        var _a;
+        const prefixes = resolveTenantPrefixes();
+        const metaKeys = await base.keys(`${prefixes.keyPrefix}meta:*`);
+        let size = 0;
+        let expired = 0;
+        const now = Date.now();
+        for (const metaKey of metaKeys) {
+            const metaValue = await base.get(metaKey, { returnExpired: true });
+            if (!metaValue)
+                continue;
+            const metadata = typeof metaValue === 'string' ? null : (isCacheMetadata(metaValue) ? metaValue : null);
+            const original = typeof metaValue === 'string' ? metaValue : metadata === null || metadata === void 0 ? void 0 : metadata.key;
+            if (!original)
+                continue;
+            size++;
+            const expiresAt = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.expiresAt) !== null && _a !== void 0 ? _a : null;
+            if (expiresAt !== null && expiresAt <= now)
+                expired++;
+        }
+        return { size, expired };
+    };
+    const cleanup = base.cleanup
+        ? async () => normalizeDeletionCount(await base.cleanup())
+        : undefined;
+    const close = base.close
+        ? async () => base.close()
+        : undefined;
+    return {
+        get,
+        set,
+        has,
+        delete: del,
+        deleteByTags,
+        clear,
+        keys,
+        stats,
+        cleanup,
+        close,
+    };
+}
+/**
+ * Cache service that provides a unified interface to different cache strategies
+ *
+ * Configuration via environment variables:
+ * - CACHE_STRATEGY: 'memory' | 'redis' | 'sqlite' | 'jsonfile' (default: 'memory')
+ * - CACHE_TTL: Default TTL in milliseconds (optional)
+ * - CACHE_REDIS_URL: Redis connection URL (for redis strategy)
+ * - CACHE_SQLITE_PATH: SQLite database file path (for sqlite strategy)
+ * - CACHE_JSON_FILE_PATH: JSON file path (for jsonfile strategy)
+ *
+ * @example
+ * const cache = createCacheService({ strategy: 'memory', defaultTtl: 60000 })
+ * await cache.set('user:123', { name: 'John' }, { tags: ['users', 'user:123'] })
+ * const user = await cache.get('user:123')
+ * await cache.deleteByTags(['users']) // Invalidate all user-related cache
+ */
+export function createCacheService(options) {
+    var _a, _b, _c;
+    const envStrategy = isCacheStrategyName(process.env.CACHE_STRATEGY)
+        ? process.env.CACHE_STRATEGY
+        : undefined;
+    const strategyType = (_b = (_a = options === null || options === void 0 ? void 0 : options.strategy) !== null && _a !== void 0 ? _a : envStrategy) !== null && _b !== void 0 ? _b : 'memory';
+    const envTtl = process.env.CACHE_TTL;
+    const parsedEnvTtl = envTtl ? Number.parseInt(envTtl, 10) : undefined;
+    const defaultTtl = (_c = options === null || options === void 0 ? void 0 : options.defaultTtl) !== null && _c !== void 0 ? _c : (typeof parsedEnvTtl === 'number' && Number.isFinite(parsedEnvTtl) ? parsedEnvTtl : undefined);
+    const baseStrategy = createStrategyForType(strategyType, options, defaultTtl);
+    const resilientStrategy = withDependencyFallback(baseStrategy, strategyType, defaultTtl);
+    return createTenantAwareWrapper(resilientStrategy);
+}
+/**
+ * CacheService class wrapper for DI integration
+ * Provides the same interface as the functional API but as a class
+ */
+export class CacheService {
+    constructor(options) {
+        this.strategy = createCacheService(options);
+    }
+    async get(key, options) {
+        return this.strategy.get(key, options);
+    }
+    async set(key, value, options) {
+        return this.strategy.set(key, value, options);
+    }
+    async has(key) {
+        return this.strategy.has(key);
+    }
+    async delete(key) {
+        return this.strategy.delete(key);
+    }
+    async deleteByTags(tags) {
+        return this.strategy.deleteByTags(tags);
+    }
+    async clear() {
+        return this.strategy.clear();
+    }
+    async keys(pattern) {
+        return this.strategy.keys(pattern);
+    }
+    async stats() {
+        return this.strategy.stats();
+    }
+    async cleanup() {
+        if (this.strategy.cleanup) {
+            return this.strategy.cleanup();
+        }
+        return 0;
+    }
+    async close() {
+        if (this.strategy.close) {
+            return this.strategy.close();
+        }
+    }
+}
+function createStrategyForType(strategyType, options, defaultTtl) {
+    switch (strategyType) {
+        case 'redis':
+            return createRedisStrategy(options === null || options === void 0 ? void 0 : options.redisUrl, { defaultTtl });
+        case 'sqlite':
+            return createSqliteStrategy(options === null || options === void 0 ? void 0 : options.sqlitePath, { defaultTtl });
+        case 'jsonfile':
+            return createJsonFileStrategy(options === null || options === void 0 ? void 0 : options.jsonFilePath, { defaultTtl });
+        case 'memory':
+        default:
+            return createMemoryStrategy({ defaultTtl });
+    }
+}
+function withDependencyFallback(strategy, strategyType, defaultTtl) {
+    if (strategyType === 'memory')
+        return strategy;
+    let activeStrategy = strategy;
+    let fallbackStrategy = null;
+    let warned = false;
+    const ensureFallback = (error) => {
+        if (!fallbackStrategy) {
+            fallbackStrategy = createMemoryStrategy({ defaultTtl });
+        }
+        if (!warned) {
+            const dependencyMessage = error.dependency
+                ? ` (missing dependency: ${error.dependency})`
+                : '';
+            console.warn(`[cache] ${error.strategy} strategy unavailable${dependencyMessage}. Falling back to memory strategy.`);
+            warned = true;
+        }
+        activeStrategy = fallbackStrategy;
+    };
+    const wrapMethod = (method) => {
+        const handler = async (...args) => {
+            const fn = activeStrategy[method];
+            if (!fn) {
+                return undefined;
+            }
+            try {
+                return await fn(...args);
+            }
+            catch (error) {
+                if (error instanceof CacheDependencyUnavailableError) {
+                    ensureFallback(error);
+                    const fallbackFn = activeStrategy[method];
+                    if (!fallbackFn) {
+                        return undefined;
+                    }
+                    return fallbackFn(...args);
+                }
+                throw error;
+            }
+        };
+        return handler;
+    };
+    return {
+        get: wrapMethod('get'),
+        set: wrapMethod('set'),
+        has: wrapMethod('has'),
+        delete: wrapMethod('delete'),
+        deleteByTags: wrapMethod('deleteByTags'),
+        clear: wrapMethod('clear'),
+        keys: wrapMethod('keys'),
+        stats: wrapMethod('stats'),
+        cleanup: typeof strategy.cleanup === 'function' ? wrapMethod('cleanup') : undefined,
+        close: typeof strategy.close === 'function' ? wrapMethod('close') : undefined,
+    };
+}

package/dist/strategies/jsonfile.d.ts

@@ -0,0 +1,10 @@
+import type { CacheStrategy } from '../types';
+/**
+ * JSON file cache strategy with tag support
+ * Persistent across process restarts, stored in JSON files
+ * Simple and requires no external dependencies, but not suitable for high-performance scenarios
+ */
+export declare function createJsonFileStrategy(filePath?: string, options?: {
+    defaultTtl?: number;
+}): CacheStrategy;
+//# sourceMappingURL=jsonfile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsonfile.d.ts","sourceRoot":"","sources":["../../src/strategies/jsonfile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAA4D,MAAM,UAAU,CAAA;AAIvG;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CA+O1G"}

package/dist/strategies/jsonfile.js

@@ -0,0 +1,205 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * JSON file cache strategy with tag support
+ * Persistent across process restarts, stored in JSON files
+ * Simple and requires no external dependencies, but not suitable for high-performance scenarios
+ */
+export function createJsonFileStrategy(filePath, options) {
+    const defaultTtl = options === null || options === void 0 ? void 0 : options.defaultTtl;
+    const cacheFile = filePath || process.env.CACHE_JSON_FILE_PATH || '.cache.json';
+    const dir = path.dirname(cacheFile);
+    function ensureDir() {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    function readData() {
+        ensureDir();
+        if (!fs.existsSync(cacheFile)) {
+            return { entries: {}, tagIndex: {} };
+        }
+        try {
+            const content = fs.readFileSync(cacheFile, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (_a) {
+            return { entries: {}, tagIndex: {} };
+        }
+    }
+    function writeData(data) {
+        ensureDir();
+        fs.writeFileSync(cacheFile, JSON.stringify(data, null, 2), 'utf8');
+    }
+    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);
+    }
+    function addToTagIndex(data, key, tags) {
+        for (const tag of tags) {
+            if (!data.tagIndex[tag]) {
+                data.tagIndex[tag] = [];
+            }
+            if (!data.tagIndex[tag].includes(key)) {
+                data.tagIndex[tag].push(key);
+            }
+        }
+    }
+    function removeFromTagIndex(data, key, tags) {
+        for (const tag of tags) {
+            if (data.tagIndex[tag]) {
+                data.tagIndex[tag] = data.tagIndex[tag].filter((k) => k !== key);
+                if (data.tagIndex[tag].length === 0) {
+                    delete data.tagIndex[tag];
+                }
+            }
+        }
+    }
+    const get = async (key, options) => {
+        const data = readData();
+        const entry = data.entries[key];
+        if (!entry)
+            return null;
+        if (isExpired(entry)) {
+            if (options === null || options === void 0 ? void 0 : options.returnExpired) {
+                return entry.value;
+            }
+            // Clean up expired entry
+            removeFromTagIndex(data, key, entry.tags);
+            delete data.entries[key];
+            writeData(data);
+            return null;
+        }
+        return entry.value;
+    };
+    const set = async (key, value, options) => {
+        var _a;
+        const data = readData();
+        // Remove old entry from tag index if it exists
+        const oldEntry = data.entries[key];
+        if (oldEntry) {
+            removeFromTagIndex(data, 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(),
+        };
+        data.entries[key] = entry;
+        addToTagIndex(data, key, tags);
+        writeData(data);
+    };
+    const has = async (key) => {
+        const data = readData();
+        const entry = data.entries[key];
+        if (!entry)
+            return false;
+        if (isExpired(entry)) {
+            removeFromTagIndex(data, key, entry.tags);
+            delete data.entries[key];
+            writeData(data);
+            return false;
+        }
+        return true;
+    };
+    const deleteKey = async (key) => {
+        const data = readData();
+        const entry = data.entries[key];
+        if (!entry)
+            return false;
+        removeFromTagIndex(data, key, entry.tags);
+        delete data.entries[key];
+        writeData(data);
+        return true;
+    };
+    const deleteByTags = async (tags) => {
+        const data = readData();
+        const keysToDelete = new Set();
+        // Collect all keys that have any of the specified tags
+        for (const tag of tags) {
+            const keys = data.tagIndex[tag] || [];
+            for (const key of keys) {
+                keysToDelete.add(key);
+            }
+        }
+        // Delete all collected keys
+        for (const key of keysToDelete) {
+            const entry = data.entries[key];
+            if (entry) {
+                removeFromTagIndex(data, key, entry.tags);
+                delete data.entries[key];
+            }
+        }
+        writeData(data);
+        return keysToDelete.size;
+    };
+    const clear = async () => {
+        const data = readData();
+        const size = Object.keys(data.entries).length;
+        writeData({ entries: {}, tagIndex: {} });
+        return size;
+    };
+    const keys = async (pattern) => {
+        const data = readData();
+        const allKeys = Object.keys(data.entries);
+        if (!pattern)
+            return allKeys;
+        return allKeys.filter((key) => matchPattern(key, pattern));
+    };
+    const stats = async () => {
+        const data = readData();
+        const allEntries = Object.values(data.entries);
+        let expired = 0;
+        for (const entry of allEntries) {
+            if (isExpired(entry)) {
+                expired++;
+            }
+        }
+        return { size: allEntries.length, expired };
+    };
+    const cleanup = async () => {
+        const data = readData();
+        let removed = 0;
+        const keysToRemove = [];
+        for (const [key, entry] of Object.entries(data.entries)) {
+            if (isExpired(entry)) {
+                keysToRemove.push(key);
+            }
+        }
+        for (const key of keysToRemove) {
+            const entry = data.entries[key];
+            removeFromTagIndex(data, key, entry.tags);
+            delete data.entries[key];
+            removed++;
+        }
+        if (removed > 0) {
+            writeData(data);
+        }
+        return removed;
+    };
+    return {
+        get,
+        set,
+        has,
+        delete: deleteKey,
+        deleteByTags,
+        clear,
+        keys,
+        stats,
+        cleanup,
+    };
+}

package/dist/strategies/memory.d.ts

@@ -0,0 +1,9 @@
+import type { CacheStrategy } from '../types';
+/**
+ * In-memory cache strategy with tag support
+ * Fast but data is lost when process restarts
+ */
+export declare function createMemoryStrategy(options?: {
+    defaultTtl?: number;
+}): CacheStrategy;
+//# sourceMappingURL=memory.d.ts.map

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

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