@hazeljs/cache 0.2.0-alpha.1

package/dist/cache.module.d.ts

@@ -0,0 +1,81 @@
+import { CacheService, CacheManager } from './cache.service';
+import { CacheStrategy } from './cache.types';
+/**
+ * Cache module options
+ */
+export interface CacheModuleOptions {
+    /**
+     * Cache strategy to use
+     * @default 'memory'
+     */
+    strategy?: CacheStrategy;
+    /**
+     * Whether this is a global module
+     * @default true
+     */
+    isGlobal?: boolean;
+    /**
+     * Redis options (if using redis or multi-tier strategy)
+     */
+    redis?: {
+        host?: string;
+        port?: number;
+        password?: string;
+    };
+    /**
+     * Memory cache cleanup interval in milliseconds
+     * @default 60000
+     */
+    cleanupInterval?: number;
+    /**
+     * Multiple cache configurations
+     */
+    stores?: Array<{
+        name: string;
+        strategy: CacheStrategy;
+        isDefault?: boolean;
+        options?: {
+            redis?: {
+                host?: string;
+                port?: number;
+                password?: string;
+            };
+            cleanupInterval?: number;
+        };
+    }>;
+}
+/**
+ * Cache module for HazelJS
+ */
+export declare class CacheModule {
+    /**
+     * Configure cache module
+     */
+    static forRoot(options?: CacheModuleOptions): {
+        module: typeof CacheModule;
+        providers: Array<{
+            provide: typeof CacheService | typeof CacheManager;
+            useFactory?: () => CacheService;
+            useValue?: CacheManager;
+        }>;
+        exports: Array<typeof CacheService | typeof CacheManager>;
+        global: boolean;
+    };
+    /**
+     * Configure cache module asynchronously
+     */
+    static forRootAsync(options: {
+        useFactory: (...args: unknown[]) => Promise<CacheModuleOptions> | CacheModuleOptions;
+        inject?: unknown[];
+    }): {
+        module: typeof CacheModule;
+        providers: Array<{
+            provide: string | typeof CacheManager | typeof CacheService;
+            useFactory: unknown;
+            inject?: unknown[];
+        }>;
+        exports: Array<typeof CacheService | typeof CacheManager>;
+        global: boolean;
+    };
+}
+//# sourceMappingURL=cache.module.d.ts.map

package/dist/cache.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.module.d.ts","sourceRoot":"","sources":["../src/cache.module.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG9C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IAEzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IAEF;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,MAAM,CAAC,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,aAAa,CAAC;QACxB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,OAAO,CAAC,EAAE;YACR,KAAK,CAAC,EAAE;gBACN,IAAI,CAAC,EAAE,MAAM,CAAC;gBACd,IAAI,CAAC,EAAE,MAAM,CAAC;gBACd,QAAQ,CAAC,EAAE,MAAM,CAAC;aACnB,CAAC;YACF,eAAe,CAAC,EAAE,MAAM,CAAC;SAC1B,CAAC;KACH,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,qBAIa,WAAW;IACtB;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,kBAAuB,GAAG;QAChD,MAAM,EAAE,OAAO,WAAW,CAAC;QAC3B,SAAS,EAAE,KAAK,CAAC;YACf,OAAO,EAAE,OAAO,YAAY,GAAG,OAAO,YAAY,CAAC;YACnD,UAAU,CAAC,EAAE,MAAM,YAAY,CAAC;YAChC,QAAQ,CAAC,EAAE,YAAY,CAAC;SACzB,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,CAAC,OAAO,YAAY,GAAG,OAAO,YAAY,CAAC,CAAC;QAC1D,MAAM,EAAE,OAAO,CAAC;KACjB;IAwCD;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE;QAC3B,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,kBAAkB,CAAC,GAAG,kBAAkB,CAAC;QACrF,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;KACpB,GAAG;QACF,MAAM,EAAE,OAAO,WAAW,CAAC;QAC3B,SAAS,EAAE,KAAK,CAAC;YACf,OAAO,EAAE,MAAM,GAAG,OAAO,YAAY,GAAG,OAAO,YAAY,CAAC;YAC5D,UAAU,EAAE,OAAO,CAAC;YACpB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;SACpB,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,CAAC,OAAO,YAAY,GAAG,OAAO,YAAY,CAAC,CAAC;QAC1D,MAAM,EAAE,OAAO,CAAC;KACjB;CA2CF"}

package/dist/cache.module.js

