@hazeljs/cache 0.2.0-alpha.1

package/dist/cache.test.js

@@ -0,0 +1,374 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 cache_service_1 = require("./cache.service");
+const cache_decorator_1 = require("./decorators/cache.decorator");
+describe('MemoryCacheStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_strategy_1.MemoryCacheStore(100); // Short cleanup interval for testing
+    });
+    afterEach(() => {
+        store.destroy();
+    });
+    describe('get and set', () => {
+        it('should set and get a value', async () => {
+            await store.set('key1', 'value1', 60);
+            const value = await store.get('key1');
+            expect(value).toBe('value1');
+        });
+        it('should return null for non-existent key', async () => {
+            const value = await store.get('nonexistent');
+            expect(value).toBeNull();
+        });
+        it('should handle complex objects', async () => {
+            const obj = { name: 'test', nested: { value: 123 } };
+            await store.set('obj', obj, 60);
+            const retrieved = await store.get('obj');
+            expect(retrieved).toEqual(obj);
+        });
+    });
+    describe('expiration', () => {
+        it('should expire entries after TTL', async () => {
+            await store.set('expire', 'value', 0.1); // 100ms
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            const value = await store.get('expire');
+            expect(value).toBeNull();
+        });
+        it('should not return expired entries', async () => {
+            await store.set('key', 'value', 0.05); // 50ms
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const exists = await store.has('key');
+            expect(exists).toBe(false);
+        });
+    });
+    describe('tags', () => {
+        it('should set value with tags', async () => {
+            await store.setWithTags('user1', { name: 'John' }, 60, ['users', 'profiles']);
+            const value = await store.get('user1');
+            expect(value).toEqual({ name: 'John' });
+        });
+        it('should delete entries by tag', async () => {
+            await store.setWithTags('user1', { name: 'John' }, 60, ['users']);
+            await store.setWithTags('user2', { name: 'Jane' }, 60, ['users']);
+            await store.setWithTags('post1', { title: 'Post' }, 60, ['posts']);
+            await store.deleteByTag('users');
+            expect(await store.get('user1')).toBeNull();
+            expect(await store.get('user2')).toBeNull();
+            expect(await store.get('post1')).toEqual({ title: 'Post' });
+        });
+    });
+    describe('operations', () => {
+        it('should delete a key', async () => {
+            await store.set('key', 'value', 60);
+            await store.delete('key');
+            const value = await store.get('key');
+            expect(value).toBeNull();
+        });
+        it('should check if key exists', async () => {
+            await store.set('key', 'value', 60);
+            expect(await store.has('key')).toBe(true);
+            expect(await store.has('nonexistent')).toBe(false);
+        });
+        it('should clear all entries', async () => {
+            await store.set('key1', 'value1', 60);
+            await store.set('key2', 'value2', 60);
+            await store.clear();
+            expect(await store.get('key1')).toBeNull();
+            expect(await store.get('key2')).toBeNull();
+        });
+        it('should get keys by pattern', async () => {
+            await store.set('user:1', 'value1', 60);
+            await store.set('user:2', 'value2', 60);
+            await store.set('post:1', 'value3', 60);
+            const userKeys = await store.keys('user:*');
+            expect(userKeys).toHaveLength(2);
+            expect(userKeys).toContain('user:1');
+            expect(userKeys).toContain('user:2');
+        });
+    });
+    describe('statistics', () => {
+        it('should track hits and misses', async () => {
+            await store.set('key', 'value', 60);
+            await store.get('key'); // hit
+            await store.get('nonexistent'); // miss
+            await store.get('key'); // hit
+            const stats = await store.getStats();
+            expect(stats.hits).toBe(2);
+            expect(stats.misses).toBe(1);
+            expect(stats.hitRate).toBeGreaterThan(0);
+        });
+        it('should report cache size', async () => {
+            await store.set('key1', 'value1', 60);
+            await store.set('key2', 'value2', 60);
+            const stats = await store.getStats();
+            expect(stats.size).toBe(2);
+        });
+        it('should reset statistics', async () => {
+            await store.set('key', 'value', 60);
+            await store.get('key');
+            store.resetStats();
+            const stats = await store.getStats();
+            expect(stats.hits).toBe(0);
+            expect(stats.misses).toBe(0);
+        });
+    });
+});
+describe('RedisCacheStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new redis_strategy_1.RedisCacheStore();
+    });
+    afterEach(async () => {
+        await store.disconnect();
+    });
+    it('should set and get a value', async () => {
+        await store.set('key1', 'value1', 60);
+        const value = await store.get('key1');
+        expect(value).toBe('value1');
+    });
+    it('should handle objects', async () => {
+        const obj = { name: 'test', value: 123 };
+        await store.set('obj', obj, 60);
+        const retrieved = await store.get('obj');
+        expect(retrieved).toEqual(obj);
+    });
+    it('should delete by tag', async () => {
+        await store.setWithTags('key1', 'value1', 60, ['tag1']);
+        await store.setWithTags('key2', 'value2', 60, ['tag1']);
+        await store.deleteByTag('tag1');
+        expect(await store.get('key1')).toBeNull();
+        expect(await store.get('key2')).toBeNull();
+    });
+});
+describe('MultiTierCacheStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new multi_tier_strategy_1.MultiTierCacheStore();
+    });
+    afterEach(async () => {
+        await store.destroy();
+    });
+    it('should set and get from multi-tier cache', async () => {
+        await store.set('key', 'value', 60);
+        const value = await store.get('key');
+        expect(value).toBe('value');
+    });
+    it('should promote from L2 to L1', async () => {
+        await store.set('key', 'value', 60);
+        // Clear L1 to simulate L2-only scenario
+        const l1Stats = await store.getL1Stats();
+        // Get should promote to L1
+        await store.get('key');
+        const newL1Stats = await store.getL1Stats();
+        expect(newL1Stats.size).toBeGreaterThanOrEqual(l1Stats.size);
+    });
+    it('should delete from both tiers', async () => {
+        await store.set('key', 'value', 60);
+        await store.delete('key');
+        expect(await store.get('key')).toBeNull();
+    });
+    it('should get combined statistics', async () => {
+        await store.set('key1', 'value1', 60);
+        await store.set('key2', 'value2', 60);
+        await store.get('key1');
+        await store.get('nonexistent');
+        const stats = await store.getStats();
+        expect(stats.hits).toBeGreaterThan(0);
+        expect(stats.misses).toBeGreaterThan(0);
+    });
+});
+describe('CacheService', () => {
+    let service;
+    beforeEach(() => {
+        service = new cache_service_1.CacheService('memory');
+    });
+    describe('basic operations', () => {
+        it('should get and set values', async () => {
+            await service.set('key', 'value', 60);
+            const value = await service.get('key');
+            expect(value).toBe('value');
+        });
+        it('should delete values', async () => {
+            await service.set('key', 'value', 60);
+            await service.delete('key');
+            expect(await service.get('key')).toBeNull();
+        });
+        it('should clear all cache', async () => {
+            await service.set('key1', 'value1', 60);
+            await service.set('key2', 'value2', 60);
+            await service.clear();
+            expect(await service.get('key1')).toBeNull();
+        });
+    });
+    describe('cache-aside pattern', () => {
+        it('should get or set value', async () => {
+            let fetchCount = 0;
+            const fetcher = async () => {
+                fetchCount++;
+                return { data: 'fetched' };
+            };
+            const result1 = await service.getOrSet('key', fetcher, 60);
+            const result2 = await service.getOrSet('key', fetcher, 60);
+            expect(result1).toEqual({ data: 'fetched' });
+            expect(result2).toEqual({ data: 'fetched' });
+            expect(fetchCount).toBe(1); // Should only fetch once
+        });
+    });
+    describe('cache warming', () => {
+        it('should warm up cache', async () => {
+            await service.warmUp({
+                keys: ['key1', 'key2', 'key3'],
+                fetcher: async (key) => ({ key, data: `data-${key}` }),
+                ttl: 60,
+            });
+            expect(await service.get('key1')).toEqual({ key: 'key1', data: 'data-key1' });
+            expect(await service.get('key2')).toEqual({ key: 'key2', data: 'data-key2' });
+            expect(await service.get('key3')).toEqual({ key: 'key3', data: 'data-key3' });
+        });
+    });
+    describe('tags', () => {
+        it('should invalidate by tags', async () => {
+            await service.setWithTags('user1', { name: 'John' }, 60, ['users']);
+            await service.setWithTags('user2', { name: 'Jane' }, 60, ['users']);
+            await service.invalidateTags(['users']);
+            expect(await service.get('user1')).toBeNull();
+            expect(await service.get('user2')).toBeNull();
+        });
+    });
+    describe('statistics', () => {
+        it('should get cache statistics', async () => {
+            await service.set('key', 'value', 60);
+            await service.get('key');
+            const stats = await service.getStats();
+            expect(stats).toBeDefined();
+            expect(stats.hits).toBeGreaterThanOrEqual(0);
+            expect(stats.misses).toBeGreaterThanOrEqual(0);
+        });
+    });
+});
+describe('CacheManager', () => {
+    let manager;
+    beforeEach(() => {
+        manager = new cache_service_1.CacheManager();
+    });
+    it('should register and get cache', () => {
+        const cache = new cache_service_1.CacheService('memory');
+        manager.register('test', cache);
+        expect(manager.get('test')).toBe(cache);
+    });
+    it('should set default cache', () => {
+        const cache = new cache_service_1.CacheService('memory');
+        manager.register('default', cache, true);
+        expect(manager.get()).toBe(cache);
+    });
+    it('should get all caches', () => {
+        const cache1 = new cache_service_1.CacheService('memory');
+        const cache2 = new cache_service_1.CacheService('memory');
+        manager.register('cache1', cache1);
+        manager.register('cache2', cache2);
+        const all = manager.getAll();
+        expect(all.size).toBe(2);
+    });
+    it('should clear all caches', async () => {
+        const cache1 = new cache_service_1.CacheService('memory');
+        const cache2 = new cache_service_1.CacheService('memory');
+        manager.register('cache1', cache1);
+        manager.register('cache2', cache2);
+        await cache1.set('key', 'value', 60);
+        await cache2.set('key', 'value', 60);
+        await manager.clearAll();
+        expect(await cache1.get('key')).toBeNull();
+        expect(await cache2.get('key')).toBeNull();
+    });
+});
+describe('Cache Decorators', () => {
+    describe('@Cache', () => {
+        it('should store cache metadata', () => {
+            class TestClass {
+                testMethod() {
+                    return 'test';
+                }
+            }
+            __decorate([
+                (0, cache_decorator_1.Cache)({ ttl: 120, strategy: 'memory' }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClass.prototype, "testMethod", null);
+            const instance = new TestClass();
+            const metadata = (0, cache_decorator_1.getCacheMetadata)(instance, 'testMethod');
+            expect(metadata).toBeDefined();
+            expect(metadata?.ttl).toBe(120);
+            expect(metadata?.strategy).toBe('memory');
+        });
+    });
+    describe('@CacheKey', () => {
+        it('should set cache key pattern', () => {
+            class TestClass {
+                testMethod() {
+                    return 'test';
+                }
+            }
+            __decorate([
+                (0, cache_decorator_1.CacheKey)('user-{id}'),
+                (0, cache_decorator_1.Cache)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClass.prototype, "testMethod", null);
+            const instance = new TestClass();
+            const metadata = (0, cache_decorator_1.getCacheMetadata)(instance, 'testMethod');
+            expect(metadata?.key).toBe('user-{id}');
+        });
+    });
+    describe('@CacheTTL', () => {
+        it('should set cache TTL', () => {
+            class TestClass {
+                testMethod() {
+                    return 'test';
+                }
+            }
+            __decorate([
+                (0, cache_decorator_1.CacheTTL)(300),
+                (0, cache_decorator_1.Cache)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClass.prototype, "testMethod", null);
+            const instance = new TestClass();
+            const metadata = (0, cache_decorator_1.getCacheMetadata)(instance, 'testMethod');
+            expect(metadata?.ttl).toBe(300);
+        });
+    });
+    describe('@CacheTags', () => {
+        it('should set cache tags', () => {
+            class TestClass {
+                testMethod() {
+                    return 'test';
+                }
+            }
+            __decorate([
+                (0, cache_decorator_1.CacheTags)(['users', 'profiles']),
+                (0, cache_decorator_1.Cache)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClass.prototype, "testMethod", null);
+            const instance = new TestClass();
+            const metadata = (0, cache_decorator_1.getCacheMetadata)(instance, 'testMethod');
+            expect(metadata?.tags).toEqual(['users', 'profiles']);
+        });
+    });
+});

package/dist/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/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/cache.types.js

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

package/dist/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/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"}