@akanjs/nest 0.0.19 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/nest",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"

package/src/interceptors.d.ts

@@ -3,12 +3,10 @@ import { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
 import type { RedisClientType } from "redis";
 import { Observable } from "rxjs";
 export declare class CacheInterceptor implements NestInterceptor {
-    private redis;
-    logger: Logger;
-    constructor(redis: RedisClientType);
-    setCache(key: string, value: any, expire: number): Promise<void>;
-    getCache<T = object>(key: string): Promise<T | null>;
-    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    #private;
+    private readonly redis;
+    constructor(redis: RedisClientType<any, any, any>);
+    intercept<T>(context: ExecutionContext, next: CallHandler): Promise<Observable<T>>;
 }
 export declare class TimeoutInterceptor implements NestInterceptor {
     intercept(context: ExecutionContext, next: CallHandler): Observable<any>;

package/src/interceptors.js

@@ -6,11 +6,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from2, except, desc) => {
-  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
@@ -25,6 +25,23 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 var interceptors_exports = {};
 __export(interceptors_exports, {
   CacheInterceptor: () => CacheInterceptor,
@@ -39,45 +56,84 @@ var import_graphql = require("@nestjs/graphql");
 var import_rxjs = require("rxjs");
 var import_operators = require("rxjs/operators");
 var import_authGuards = require("./authGuards");
+var _logger, _CACHE_PREFIX, _generateCacheKey, generateCacheKey_fn, _getCache, getCache_fn, _setCache, setCache_fn;
 let CacheInterceptor = class {
   constructor(redis) {
     this.redis = redis;
+    __privateAdd(this, _generateCacheKey);
+    __privateAdd(this, _getCache);
+    __privateAdd(this, _setCache);
+    __privateAdd(this, _logger, new import_common.Logger("CacheInterceptor"));
+    __privateAdd(this, _CACHE_PREFIX, "signal:");
   }
-  logger = new import_common.Logger("CacheInterceptor");
-  async setCache(key, value, expire) {
-    await this.redis.set(key, JSON.stringify(value), { PX: expire });
-  }
-  async getCache(key) {
-    const cached = await this.redis.get(key);
-    return cached ? JSON.parse(cached) : null;
-  }
-  intercept(context, next) {
-    const signalKey = context.getHandler().name;
+  async intercept(context, next) {
+    const handler = context.getHandler();
+    const signalKey = handler.name;
     const gqlMeta = (0, import_signal.getGqlMeta)(context.getClass(), signalKey);
-    const cacheExpireMs = gqlMeta.signalOption.cache;
-    if (gqlMeta.type !== "Query" || !cacheExpireMs) {
-      if (cacheExpireMs)
-        this.logger.warn(`CacheInterceptor: ${signalKey} is not Query endpoint or cache is not set`);
+    if (gqlMeta.type !== "Query" || !gqlMeta.signalOption.cache) {
+      if (gqlMeta.signalOption.cache) {
+        __privateGet(this, _logger).warn(`CacheInterceptor: ${signalKey} is not Query endpoint or cache is not set`);
+      }
       return next.handle();
     }
     const args = (0, import_authGuards.getArgs)(context);
-    const cacheKey = `signal:${signalKey}:${JSON.stringify(args)}`;
-    const cacheResult$ = (0, import_rxjs.from)(this.getCache(cacheKey));
-    return (0, import_rxjs.forkJoin)([cacheResult$]).pipe(
-      (0, import_rxjs.switchMap)(([cacheResult]) => {
-        if (cacheResult) {
-          this.logger.trace(`CacheHit-${cacheKey}`);
-          return (0, import_rxjs.of)(cacheResult);
-        } else
-          return next.handle().pipe(
-            (0, import_rxjs.map)((resData) => {
-              void this.setCache(cacheKey, resData, cacheExpireMs);
-              this.logger.trace(`CacheSet-${cacheKey}`);
-              return resData;
-            })
-          );
-      })
-    );
+    const cacheKey = __privateMethod(this, _generateCacheKey, generateCacheKey_fn).call(this, signalKey, args);
+    try {
+      const cachedData = await __privateMethod(this, _getCache, getCache_fn).call(this, cacheKey);
+      if (cachedData) {
+        __privateGet(this, _logger).debug(`Cache hit for key: ${cacheKey}`);
+        return (0, import_rxjs.of)(cachedData);
+      }
+      return next.handle().pipe(
+        (0, import_rxjs.map)((data) => {
+          const cacheDuration = gqlMeta.signalOption.cache;
+          if (typeof cacheDuration === "number") {
+            void __privateMethod(this, _setCache, setCache_fn).call(this, cacheKey, data, cacheDuration);
+            __privateGet(this, _logger).debug(`Cache set for key: ${cacheKey}`);
+          }
+          return data;
+        }),
+        (0, import_operators.catchError)((error) => {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          __privateGet(this, _logger).error(`Error in cache interceptor for ${cacheKey}: ${errorMessage}`);
+          return (0, import_rxjs.throwError)(() => error);
+        })
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      __privateGet(this, _logger).error(`Cache error for ${cacheKey}: ${errorMessage}`);
+      return next.handle();
+    }
+  }
+};
+_logger = new WeakMap();
+_CACHE_PREFIX = new WeakMap();
+_generateCacheKey = new WeakSet();
+generateCacheKey_fn = function(signalKey, args) {
+  return `${__privateGet(this, _CACHE_PREFIX)}${signalKey}:${JSON.stringify(args)}`;
+};
+_getCache = new WeakSet();
+getCache_fn = async function(key) {
+  try {
+    const cached = await this.redis.get(key);
+    if (!cached)
+      return null;
+    const { data } = JSON.parse(cached);
+    return data;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    __privateGet(this, _logger).error(`Error retrieving cache for key ${key}: ${errorMessage}`);
+    return null;
+  }
+};
+_setCache = new WeakSet();
+setCache_fn = async function(key, data, ttlMs) {
+  try {
+    const cacheData = { data, timestamp: Date.now() };
+    await this.redis.set(key, JSON.stringify(cacheData), { PX: ttlMs });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    __privateGet(this, _logger).error(`Error setting cache for key ${key}: ${errorMessage}`);
   }
 };
 CacheInterceptor = __decorateClass([