@hazeljs/cache 0.2.0-beta.1

package/dist/src/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.Injectable)(),
+    __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/src/cache.types.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Cache strategy types
+ */
+export type CacheStrategy = 'memory' | 'redis' | 'multi-tier';
+/**
+ * TTL strategy types
+ */
+export type TTLStrategy = 'absolute' | 'sliding';
+/**
+ * Cache options
+ */
+export interface CacheOptions {
+    /**
+     * Cache strategy to use
+     * @default 'memory'
+     */
+    strategy?: CacheStrategy;
+    /**
+     * Time to live in seconds
+     * @default 3600
+     */
+    ttl?: number;
+    /**
+     * TTL strategy
+     * @default 'absolute'
+     */
+    ttlStrategy?: TTLStrategy;
+    /**
+     * Cache key pattern (supports placeholders like {id}, {userId})
+     */
+    key?: string;
+    /**
+     * Tags for group invalidation
+     */
+    tags?: string[];
+    /**
+     * Events that should invalidate this cache
+     */
+    invalidateOn?: string[];
+    /**
+     * Whether to cache null/undefined values
+     * @default false
+     */
+    cacheNull?: boolean;
+    /**
+     * Custom condition function to determine if value should be cached
+     */
+    condition?: (value: unknown) => boolean;
+}
+/**
+ * Cache entry metadata
+ */
+export interface CacheEntry<T = unknown> {
+    /**
+     * Cached value
+     */
+    value: T;
+    /**
+     * Timestamp when cached
+     */
+    cachedAt: number;
+    /**
+     * Expiration timestamp
+     */
+    expiresAt: number;
+    /**
+     * Last accessed timestamp (for sliding TTL)
+     */
+    lastAccessedAt?: number;
+    /**
+     * Cache tags
+     */
+    tags?: string[];
+    /**
+     * Cache key
+     */
+    key: string;
+}
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+    /**
+     * Total number of cache hits
+     */
+    hits: number;
+    /**
+     * Total number of cache misses
+     */
+    misses: number;
+    /**
+     * Hit rate percentage
+     */
+    hitRate: number;
+    /**
+     * Total number of cached entries
+     */
+    size: number;
+    /**
+     * Total memory used (in bytes, if applicable)
+     */
+    memoryUsage?: number;
+}
+/**
+ * Cache store interface
+ */
+export interface ICacheStore {
+    /**
+     * 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>;
+    /**
+     * Delete a value from cache
+     */
+    delete(key: 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>;
+}
+/**
+ * Cache warming options
+ */
+export interface CacheWarmingOptions {
+    /**
+     * Keys to warm up
+     */
+    keys: string[];
+    /**
+     * Function to fetch data for warming
+     */
+    fetcher: (key: string) => Promise<unknown>;
+    /**
+     * TTL for warmed entries
+     */
+    ttl?: number;
+    /**
+     * Whether to warm in parallel
+     * @default true
+     */
+    parallel?: boolean;
+}
+/**
+ * Cache invalidation event
+ */
+export interface CacheInvalidationEvent {
+    /**
+     * Event name
+     */
+    event: string;
+    /**
+     * Keys to invalidate
+     */
+    keys?: string[];
+    /**
+     * Tags to invalidate
+     */
+    tags?: string[];
+    /**
+     * Timestamp
+     */
+    timestamp: number;
+}
+//# sourceMappingURL=cache.types.d.ts.map

package/dist/src/cache.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.types.d.ts","sourceRoot":"","sources":["../../src/cache.types.ts"],"names":[],"mappings":"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"}

package/dist/src/cache.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/decorators/cache.decorator.d.ts

@@ -0,0 +1,93 @@
+import 'reflect-metadata';
+import { CacheOptions } from '../cache.types';
+/**
+ * Cache decorator for methods
+ *
+ * @example
+ * ```typescript
+ * @Cache({
+ *   strategy: 'memory',
+ *   ttl: 3600,
+ *   key: 'user-{id}',
+ *   tags: ['users']
+ * })
+ * @Get('/users/:id')
+ * async getUser(@Param('id') id: string) {
+ *   return this.userService.findById(id);
+ * }
+ * ```
+ */
+export declare function Cache(options?: CacheOptions): MethodDecorator;
+/**
+ * Get cache metadata from a method
+ */
+export declare function getCacheMetadata(target: object, propertyKey: string | symbol): CacheOptions | undefined;
+/**
+ * Check if a method has cache metadata
+ */
+export declare function hasCacheMetadata(target: object, propertyKey: string | symbol): boolean;
+/**
+ * CacheKey decorator to specify custom cache key generation
+ *
+ * @example
+ * ```typescript
+ * @CacheKey('user-{id}-{role}')
+ * @Get('/users/:id')
+ * async getUser(@Param('id') id: string, @Query('role') role: string) {
+ *   return this.userService.findById(id);
+ * }
+ * ```
+ */
+export declare function CacheKey(keyPattern: string): MethodDecorator;
+/**
+ * CacheTTL decorator to specify cache TTL
+ *
+ * @example
+ * ```typescript
+ * @CacheTTL(7200) // 2 hours
+ * @Get('/users')
+ * async getUsers() {
+ *   return this.userService.findAll();
+ * }
+ * ```
+ */
+export declare function CacheTTL(ttl: number): MethodDecorator;
+/**
+ * CacheTags decorator to specify cache tags
+ *
+ * @example
+ * ```typescript
+ * @CacheTags(['users', 'profiles'])
+ * @Get('/users/:id/profile')
+ * async getUserProfile(@Param('id') id: string) {
+ *   return this.userService.getProfile(id);
+ * }
+ * ```
+ */
+export declare function CacheTags(tags: string[]): MethodDecorator;
+/**
+ * CacheEvict decorator to evict cache entries
+ *
+ * @example
+ * ```typescript
+ * @CacheEvict({ tags: ['users'] })
+ * @Post('/users')
+ * async createUser(@Body() user: CreateUserDto) {
+ *   return this.userService.create(user);
+ * }
+ * ```
+ */
+export declare function CacheEvict(options: {
+    keys?: string[];
+    tags?: string[];
+    all?: boolean;
+}): MethodDecorator;
+/**
+ * Get cache evict metadata
+ */
+export declare function getCacheEvictMetadata(target: object, propertyKey: string | symbol): {
+    keys?: string[];
+    tags?: string[];
+    all?: boolean;
+} | undefined;
+//# sourceMappingURL=cache.decorator.d.ts.map

package/dist/src/decorators/cache.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.decorator.d.ts","sourceRoot":"","sources":["../../../src/decorators/cache.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAK9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,eAAe,CAoBjE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B,YAAY,GAAG,SAAS,CAE1B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAEtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAY5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAYrD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,CAYzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE;IAClC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf,GAAG,eAAe,CAMlB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B;IAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAEjE"}

package/dist/src/decorators/cache.decorator.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = Cache;
+exports.getCacheMetadata = getCacheMetadata;
+exports.hasCacheMetadata = hasCacheMetadata;
+exports.CacheKey = CacheKey;
+exports.CacheTTL = CacheTTL;
+exports.CacheTags = CacheTags;
+exports.CacheEvict = CacheEvict;
+exports.getCacheEvictMetadata = getCacheEvictMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const CACHE_METADATA_KEY = 'hazel:cache';
+/**
+ * Cache decorator for methods
+ *
+ * @example
+ * ```typescript
+ * @Cache({
+ *   strategy: 'memory',
+ *   ttl: 3600,
+ *   key: 'user-{id}',
+ *   tags: ['users']
+ * })
+ * @Get('/users/:id')
+ * async getUser(@Param('id') id: string) {
+ *   return this.userService.findById(id);
+ * }
+ * ```
+ */
+function Cache(options = {}) {
+    return (target, propertyKey, descriptor) => {
+        const defaults = {
+            strategy: 'memory',
+            ttl: 3600,
+            ttlStrategy: 'absolute',
+            cacheNull: false,
+            ...options,
+        };
+        // Store metadata
+        Reflect.defineMetadata(CACHE_METADATA_KEY, defaults, target, propertyKey);
+        core_1.default.debug(`Cache decorator applied to ${target.constructor.name}.${String(propertyKey)}`);
+        // Note: The actual caching logic will be implemented by the CacheInterceptor
+        // This decorator just marks the method and stores configuration
+        return descriptor;
+    };
+}
+/**
+ * Get cache metadata from a method
+ */
+function getCacheMetadata(target, propertyKey) {
+    return Reflect.getMetadata(CACHE_METADATA_KEY, target, propertyKey);
+}
+/**
+ * Check if a method has cache metadata
+ */
+function hasCacheMetadata(target, propertyKey) {
+    return Reflect.hasMetadata(CACHE_METADATA_KEY, target, propertyKey);
+}
+/**
+ * CacheKey decorator to specify custom cache key generation
+ *
+ * @example
+ * ```typescript
+ * @CacheKey('user-{id}-{role}')
+ * @Get('/users/:id')
+ * async getUser(@Param('id') id: string, @Query('role') role: string) {
+ *   return this.userService.findById(id);
+ * }
+ * ```
+ */
+function CacheKey(keyPattern) {
+    return (target, propertyKey, descriptor) => {
+        const existingMetadata = getCacheMetadata(target, propertyKey) || {};
+        const updatedMetadata = {
+            ...existingMetadata,
+            key: keyPattern,
+        };
+        Reflect.defineMetadata(CACHE_METADATA_KEY, updatedMetadata, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * CacheTTL decorator to specify cache TTL
+ *
+ * @example
+ * ```typescript
+ * @CacheTTL(7200) // 2 hours
+ * @Get('/users')
+ * async getUsers() {
+ *   return this.userService.findAll();
+ * }
+ * ```
+ */
+function CacheTTL(ttl) {
+    return (target, propertyKey, descriptor) => {
+        const existingMetadata = getCacheMetadata(target, propertyKey) || {};
+        const updatedMetadata = {
+            ...existingMetadata,
+            ttl,
+        };
+        Reflect.defineMetadata(CACHE_METADATA_KEY, updatedMetadata, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * CacheTags decorator to specify cache tags
+ *
+ * @example
+ * ```typescript
+ * @CacheTags(['users', 'profiles'])
+ * @Get('/users/:id/profile')
+ * async getUserProfile(@Param('id') id: string) {
+ *   return this.userService.getProfile(id);
+ * }
+ * ```
+ */
+function CacheTags(tags) {
+    return (target, propertyKey, descriptor) => {
+        const existingMetadata = getCacheMetadata(target, propertyKey) || {};
+        const updatedMetadata = {
+            ...existingMetadata,
+            tags,
+        };
+        Reflect.defineMetadata(CACHE_METADATA_KEY, updatedMetadata, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * CacheEvict decorator to evict cache entries
+ *
+ * @example
+ * ```typescript
+ * @CacheEvict({ tags: ['users'] })
+ * @Post('/users')
+ * async createUser(@Body() user: CreateUserDto) {
+ *   return this.userService.create(user);
+ * }
+ * ```
+ */
+function CacheEvict(options) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata('hazel:cache:evict', options, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * Get cache evict metadata
+ */
+function getCacheEvictMetadata(target, propertyKey) {
+    return Reflect.getMetadata('hazel:cache:evict', target, propertyKey);
+}