@@ -0,0 +1,111 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var CacheModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheModule = void 0;
+const core_1 = require("@hazeljs/core");
+const cache_service_1 = require("./cache.service");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Cache module for HazelJS
+ */
+let CacheModule = CacheModule_1 = class CacheModule {
+    /**
+     * Configure cache module
+     */
+    static forRoot(options = {}) {
+        const { strategy = 'memory', isGlobal = true, redis, cleanupInterval, stores } = options;
+        core_2.default.info('Configuring cache module...');
+        // Create cache manager
+        const cacheManager = new cache_service_1.CacheManager();
+        // If multiple stores are configured
+        if (stores && stores.length > 0) {
+            for (const storeConfig of stores) {
+                const cache = new cache_service_1.CacheService(storeConfig.strategy, {
+                    redis: storeConfig.options?.redis || redis,
+                    cleanupInterval: storeConfig.options?.cleanupInterval || cleanupInterval,
+                });
+                cacheManager.register(storeConfig.name, cache, storeConfig.isDefault);
+            }
+        }
+        else {
+            // Single cache configuration
+            const cache = new cache_service_1.CacheService(strategy, { redis, cleanupInterval });
+            cacheManager.register('default', cache, true);
+        }
+        return {
+            module: CacheModule_1,
+            providers: [
+                {
+                    provide: cache_service_1.CacheService,
+                    useFactory: () => cacheManager.get(),
+                },
+                {
+                    provide: cache_service_1.CacheManager,
+                    useValue: cacheManager,
+                },
+            ],
+            exports: [cache_service_1.CacheService, cache_service_1.CacheManager],
+            global: isGlobal,
+        };
+    }
+    /**
+     * Configure cache module asynchronously
+     */
+    static forRootAsync(options) {
+        return {
+            module: CacheModule_1,
+            providers: [
+                {
+                    provide: 'CACHE_OPTIONS',
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+                {
+                    provide: cache_service_1.CacheManager,
+                    useFactory: async (cacheOptions) => {
+                        const { strategy = 'memory', redis, cleanupInterval, stores } = cacheOptions;
+                        const cacheManager = new cache_service_1.CacheManager();
+                        if (stores && stores.length > 0) {
+                            for (const storeConfig of stores) {
+                                const cache = new cache_service_1.CacheService(storeConfig.strategy, {
+                                    redis: storeConfig.options?.redis || redis,
+                                    cleanupInterval: storeConfig.options?.cleanupInterval || cleanupInterval,
+                                });
+                                cacheManager.register(storeConfig.name, cache, storeConfig.isDefault);
+                            }
+                        }
+                        else {
+                            const cache = new cache_service_1.CacheService(strategy, { redis, cleanupInterval });
+                            cacheManager.register('default', cache, true);
+                        }
+                        return cacheManager;
+                    },
+                    inject: ['CACHE_OPTIONS'],
+                },
+                {
+                    provide: cache_service_1.CacheService,
+                    useFactory: (cacheManager) => cacheManager.get(),
+                    inject: [cache_service_1.CacheManager],
+                },
+            ],
+            exports: [cache_service_1.CacheService, cache_service_1.CacheManager],
+            global: true,
+        };
+    }
+};
+exports.CacheModule = CacheModule;
+exports.CacheModule = CacheModule = CacheModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [],
+        exports: [],
+    })
+], CacheModule);

package/dist/cache.service.d.ts

@@ -0,0 +1,109 @@
+import { ICacheStore, CacheStats, CacheWarmingOptions, CacheStrategy } from './cache.types';
+/**
+ * Cache service for managing cache operations
+ */
+export declare class CacheService {
+    private store;
+    private strategy;
+    constructor(strategy?: CacheStrategy, options?: unknown);
+    /**
+     * Create cache store based on strategy
+     */
+    private createStore;
+    /**
+     * Get a value from cache
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in cache
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Set a value with tags
+     */
+    setWithTags<T>(key: string, value: T, ttl: number, tags?: string[]): Promise<void>;
+    /**
+     * Delete a value from cache
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete entries by tag
+     */
+    deleteByTag(tag: string): Promise<void>;
+    /**
+     * Invalidate cache by tags
+     */
+    invalidateTags(tags: string[]): Promise<void>;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Clear all cache entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all keys matching a pattern
+     */
+    keys(pattern?: string): Promise<string[]>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Warm up cache with predefined data
+     */
+    warmUp(options: CacheWarmingOptions): Promise<void>;
+    /**
+     * Get or set a value (cache-aside pattern)
+     */
+    getOrSet<T>(key: string, fetcher: () => Promise<T>, ttl?: number, tags?: string[]): Promise<T>;
+    /**
+     * Wrap a function with caching
+     */
+    wrap<T>(key: string, fn: () => Promise<T>, ttl?: number): Promise<T>;
+    /**
+     * Get the underlying cache store
+     */
+    getStore(): ICacheStore;
+    /**
+     * Get cache strategy
+     */
+    getStrategy(): CacheStrategy;
+    /**
+     * Reset cache statistics
+     */
+    resetStats(): void;
+}
+/**
+ * Cache manager for managing multiple cache instances
+ */
+export declare class CacheManager {
+    private caches;
+    private defaultCache?;
+    /**
+     * Register a cache instance
+     */
+    register(name: string, cache: CacheService, isDefault?: boolean): void;
+    /**
+     * Get a cache instance by name
+     */
+    get(name?: string): CacheService;
+    /**
+     * Get all cache instances
+     */
+    getAll(): Map<string, CacheService>;
+    /**
+     * Clear all caches
+     */
+    clearAll(): Promise<void>;
+    /**
+     * Get statistics for all caches
+     */
+    getAllStats(): Promise<Map<string, CacheStats>>;
+    /**
+     * Invalidate tags across all caches
+     */
+    invalidateTagsGlobal(tags: string[]): Promise<void>;
+}
+//# sourceMappingURL=cache.service.d.ts.map

