@hazeljs/cache 0.2.0-beta.1

package/dist/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);
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @hazeljs/cache - Caching module for HazelJS
+ */
+export { CacheModule, type CacheModuleOptions } from './cache.module';
+export { CacheService, CacheManager } from './cache.service';
+export { Cache, CacheKey, CacheTTL, CacheTags, CacheEvict, getCacheMetadata, hasCacheMetadata, getCacheEvictMetadata, } from './decorators/cache.decorator';
+export { type CacheOptions, type CacheStrategy, type TTLStrategy, type CacheEntry, type CacheStats, type ICacheStore, type CacheWarmingOptions, type CacheInvalidationEvent, } from './cache.types';
+export { MemoryCacheStore } from './strategies/memory.strategy';
+export { RedisCacheStore } from './strategies/redis.strategy';
+export { MultiTierCacheStore } from './strategies/multi-tier.strategy';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EACL,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,GAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @hazeljs/cache - Caching module for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiTierCacheStore = exports.RedisCacheStore = exports.MemoryCacheStore = exports.getCacheEvictMetadata = exports.hasCacheMetadata = exports.getCacheMetadata = exports.CacheEvict = exports.CacheTags = exports.CacheTTL = exports.CacheKey = exports.Cache = exports.CacheManager = exports.CacheService = exports.CacheModule = void 0;
+var cache_module_1 = require("./cache.module");
+Object.defineProperty(exports, "CacheModule", { enumerable: true, get: function () { return cache_module_1.CacheModule; } });
+var cache_service_1 = require("./cache.service");
+Object.defineProperty(exports, "CacheService", { enumerable: true, get: function () { return cache_service_1.CacheService; } });
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return cache_service_1.CacheManager; } });
+var cache_decorator_1 = require("./decorators/cache.decorator");
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_decorator_1.Cache; } });
+Object.defineProperty(exports, "CacheKey", { enumerable: true, get: function () { return cache_decorator_1.CacheKey; } });
+Object.defineProperty(exports, "CacheTTL", { enumerable: true, get: function () { return cache_decorator_1.CacheTTL; } });
+Object.defineProperty(exports, "CacheTags", { enumerable: true, get: function () { return cache_decorator_1.CacheTags; } });
+Object.defineProperty(exports, "CacheEvict", { enumerable: true, get: function () { return cache_decorator_1.CacheEvict; } });
+Object.defineProperty(exports, "getCacheMetadata", { enumerable: true, get: function () { return cache_decorator_1.getCacheMetadata; } });
+Object.defineProperty(exports, "hasCacheMetadata", { enumerable: true, get: function () { return cache_decorator_1.hasCacheMetadata; } });
+Object.defineProperty(exports, "getCacheEvictMetadata", { enumerable: true, get: function () { return cache_decorator_1.getCacheEvictMetadata; } });
+var memory_strategy_1 = require("./strategies/memory.strategy");
+Object.defineProperty(exports, "MemoryCacheStore", { enumerable: true, get: function () { return memory_strategy_1.MemoryCacheStore; } });
+var redis_strategy_1 = require("./strategies/redis.strategy");
+Object.defineProperty(exports, "RedisCacheStore", { enumerable: true, get: function () { return redis_strategy_1.RedisCacheStore; } });
+var multi_tier_strategy_1 = require("./strategies/multi-tier.strategy");
+Object.defineProperty(exports, "MultiTierCacheStore", { enumerable: true, get: function () { return multi_tier_strategy_1.MultiTierCacheStore; } });

package/dist/src/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/src/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/src/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/src/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/src/cache.service.d.ts.map

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