@sebspark/promise-cache 3.9.0 → 3.10.0

package/README.md

@@ -20,14 +20,15 @@ yarn install @sebspark/promise-cache
 
 ### **PromiseCache Class**
 
-| Params        | Type                | Default   | Description                                   |
-|---------------|---------------------|-----------|-----------------------------------------------|
-| redis         | RedisClientOptions  | undefined | Redis instance url, skip if use local memory  |
-| ttlInSeconds  | number              | undefined | Persist time in Seconds                       |
-| caseSensituve | boolean             | false     | Retrieving cache with case sensitive          |
-| onSuccess     | function            | undefined | Callback function if connection is success    |
-| onError       | function            | undefined | Callback function if there is an error        |
-| logger        | winston Logger      | undefined | Logger                                        |
+| Params             | Type                | Default   | Description                                      |
+|--------------------|---------------------|-----------|--------------------------------------------------|
+| redis              | RedisClientOptions  | undefined | Redis instance url, skip if use local memory     |
+| ttlInSeconds       | number              | undefined | Persist time in Seconds                          |
+| caseSensituve      | boolean             | false     | Retrieving cache with case sensitive             |
+| fallbackToFunction | boolean             | false     | Executes the wrapped function if persistor fails |
+| onSuccess          | function            | undefined | Callback function if connection is success       |
+| onError            | function            | undefined | Callback function if there is an error           |
+| logger             | winston Logger      | undefined | Logger                                           |
 
 ```typescript
 import { PromiseCache } from '@sebspark/promise-cache'

package/dist/index.d.mts

@@ -23,10 +23,10 @@ type PersistorConstructorType = {
 };
 declare class Persistor {
     client: ReturnType<typeof createClient> | null;
-    private clientId?;
-    private onError;
-    private onSuccess;
-    private logger;
+    private readonly clientId?;
+    private readonly onError;
+    private readonly onSuccess;
+    private readonly logger;
     private readonly redis?;
     constructor({ redis, clientId, onSuccess, onError, logger, }: PersistorConstructorType);
     startConnection(): Promise<void>;
@@ -59,21 +59,24 @@ type PromiseCacheOptions = {
     ttlInSeconds?: number;
     caseSensitive?: boolean;
     redis?: RedisClientOptions;
+    fallbackToFunction?: boolean;
     onError?: (error: string) => void;
     onSuccess?: () => void;
     logger?: Logger;
 };
 declare class PromiseCache<U> {
     persistor: Persistor;
-    private clientId;
+    private readonly clientId;
     private readonly caseSensitive;
+    private readonly fallbackToFunction;
     private readonly ttl?;
+    private readonly logger;
     /**
      * Initialize a new PromiseCache.
      * @param ttlInSeconds Default cache TTL.
      * @param caseSensitive Set to true if you want to differentiate between keys with different casing.
      */
-    constructor({ ttlInSeconds, caseSensitive, redis, onSuccess, onError, logger, }: PromiseCacheOptions);
+    constructor({ ttlInSeconds, caseSensitive, redis, fallbackToFunction, onSuccess, onError, logger, }: PromiseCacheOptions);
     /**
      * Cache size.
      * @returns The number of entries in the cache.

package/dist/index.d.ts

@@ -23,10 +23,10 @@ type PersistorConstructorType = {
 };
 declare class Persistor {
     client: ReturnType<typeof createClient> | null;
-    private clientId?;
-    private onError;
-    private onSuccess;
-    private logger;
+    private readonly clientId?;
+    private readonly onError;
+    private readonly onSuccess;
+    private readonly logger;
     private readonly redis?;
     constructor({ redis, clientId, onSuccess, onError, logger, }: PersistorConstructorType);
     startConnection(): Promise<void>;
@@ -59,21 +59,24 @@ type PromiseCacheOptions = {
     ttlInSeconds?: number;
     caseSensitive?: boolean;
     redis?: RedisClientOptions;
+    fallbackToFunction?: boolean;
     onError?: (error: string) => void;
     onSuccess?: () => void;
     logger?: Logger;
 };
 declare class PromiseCache<U> {
     persistor: Persistor;
-    private clientId;
+    private readonly clientId;
     private readonly caseSensitive;
+    private readonly fallbackToFunction;
     private readonly ttl?;
+    private readonly logger;
     /**
      * Initialize a new PromiseCache.
      * @param ttlInSeconds Default cache TTL.
      * @param caseSensitive Set to true if you want to differentiate between keys with different casing.
      */
-    constructor({ ttlInSeconds, caseSensitive, redis, onSuccess, onError, logger, }: PromiseCacheOptions);
+    constructor({ ttlInSeconds, caseSensitive, redis, fallbackToFunction, onSuccess, onError, logger, }: PromiseCacheOptions);
     /**
      * Cache size.
      * @returns The number of entries in the cache.

package/dist/index.js

@@ -124,7 +124,7 @@ var Persistor = class {
           socket: {
             ...this.redis?.socket,
             reconnectStrategy: (retries, cause) => {
-              console.error(cause);
+              this.logger?.error(cause);
               return 1e3 * 2 ** retries;
             }
           }
@@ -263,8 +263,11 @@ var PromiseCache = class {
   persistor;
   clientId = (0, import_node_crypto.randomUUID)();
   caseSensitive;
+  fallbackToFunction;
+  // If true, the cache will fallback to the delegate function if there is an error retrieving the cache.
   ttl;
   // Time to live in milliseconds.
+  logger;
   /**
    * Initialize a new PromiseCache.
    * @param ttlInSeconds Default cache TTL.
@@ -274,18 +277,21 @@ var PromiseCache = class {
     ttlInSeconds,
     caseSensitive = false,
     redis,
+    fallbackToFunction = false,
     onSuccess,
     onError,
     logger
   }) {
+    this.logger = logger;
     this.persistor = getPersistor({
       redis,
       onError,
       onSuccess,
       clientId: this.clientId,
-      logger
+      logger: this.logger
     });
     this.caseSensitive = caseSensitive;
+    this.fallbackToFunction = fallbackToFunction;
     if (ttlInSeconds) {
       this.ttl = ttlInSeconds;
     }
@@ -332,14 +338,25 @@ var PromiseCache = class {
     const now = Date.now();
     const effectiveKey = this.caseSensitive ? key : key.toLowerCase();
     let effectiveTTL = ttlInSeconds ?? this.ttl;
-    const cached = await this.persistor.get(effectiveKey);
-    if (cached) {
-      if (!ttlKeyInSeconds && cached.ttl !== effectiveTTL) {
-        console.error(
-          "WARNING: TTL mismatch for key. It is recommended to use the same TTL for the same key."
-        );
+    try {
+      const cached = await this.persistor.get(effectiveKey);
+      if (cached) {
+        if (!ttlKeyInSeconds && cached.ttl !== effectiveTTL) {
+          this.logger?.error(
+            "WARNING: TTL mismatch for key. It is recommended to use the same TTL for the same key."
+          );
+        }
+        return cached.value;
+      }
+    } catch (err) {
+      const error = err;
+      if (!this.fallbackToFunction) {
+        throw error;
       }
-      return cached.value;
+      this.logger?.error(
+        "redis error, falling back to function execution",
+        error instanceof Error ? error.message : String(error)
+      );
     }
     const response = await delegate();
     if (ttlKeyInSeconds) {
@@ -347,11 +364,16 @@ var PromiseCache = class {
       const responseTTL = Number(responseDict[ttlKeyInSeconds]);
       effectiveTTL = responseTTL || effectiveTTL;
     }
-    this.persistor.set(effectiveKey, {
-      value: response,
-      timestamp: now,
-      ttl: effectiveTTL
-    });
+    try {
+      await this.persistor.set(effectiveKey, {
+        value: response,
+        timestamp: now,
+        ttl: effectiveTTL
+      });
+    } catch (err) {
+      const error = err;
+      console.error("failed to cache result", error.message);
+    }
     return response;
   }
 };

package/dist/index.mjs

@@ -105,7 +105,7 @@ var Persistor = class {
           socket: {
             ...this.redis?.socket,
             reconnectStrategy: (retries, cause) => {
-              console.error(cause);
+              this.logger?.error(cause);
               return 1e3 * 2 ** retries;
             }
           }
@@ -244,8 +244,11 @@ var PromiseCache = class {
   persistor;
   clientId = randomUUID();
   caseSensitive;
+  fallbackToFunction;
+  // If true, the cache will fallback to the delegate function if there is an error retrieving the cache.
   ttl;
   // Time to live in milliseconds.
+  logger;
   /**
    * Initialize a new PromiseCache.
    * @param ttlInSeconds Default cache TTL.
@@ -255,18 +258,21 @@ var PromiseCache = class {
     ttlInSeconds,
     caseSensitive = false,
     redis,
+    fallbackToFunction = false,
     onSuccess,
     onError,
     logger
   }) {
+    this.logger = logger;
     this.persistor = getPersistor({
       redis,
       onError,
       onSuccess,
       clientId: this.clientId,
-      logger
+      logger: this.logger
     });
     this.caseSensitive = caseSensitive;
+    this.fallbackToFunction = fallbackToFunction;
     if (ttlInSeconds) {
       this.ttl = ttlInSeconds;
     }
@@ -313,14 +319,25 @@ var PromiseCache = class {
     const now = Date.now();
     const effectiveKey = this.caseSensitive ? key : key.toLowerCase();
     let effectiveTTL = ttlInSeconds ?? this.ttl;
-    const cached = await this.persistor.get(effectiveKey);
-    if (cached) {
-      if (!ttlKeyInSeconds && cached.ttl !== effectiveTTL) {
-        console.error(
-          "WARNING: TTL mismatch for key. It is recommended to use the same TTL for the same key."
-        );
+    try {
+      const cached = await this.persistor.get(effectiveKey);
+      if (cached) {
+        if (!ttlKeyInSeconds && cached.ttl !== effectiveTTL) {
+          this.logger?.error(
+            "WARNING: TTL mismatch for key. It is recommended to use the same TTL for the same key."
+          );
+        }
+        return cached.value;
+      }
+    } catch (err) {
+      const error = err;
+      if (!this.fallbackToFunction) {
+        throw error;
       }
-      return cached.value;
+      this.logger?.error(
+        "redis error, falling back to function execution",
+        error instanceof Error ? error.message : String(error)
+      );
     }
     const response = await delegate();
     if (ttlKeyInSeconds) {
@@ -328,11 +345,16 @@ var PromiseCache = class {
       const responseTTL = Number(responseDict[ttlKeyInSeconds]);
       effectiveTTL = responseTTL || effectiveTTL;
     }
-    this.persistor.set(effectiveKey, {
-      value: response,
-      timestamp: now,
-      ttl: effectiveTTL
-    });
+    try {
+      await this.persistor.set(effectiveKey, {
+        value: response,
+        timestamp: now,
+        ttl: effectiveTTL
+      });
+    } catch (err) {
+      const error = err;
+      console.error("failed to cache result", error.message);
+    }
     return response;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebspark/promise-cache",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -17,8 +17,8 @@
     "typecheck": "vitest --typecheck.only --passWithNoTests"
   },
   "devDependencies": {
-    "@testcontainers/redis": "^10.18.0",
-    "testcontainers": "^10.18.0",
+    "@testcontainers/redis": "10.25.0",
+    "testcontainers": "10.25.0",
     "tsconfig": "*"
   },
   "dependencies": {