package/dist/cache.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.service.d.ts","sourceRoot":"","sources":["../src/cache.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAM5F;;GAEG;AACH,qBACa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,QAAQ,CAAgB;gBAEpB,QAAQ,GAAE,aAAwB,EAAE,OAAO,CAAC,EAAE,OAAO;IAMjE;;OAEG;IACH,OAAO,CAAC,WAAW;IAiBnB;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAI5C;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhE;;OAEG;IACG,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAexF;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxC;;OAEG;IACG,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW7C;;OAEG;IACG,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAOnD;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAI/C;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAIrC;;OAEG;IACG,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BzD;;OAEG;IACG,QAAQ,CAAC,CAAC,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,GAAG,CAAC,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,CAAC,CAAC;IAoBb;;OAEG;IACH,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAIpE;;OAEG;IACH,QAAQ,IAAI,WAAW;IAIvB;;OAEG;IACH,WAAW,IAAI,aAAa;IAI5B;;OAEG;IACH,UAAU,IAAI,IAAI;CAQnB;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,SAAS,UAAQ,GAAG,IAAI;IAQpE;;OAEG;IACH,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,YAAY;IAgBhC;;OAEG;IACH,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC;IAInC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAUrD;;OAEG;IACG,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAI1D"}

package/dist/cache.service.js

