@nestjs-redisx/cache 1.0.1 → 1.0.2

package/dist/index.mjs

@@ -114,20 +114,19 @@ function Cached(options = {}) {
         return originalMethod.apply(this, args);
       }
       const key = buildCacheKey(this, propertyKey.toString(), args, options);
+      const tags = typeof options.tags === "function" ? options.tags(...args) : options.tags;
       try {
-        const cached = await cacheService.get(key);
-        if (cached !== null) {
-          return cached;
-        }
+        return await cacheService.getOrSet(key, () => originalMethod.apply(this, args), {
+          ttl: options.ttl,
+          tags,
+          strategy: options.strategy,
+          swr: options.swr,
+          unless: options.unless ? (result) => options.unless(result, ...args) : void 0
+        });
       } catch (error) {
-        logger.error(`@Cached: Cache get error for key ${key}:`, error);
-      }
-      const result = await originalMethod.apply(this, args);
-      if (options.unless?.(result, ...args)) {
-        return result;
+        logger.error(`@Cached: getOrSet error for key ${key}:`, error);
+        return originalMethod.apply(this, args);
       }
-      await cacheResult(cacheService, key, result, options, args);
-      return result;
     };
     Object.defineProperty(descriptor.value, "name", {
       value: originalMethod.name,
@@ -159,6 +158,10 @@ function enrichWithContext(key, options) {
   for (const ctxKey of contextKeys) {
     const value = pluginOpts.contextProvider.get(ctxKey);
     if (value !== void 0 && value !== null) {
+      if (typeof value === "object") {
+        logger.warn(`Context key "${ctxKey}" has object value, skipping (use primitives for context keys)`);
+        continue;
+      }
       contextMap.set(ctxKey, String(value));
     }
   }
@@ -167,6 +170,10 @@ function enrichWithContext(key, options) {
       if (!contextMap.has(name)) {
         const value = pluginOpts.contextProvider.get(name);
         if (value !== void 0 && value !== null) {
+          if (typeof value === "object") {
+            logger.warn(`varyBy key "${name}" has object value, skipping (use primitives for varyBy keys)`);
+            continue;
+          }
           contextMap.set(name, String(value));
         }
       }
@@ -181,7 +188,7 @@ function sanitizeForKey(value) {
   return String(value).replace(/[^a-zA-Z0-9\-_]/g, "_");
 }
 function interpolateKey(template, args) {
-  return template.replace(/\{(\d+)\}/g, (match, index) => {
+  return template.replace(/\{(\d+)}/g, (match, index) => {
     const argIndex = parseInt(index, 10);
     if (argIndex < args.length) {
       return serializeArg(args[argIndex]);
@@ -198,38 +205,43 @@ function serializeArg(arg) {
   }
   if (typeof arg === "object") {
     try {
-      return JSON.stringify(arg);
+      return stableStringify(arg);
     } catch {
       return "object";
     }
   }
   return "unknown";
 }
-async function cacheResult(cacheService, key, value, options, args) {
-  try {
-    const tags = typeof options.tags === "function" ? options.tags(...args) : options.tags;
-    if (options.swr?.enabled) {
-      await cacheService.getOrSet(
-        key,
-        // eslint-disable-next-line @typescript-eslint/require-await
-        async () => value,
-        {
-          ttl: options.ttl,
-          tags,
-          strategy: options.strategy,
-          swr: options.swr
-        }
-      );
-    } else {
-      await cacheService.set(key, value, {
-        ttl: options.ttl,
-        tags,
-        strategy: options.strategy
-      });
+function stableStringify(value) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (typeof value === "function" || typeof value === "symbol") {
+    return "null";
+  }
+  if (typeof value !== "object") {
+    if (typeof value === "bigint") {
+      return String(value);
     }
-  } catch (error) {
-    logger.error(`@Cached: Failed to cache result for key ${key}:`, error);
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map((item) => item === void 0 || typeof item === "function" || typeof item === "symbol" ? "null" : stableStringify(item)).join(",") + "]";
   }
+  if (value instanceof Date) {
+    return JSON.stringify(value);
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const parts = [];
+  for (const key of keys) {
+    const v = obj[key];
+    if (v === void 0 || typeof v === "function" || typeof v === "symbol") {
+      continue;
+    }
+    parts.push(JSON.stringify(key) + ":" + stableStringify(v));
+  }
+  return "{" + parts.join(",") + "}";
 }
 
 // src/invalidation/infrastructure/decorators/invalidate-on.decorator.ts
@@ -871,7 +883,7 @@ var CacheService = class {
   async getOrSet(key, loader, options = {}) {
     const normalizedKey = this.validateAndNormalizeKey(key);
     const enrichedKey = this.enrichKeyWithContext(normalizedKey, options.varyBy);
-    const swrEnabled = this.swrEnabled && (options.swr?.enabled ?? true);
+    const swrEnabled = options.swr?.enabled ?? this.swrEnabled;
     if (swrEnabled) {
       const swrEntry = await this.l2Store.getSwr(enrichedKey);
       if (swrEntry) {
@@ -883,11 +895,14 @@ var CacheService = class {
               enrichedKey,
               loader,
               async (freshValue) => {
-                await this.set(enrichedKey, freshValue, {
-                  ttl: options.ttl,
-                  tags: options.tags,
-                  strategy: options.strategy
-                });
+                const staleTime = options.swr?.staleTime ?? this.options.swr?.defaultStaleTime ?? 60;
+                const ttl = options.ttl ?? this.options.l2?.defaultTtl ?? 3600;
+                const swrEntryNew = this.swrManager.createSwrEntry(freshValue, ttl, staleTime);
+                await this.l2Store.setSwr(enrichedKey, swrEntryNew);
+                if (this.l1Enabled) {
+                  const entry = CacheEntry.create(freshValue, ttl);
+                  await this.l1Store.set(enrichedKey, entry, this.options.l1?.ttl);
+                }
               },
               (error) => {
                 this.logger.error(`SWR revalidation failed for key ${enrichedKey}:`, error);
@@ -898,10 +913,12 @@ var CacheService = class {
         }
       }
       const value = await this.loadWithStampede(enrichedKey, loader, options);
-      const staleTime = options.swr?.staleTime ?? this.options.swr?.defaultStaleTime ?? 60;
-      const ttl = options.ttl ?? this.options.l2?.defaultTtl ?? 3600;
-      const swrEntryNew = this.swrManager.createSwrEntry(value, ttl, staleTime);
-      await this.l2Store.setSwr(enrichedKey, swrEntryNew);
+      if (!options.unless?.(value)) {
+        const staleTime = options.swr?.staleTime ?? this.options.swr?.defaultStaleTime ?? 60;
+        const ttl = options.ttl ?? this.options.l2?.defaultTtl ?? 3600;
+        const swrEntryNew = this.swrManager.createSwrEntry(value, ttl, staleTime);
+        await this.l2Store.setSwr(enrichedKey, swrEntryNew);
+      }
       return value;
     }
     const cached = await this.get(enrichedKey);
@@ -926,19 +943,23 @@ var CacheService = class {
         this.metrics?.incrementCounter("redisx_cache_stampede_prevented_total");
         return result.value;
       }
-      await this.set(key, result.value, {
+      if (!options.unless?.(result.value)) {
+        await this.set(key, result.value, {
+          ttl: options.ttl,
+          tags: options.tags,
+          strategy: options.strategy
+        });
+      }
+      return result.value;
+    }
+    const value = await loader();
+    if (!options.unless?.(value)) {
+      await this.set(key, value, {
         ttl: options.ttl,
         tags: options.tags,
         strategy: options.strategy
       });
-      return result.value;
     }
-    const value = await loader();
-    await this.set(key, value, {
-      ttl: options.ttl,
-      tags: options.tags,
-      strategy: options.strategy
-    });
     return value;
   }
   async delete(key) {
@@ -981,11 +1002,12 @@ var CacheService = class {
       if (normalizedKeys.length === 0) {
         return 0;
       }
-      let deletedCount = 0;
+      const deleted = new Array(normalizedKeys.length).fill(false);
       if (this.l1Enabled) {
-        for (const key of normalizedKeys) {
-          const deleted = await this.l1Store.delete(key);
-          if (deleted) deletedCount++;
+        for (let i = 0; i < normalizedKeys.length; i++) {
+          if (await this.l1Store.delete(normalizedKeys[i])) {
+            deleted[i] = true;
+          }
         }
       }
       if (this.l2Enabled && normalizedKeys.length > 0) {
@@ -995,17 +1017,16 @@ var CacheService = class {
           pipeline.del(fullKey);
         }
         const results = await pipeline.exec();
-        let l2Count = 0;
         if (results) {
-          for (const [error, result] of results) {
+          for (let i = 0; i < results.length; i++) {
+            const [error, result] = results[i];
             if (!error && typeof result === "number" && result > 0) {
-              l2Count++;
+              deleted[i] = true;
             }
           }
         }
-        deletedCount = Math.max(deletedCount, l2Count);
       }
-      return deletedCount;
+      return deleted.filter(Boolean).length;
     } catch (error) {
       throw new CacheError(`Failed to delete multiple keys: ${error.message}`, ErrorCode.CACHE_DELETE_FAILED, error);
     }
@@ -1142,10 +1163,10 @@ var CacheService = class {
       const maxTtl = this.options.l2?.maxTtl ?? 86400;
       const defaultTtl = this.options.l2?.defaultTtl ?? 3600;
       const cacheEntries = entries.map(({ key, value, ttl }) => {
-        const entryTtl = ttl ?? defaultTtl;
+        const entryTtl = Math.min(ttl ?? defaultTtl, maxTtl);
         return {
           key: this.enrichKeyWithContext(this.validateAndNormalizeKey(key)),
-          entry: CacheEntry.create(value, Math.min(entryTtl, maxTtl)),
+          entry: CacheEntry.create(value, entryTtl),
           ttl: entryTtl
         };
       });
@@ -1270,6 +1291,10 @@ var CacheService = class {
       for (const ctxKey of contextKeys) {
         const value = contextProvider.get(ctxKey);
         if (value !== void 0 && value !== null) {
+          if (typeof value === "object") {
+            this.logger.warn(`Context key "${ctxKey}" has object value, skipping (use primitives for context keys)`);
+            continue;
+          }
           contextMap.set(ctxKey, String(value));
         }
       }
@@ -1507,12 +1532,6 @@ var L1MemoryStoreAdapter = class {
   }
   // eslint-disable-next-line @typescript-eslint/require-await
   async size() {
-    const now = Date.now();
-    for (const [key, node] of this.cache.entries()) {
-      if (now > node.expiresAt) {
-        void this.delete(key);
-      }
-    }
     return this.cache.size;
   }
   moveToFront(node) {
@@ -2710,9 +2729,6 @@ var SwrManagerService = class {
   async delete(_key) {
   }
   isStale(entry) {
-    if (!this.enabled) {
-      return false;
-    }
     const now = Date.now();
     return now > entry.staleAt;
   }
@@ -3045,33 +3061,63 @@ LuaScriptLoader = __decorateClass([
 ], LuaScriptLoader);
 
 // src/cache.plugin.ts
-var CachePlugin = class {
+var CachePlugin = class _CachePlugin {
   constructor(options = {}) {
     this.options = options;
   }
   name = "cache";
   version = "0.1.0";
   description = "Advanced caching with L1+L2, anti-stampede, SWR, and tag invalidation";
+  asyncOptions;
+  /**
+   * Create a CachePlugin with async configuration from DI.
+   *
+   * @example
+   * ```typescript
+   * CachePlugin.registerAsync({
+   *   imports: [ConfigModule],
+   *   inject: [ConfigService],
+   *   useFactory: (config: ConfigService) => ({
+   *     l1: { maxSize: config.get('CACHE_L1_MAX_SIZE', 1000) },
+   *     swr: { enabled: config.get('CACHE_SWR_ENABLED', false) },
+   *   }),
+   * })
+   * ```
+   */
+  static registerAsync(asyncOptions) {
+    const plugin = new _CachePlugin();
+    plugin.asyncOptions = asyncOptions;
+    return plugin;
+  }
+  static mergeDefaults(options) {
+    return {
+      l1: { ...DEFAULT_CACHE_CONFIG.l1, ...options.l1 },
+      l2: { ...DEFAULT_CACHE_CONFIG.l2, ...options.l2 },
+      stampede: { ...DEFAULT_CACHE_CONFIG.stampede, ...options.stampede },
+      swr: { ...DEFAULT_CACHE_CONFIG.swr, ...options.swr },
+      tags: { ...DEFAULT_CACHE_CONFIG.tags, ...options.tags },
+      warmup: { ...DEFAULT_CACHE_CONFIG.warmup, ...options.warmup },
+      keys: { ...DEFAULT_CACHE_CONFIG.keys, ...options.keys },
+      invalidation: { ...DEFAULT_CACHE_CONFIG.invalidation, ...options.invalidation }
+    };
+  }
+  getImports() {
+    return this.asyncOptions?.imports ?? [];
+  }
   getProviders() {
-    const config = {
-      l1: { ...DEFAULT_CACHE_CONFIG.l1, ...this.options.l1 },
-      l2: { ...DEFAULT_CACHE_CONFIG.l2, ...this.options.l2 },
-      stampede: { ...DEFAULT_CACHE_CONFIG.stampede, ...this.options.stampede },
-      swr: { ...DEFAULT_CACHE_CONFIG.swr, ...this.options.swr },
-      tags: { ...DEFAULT_CACHE_CONFIG.tags, ...this.options.tags },
-      warmup: { ...DEFAULT_CACHE_CONFIG.warmup, ...this.options.warmup },
-      keys: { ...DEFAULT_CACHE_CONFIG.keys, ...this.options.keys },
-      invalidation: {
-        ...DEFAULT_CACHE_CONFIG.invalidation,
-        ...this.options.invalidation
-      }
+    const optionsProvider = this.asyncOptions ? {
+      provide: CACHE_PLUGIN_OPTIONS,
+      useFactory: async (...args) => {
+        const userOptions = await this.asyncOptions.useFactory(...args);
+        return _CachePlugin.mergeDefaults(userOptions);
+      },
+      inject: this.asyncOptions.inject || []
+    } : {
+      provide: CACHE_PLUGIN_OPTIONS,
+      useValue: _CachePlugin.mergeDefaults(this.options)
     };
     return [
-      // Configuration
-      {
-        provide: CACHE_PLUGIN_OPTIONS,
-        useValue: config
-      },
+      optionsProvider,
       // Domain services
       {
         provide: SERIALIZER,
@@ -3129,9 +3175,9 @@ var CachePlugin = class {
       // Factory for registering static invalidation rules
       {
         provide: INVALIDATION_RULES_INIT,
-        useFactory: (registry, config2) => {
-          if (config2.invalidation?.rules && config2.invalidation.rules.length > 0) {
-            const rules = config2.invalidation.rules.map((ruleProps) => InvalidationRule.create(ruleProps));
+        useFactory: (registry, config) => {
+          if (config.invalidation?.rules && config.invalidation.rules.length > 0) {
+            const rules = config.invalidation.rules.map((ruleProps) => InvalidationRule.create(ruleProps));
             registry.registerMany(rules);
           }
           return true;