@@ -0,0 +1,263 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = exports.CacheService = void 0;
+const core_1 = require("@hazeljs/core");
+const memory_strategy_1 = require("./strategies/memory.strategy");
+const redis_strategy_1 = require("./strategies/redis.strategy");
+const multi_tier_strategy_1 = require("./strategies/multi-tier.strategy");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Cache service for managing cache operations
+ */
+let CacheService = class CacheService {
+    constructor(strategy = 'memory', options) {
+        this.strategy = strategy;
+        this.store = this.createStore(strategy, options);
+        core_2.default.info(`Cache service initialized with strategy: ${strategy}`);
+    }
+    /**
+     * Create cache store based on strategy
+     */
+    createStore(strategy, options) {
+        const opts = options;
+        switch (strategy) {
+            case 'redis':
+                return new redis_strategy_1.RedisCacheStore(opts?.redis);
+            case 'multi-tier':
+                return new multi_tier_strategy_1.MultiTierCacheStore(opts);
+            case 'memory':
+            default:
+                return new memory_strategy_1.MemoryCacheStore(opts?.cleanupInterval);
+        }
+    }
+    /**
+     * Get a value from cache
+     */
+    async get(key) {
+        return await this.store.get(key);
+    }
+    /**
+     * Set a value in cache
+     */
+    async set(key, value, ttl) {
+        await this.store.set(key, value, ttl);
+    }
+    /**
+     * Set a value with tags
+     */
+    async setWithTags(key, value, ttl, tags) {
+        if ('setWithTags' in this.store &&
+            typeof this.store.setWithTags === 'function') {
+            await this.store.setWithTags(key, value, ttl, tags);
+        }
+        else {
+            await this.store.set(key, value, ttl);
+        }
+    }
+    /**
+     * Delete a value from cache
+     */
+    async delete(key) {
+        await this.store.delete(key);
+    }
+    /**
+     * Delete entries by tag
+     */
+    async deleteByTag(tag) {
+        if ('deleteByTag' in this.store &&
+            typeof this.store.deleteByTag === 'function') {
+            await this.store.deleteByTag(tag);
+        }
+        else {
+            core_2.default.warn(`deleteByTag not supported for ${this.strategy} strategy`);
+        }
+    }
+    /**
+     * Invalidate cache by tags
+     */
+    async invalidateTags(tags) {
+        for (const tag of tags) {
+            await this.deleteByTag(tag);
+        }
+        core_2.default.info(`Invalidated cache for tags: ${tags.join(', ')}`);
+    }
+    /**
+     * Check if key exists in cache
+     */
+    async has(key) {
+        return await this.store.has(key);
+    }
+    /**
+     * Clear all cache entries
+     */
+    async clear() {
+        await this.store.clear();
+    }
+    /**
+     * Get all keys matching a pattern
+     */
+    async keys(pattern) {
+        return await this.store.keys(pattern);
+    }
+    /**
+     * Get cache statistics
+     */
+    async getStats() {
+        return await this.store.getStats();
+    }
+    /**
+     * Warm up cache with predefined data
+     */
+    async warmUp(options) {
+        const { keys, fetcher, ttl = 3600, parallel = true } = options;
+        core_2.default.info(`Warming up cache for ${keys.length} keys...`);
+        const warmUpKey = async (key) => {
+            try {
+                const data = await fetcher(key);
+                await this.set(key, data, ttl);
+                core_2.default.debug(`Warmed up cache key: ${key}`);
+            }
+            catch (error) {
+                core_2.default.error(`Failed to warm up cache key ${key}:`, error);
+            }
+        };
+        if (parallel) {
+            await Promise.all(keys.map(warmUpKey));
+        }
+        else {
+            for (const key of keys) {
+                await warmUpKey(key);
+            }
+        }
+        core_2.default.info(`Cache warming completed for ${keys.length} keys`);
+    }
+    /**
+     * Get or set a value (cache-aside pattern)
+     */
+    async getOrSet(key, fetcher, ttl, tags) {
+        // Try to get from cache
+        const cached = await this.get(key);
+        if (cached !== null) {
+            return cached;
+        }
+        // Fetch data
+        const data = await fetcher();
+        // Store in cache
+        if (tags) {
+            await this.setWithTags(key, data, ttl || 3600, tags);
+        }
+        else {
+            await this.set(key, data, ttl);
+        }
+        return data;
+    }
+    /**
+     * Wrap a function with caching
+     */
+    wrap(key, fn, ttl) {
+        return this.getOrSet(key, fn, ttl);
+    }
+    /**
+     * Get the underlying cache store
+     */
+    getStore() {
+        return this.store;
+    }
+    /**
+     * Get cache strategy
+     */
+    getStrategy() {
+        return this.strategy;
+    }
+    /**
+     * Reset cache statistics
+     */
+    resetStats() {
+        if ('resetStats' in this.store &&
+            typeof this.store.resetStats === 'function') {
+            this.store.resetStats();
+        }
+    }
+};
+exports.CacheService = CacheService;
+exports.CacheService = CacheService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [String, Object])
+], CacheService);
+/**
+ * Cache manager for managing multiple cache instances
+ */
+class CacheManager {
+    constructor() {
+        this.caches = new Map();
+    }
+    /**
+     * Register a cache instance
+     */
+    register(name, cache, isDefault = false) {
+        this.caches.set(name, cache);
+        if (isDefault || !this.defaultCache) {
+            this.defaultCache = cache;
+        }
+        core_2.default.info(`Cache registered: ${name}${isDefault ? ' (default)' : ''}`);
+    }
+    /**
+     * Get a cache instance by name
+     */
+    get(name) {
+        if (!name) {
+            if (!this.defaultCache) {
+                throw new Error('No default cache configured');
+            }
+            return this.defaultCache;
+        }
+        const cache = this.caches.get(name);
+        if (!cache) {
+            throw new Error(`Cache not found: ${name}`);
+        }
+        return cache;
+    }
+    /**
+     * Get all cache instances
+     */
+    getAll() {
+        return this.caches;
+    }
+    /**
+     * Clear all caches
+     */
+    async clearAll() {
+        await Promise.all(Array.from(this.caches.values()).map((cache) => cache.clear()));
+        core_2.default.info('All caches cleared');
+    }
+    /**
+     * Get statistics for all caches
+     */
+    async getAllStats() {
+        const stats = new Map();
+        for (const [name, cache] of this.caches.entries()) {
+            stats.set(name, await cache.getStats());
+        }
+        return stats;
+    }
+    /**
+     * Invalidate tags across all caches
+     */
+    async invalidateTagsGlobal(tags) {
+        await Promise.all(Array.from(this.caches.values()).map((cache) => cache.invalidateTags(tags)));
+        core_2.default.info(`Invalidated tags globally: ${tags.join(', ')}`);
+    }
+}
+exports.CacheManager = CacheManager;

package/dist/cache.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cache.test.d.ts.map

package/dist/cache.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.test.d.ts","sourceRoot":"","sources":["../src/cache.test.ts"],"names":[],"mappings":""}