@sebspark/promise-cache 2.1.1 → 3.0.0

package/README.md

@@ -1,23 +1,163 @@
 # `@sebspark/promise-cache`
 
-A simple caching wrapper for promises.
+Simple caching wrapper
+
+## **Features**
+
+- **PromiseCache**: Simple caching wraper for promises
+- **Persistor**: Simple Key/Value caching wrapper, can be used with redis or with local memory.
+  
+## **Installation**
+
+To install promise-cache, use `yarn`:
+
+```bash
+yarn install @sebspark/promise-cache
+```
+## **Usage**
+
+### **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                                 |
 
 ```typescript
+import { PromiseCache } from '@sebspark/promise-cache'
+
+// with redis
+const cacheInRedis = new PromiseCache<T>({
+  redis: REDIS_URL,
+  ttlInSeconds: ttl,
+  caseSensitive: true
+})
+
+// without redis
+const cacheLocalMemory = new PromiseCache<T>({
+  ttlInSeconds: ttl,
+  caseSensitive: true
+})
+```
+
+## **PromiseCache Methods**
+
+```typescript
+// Wrap
+/* Simple promise cache wrapper
+ * @param key Cache key.
+ * @param delegate The function to execute if the key is not in the cache.
+ * @param ttlInSeconds Time to live in seconds.
+ * @param ttlKeyInSeconds The key in the response object that contains the TTL.
+ * @returns The result of the delegate function.
+*/
+const ttl = 5 // 5 seconds
+const delegate = new Promise((reject, resolve) => { resolve(123)})
+const response = await cacheInRedis.wrap('Key', delegate, ttl)
+expect(response).toBe(123)
+
+// Size
 /*
- * Pseudocode example.
+* Cache size
+* @returns The number of entries in the cache
+*/
+
+const entries = await cacheInRedis.size()
+expect(entries).toBe(1)
+
+// Find
+ /**
+* Get a value from the cache.
+* @param key Cache key.
+*/
+
+const cachedValue = await cacheInRedis.find('Key')
+expect(cachedValue).toBe(123)
+
+// Override
+/**
+ * Set a value in the cache.
+ * @param key Cache key.
+ * @param value Cache value.
+ * @param ttlInSeconds? Time to live in seconds.
  */
-import { PromiseCache } from '@sebspark/promise-cache'
 
-// Instantiate the cache with a TTL.
-const cache = new PromiseCache<number>(60, true, true) // 1 minute cache TTL / is case sensitive / use local storage
+await cacheInRedis.override('Key', 234) // keep the same ttl
+const cached = cacheInRedis.find('Key')
+expect(cached).toBe(234)
+```
+
+### **Persistor Class**
+
+| Params        | Type     | Default |Description                                  |
+|---------------|----------|---------|---------------------------------------------|
+| redis         | RedisClientOptions   |    undefined     |Redis instance url, skip if use local memory |
+| onSuccess     | function |    undefined     |Callback function if connection is success   |
+| onError       | function |    undefined     |Callback function if there is an error       |
+| logger        | winston Logger |    undefined     |Logger                                 |
+| clientId        | any |    undefined     |Object internal id                                 |
+
+```typescript
+import { Persistor } from '@sebspark/promise-cache'
 
-const redisCache = new PromiseCache<number>(60, false, false) // 1 minute cache TTL / is not case sensitive / use redis storage
+// with redis
+const store = new Persistor<T>({
+  redis: REDIS_URL,
+})
+
+// without redis
+const store = new Persistor<T>()
+```
+
+## **Persistor Methods**
+
+```typescript
 
-// Use the cache wrapper for a database query to relieve the database.
-const query = 'SELECT username FROM users ORDER BY created DESC LIMIT 1'
-const newestUser = await cache.wrap('newestUser', () => database.query(query))
+/**
+* Size
+* @returns The number of entries in the cache
+*/
+
+const size = await store.size()
+expect(size).toBe(0)
+
+/**
+* Set
+* Set a value in the cache.
+* @param key Cache key.
+* @param object.value Value to set in the cache.
+* @param object.ttl Time to live in seconds.
+* @param object.timestamp Timestamp
+*/
+
+await store.set<number>('MyKey', {
+  value: 123,
+  ttl: 10               // In seconds, default undefined
+  timestamp: Date.now() // default Date.now()
+})
+
+/**
+ * Get a value from the cache.
+ * @param key Cache key.
+ * @returns GetType<T> value
+ */
+
+const cached = await store.get('MyKey')
+expect(cached).toBe({
+  value: 43,
+  ttl: 10,
+  timestamp: // The timestamp
+})
+
+/**
+ * Delete a value from the cache.
+ * @param key Cache key
+ */
 
-// Use the cache wrapper for a database query to relieve the database.
-const query = 'SELECT username FROM users ORDER BY created DESC LIMIT 1'
-const newestUser = await redisCache.wrap('newestUserRedis', () => database.query(query))
-```
+await store.delete('MyKey')
+expect(await store.get('MyKey').toBe(null)
+```

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { RedisClientOptions, createClient } from 'redis';
 export { RedisClientOptions } from 'redis';
+import { Logger } from 'winston';
 import { UUID } from 'node:crypto';
 
 type GetType<T> = {
@@ -9,29 +10,47 @@ type GetType<T> = {
 };
 type SetParams<T> = {
     value: T;
-    timestamp: number;
+    timestamp?: number;
     ttl?: number;
 };
 type PersistorConstructorType = {
     redis?: RedisClientOptions;
     clientId?: UUID;
-    onError: (error: string) => void;
-    onSuccess: () => void;
+    onError?: (error: string) => void;
+    onSuccess?: () => void;
+    logger?: Logger;
 };
 declare class Persistor {
     client: ReturnType<typeof createClient> | null;
     private clientId?;
     private onError;
     private onSuccess;
+    private logger;
     private readonly redis?;
-    constructor({ redis, clientId, onSuccess, onError, }: PersistorConstructorType);
+    constructor({ redis, clientId, onSuccess, onError, logger, }: PersistorConstructorType);
     startConnection(): Promise<void>;
     size(): Promise<number>;
-    get<T>(key: string): Promise<GetType<T> | null>;
     getClientId(): UUID | undefined;
     getIsClientConnected(): boolean;
     private createOptions;
+    /**
+     * Set a value in the cache.
+     * @param key Cache key.
+     * @param object.value Value to set in the cache.
+     * @param object.ttl Time to live in seconds.
+     * @param object.timestamp Timestamp
+     */
     set<T>(key: string, { value, timestamp, ttl }: SetParams<T>): Promise<void>;
+    /**
+     * Get a value from the cache.
+     * @param key Cache key.
+     * @returns GetType<T> value
+     */
+    get<T>(key: string): Promise<GetType<T> | null>;
+    /**
+     * Delete a value from the cache.
+     * @param key Cache key
+     */
     delete(key: string): Promise<void>;
 }
 
@@ -41,6 +60,7 @@ type PromiseCacheOptions = {
     redis?: RedisClientOptions;
     onError?: (error: string) => void;
     onSuccess?: () => void;
+    logger?: Logger;
 };
 declare class PromiseCache<U> {
     persistor: Persistor;
@@ -52,14 +72,14 @@ declare class PromiseCache<U> {
      * @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, }: PromiseCacheOptions);
+    constructor({ ttlInSeconds, caseSensitive, redis, onSuccess, onError, logger, }: PromiseCacheOptions);
     /**
      * Cache size.
      * @returns The number of entries in the cache.
      */
     size(): Promise<number>;
     /**
-     * Set a value in the cache.
+     * Override a value in the cache.
      * @param key Cache key.
      * @param value Cache value.
      * @param ttlInSeconds Time to live in seconds.
@@ -81,19 +101,4 @@ declare class PromiseCache<U> {
     wrap(key: string, delegate: () => Promise<U>, ttlInSeconds?: number, ttlKeyInSeconds?: string): Promise<U>;
 }
 
-declare class LocalStorage {
-    client: Map<any, any>;
-    isReady: boolean;
-    get(key: string): any;
-    set(key: string, value: string, options?: {
-        PX: number;
-    }): void;
-    del(key: string): void;
-    clear(): void;
-    DBSIZE(): Promise<number>;
-    on(event: string, callback: (message: string) => void): this;
-    connect(): Promise<this>;
-}
-declare const createLocalMemoryClient: () => LocalStorage;
-
-export { LocalStorage, Persistor, type PersistorConstructorType, PromiseCache, type PromiseCacheOptions, createLocalMemoryClient };
+export { Persistor, type PersistorConstructorType, PromiseCache, type PromiseCacheOptions };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { RedisClientOptions, createClient } from 'redis';
 export { RedisClientOptions } from 'redis';
+import { Logger } from 'winston';
 import { UUID } from 'node:crypto';
 
 type GetType<T> = {
@@ -9,29 +10,47 @@ type GetType<T> = {
 };
 type SetParams<T> = {
     value: T;
-    timestamp: number;
+    timestamp?: number;
     ttl?: number;
 };
 type PersistorConstructorType = {
     redis?: RedisClientOptions;
     clientId?: UUID;
-    onError: (error: string) => void;
-    onSuccess: () => void;
+    onError?: (error: string) => void;
+    onSuccess?: () => void;
+    logger?: Logger;
 };
 declare class Persistor {
     client: ReturnType<typeof createClient> | null;
     private clientId?;
     private onError;
     private onSuccess;
+    private logger;
     private readonly redis?;
-    constructor({ redis, clientId, onSuccess, onError, }: PersistorConstructorType);
+    constructor({ redis, clientId, onSuccess, onError, logger, }: PersistorConstructorType);
     startConnection(): Promise<void>;
     size(): Promise<number>;
-    get<T>(key: string): Promise<GetType<T> | null>;
     getClientId(): UUID | undefined;
     getIsClientConnected(): boolean;
     private createOptions;
+    /**
+     * Set a value in the cache.
+     * @param key Cache key.
+     * @param object.value Value to set in the cache.
+     * @param object.ttl Time to live in seconds.
+     * @param object.timestamp Timestamp
+     */
     set<T>(key: string, { value, timestamp, ttl }: SetParams<T>): Promise<void>;
+    /**
+     * Get a value from the cache.
+     * @param key Cache key.
+     * @returns GetType<T> value
+     */
+    get<T>(key: string): Promise<GetType<T> | null>;
+    /**
+     * Delete a value from the cache.
+     * @param key Cache key
+     */
     delete(key: string): Promise<void>;
 }
 
@@ -41,6 +60,7 @@ type PromiseCacheOptions = {
     redis?: RedisClientOptions;
     onError?: (error: string) => void;
     onSuccess?: () => void;
+    logger?: Logger;
 };
 declare class PromiseCache<U> {
     persistor: Persistor;
@@ -52,14 +72,14 @@ declare class PromiseCache<U> {
      * @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, }: PromiseCacheOptions);
+    constructor({ ttlInSeconds, caseSensitive, redis, onSuccess, onError, logger, }: PromiseCacheOptions);
     /**
      * Cache size.
      * @returns The number of entries in the cache.
      */
     size(): Promise<number>;
     /**
-     * Set a value in the cache.
+     * Override a value in the cache.
      * @param key Cache key.
      * @param value Cache value.
      * @param ttlInSeconds Time to live in seconds.
@@ -81,19 +101,4 @@ declare class PromiseCache<U> {
     wrap(key: string, delegate: () => Promise<U>, ttlInSeconds?: number, ttlKeyInSeconds?: string): Promise<U>;
 }
 
-declare class LocalStorage {
-    client: Map<any, any>;
-    isReady: boolean;
-    get(key: string): any;
-    set(key: string, value: string, options?: {
-        PX: number;
-    }): void;
-    del(key: string): void;
-    clear(): void;
-    DBSIZE(): Promise<number>;
-    on(event: string, callback: (message: string) => void): this;
-    connect(): Promise<this>;
-}
-declare const createLocalMemoryClient: () => LocalStorage;
-
-export { LocalStorage, Persistor, type PersistorConstructorType, PromiseCache, type PromiseCacheOptions, createLocalMemoryClient };
+export { Persistor, type PersistorConstructorType, PromiseCache, type PromiseCacheOptions };

package/dist/index.js

@@ -20,10 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  LocalStorage: () => LocalStorage,
   Persistor: () => Persistor,
-  PromiseCache: () => PromiseCache,
-  createLocalMemoryClient: () => createLocalMemoryClient
+  PromiseCache: () => PromiseCache
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -74,24 +72,144 @@ var createLocalMemoryClient = () => {
   return localStorage;
 };
 
+// src/serializerUtils.ts
+function serialize(value) {
+  const type = typeof value;
+  if (value === null) {
+    return JSON.stringify({ type: "null" });
+  }
+  if (value === void 0) {
+    return JSON.stringify({ type: "undefined" });
+  }
+  switch (type) {
+    case "string":
+    case "number":
+    case "boolean":
+      return JSON.stringify({ type, value });
+    case "bigint":
+      return JSON.stringify({ type: "bigint", value: value.toString() });
+    case "object": {
+      if (Array.isArray(value)) {
+        return JSON.stringify({ type: "array", value: value.map(serialize) });
+      }
+      if (value instanceof Map) {
+        const entries = Array.from(value.entries()).map(([key, val]) => [
+          serialize(key),
+          serialize(val)
+        ]);
+        return JSON.stringify({ type: "map", value: entries });
+      }
+      if (value instanceof Set) {
+        const entries = Array.from(value).map(serialize);
+        return JSON.stringify({ type: "set", value: entries });
+      }
+      if (value.constructor === Object) {
+        const entries = Object.entries(value).reduce(
+          (acc, [key, val]) => {
+            acc[key] = serialize(val);
+            return acc;
+          },
+          {}
+        );
+        return JSON.stringify({ type: "object", value: entries });
+      }
+      throw new Error("Cannot serialize non-plain objects");
+    }
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+}
+function deserializePrimitives(serialized) {
+  let parsed = serialized;
+  if (typeof serialized === "string") {
+    parsed = JSON.parse(serialized);
+  }
+  switch (parsed.type) {
+    case "string":
+      return parsed.value;
+    case "number":
+      return Number(parsed.value);
+    case "boolean":
+      return Boolean(parsed.value);
+    case "undefined":
+      return void 0;
+    case "bigint":
+      return BigInt(parsed.value);
+    case "null":
+      return null;
+    default:
+      throw new Error(
+        `Unsupported type during deserialization: ${JSON.stringify(parsed)}`
+      );
+  }
+}
+function deserialize(serialized) {
+  let parsed = serialized;
+  if (typeof serialized === "string") {
+    parsed = JSON.parse(serialized);
+  }
+  switch (parsed.type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+    case "bigint":
+    case "null":
+      return deserializePrimitives(parsed);
+    case "array":
+      return parsed.value.map(deserialize);
+    case "map": {
+      const map = /* @__PURE__ */ new Map();
+      for (const [key, val] of parsed.value) {
+        map.set(deserialize(key), deserialize(val));
+      }
+      return map;
+    }
+    case "set": {
+      const set = /* @__PURE__ */ new Set();
+      for (const item of parsed.value) {
+        set.add(deserialize(item));
+      }
+      return set;
+    }
+    case "object": {
+      const obj = {};
+      for (const [key, val] of Object.entries(parsed.value)) {
+        obj[key] = deserialize(val);
+      }
+      return obj;
+    }
+    default:
+      throw new Error(`Unsupported type during deserialization: ${parsed}`);
+  }
+}
+
 // src/persistor.ts
 var CACHE_CLIENT = import_redis.createClient;
 var isTestRunning = process.env.NODE_ENV === "test";
+function toMillis(seconds) {
+  return seconds / 1e3;
+}
 var Persistor = class {
   client = null;
   clientId;
   onError;
   onSuccess;
+  logger;
   redis;
   constructor({
     redis,
     clientId,
     onSuccess,
-    onError
+    onError,
+    logger
   }) {
-    this.onError = onError;
-    this.onSuccess = onSuccess;
+    this.onError = onError || (() => {
+    });
+    this.onSuccess = onSuccess || (() => {
+    });
     this.clientId = clientId;
+    this.logger = logger;
     if (redis && !isTestRunning) {
       this.redis = redis;
     } else {
@@ -102,11 +220,12 @@ var Persistor = class {
     }
   }
   async startConnection() {
+    var _a;
     try {
       await new Promise((resolve, reject) => {
-        var _a;
+        var _a2;
         this.client = CACHE_CLIENT({
-          url: (_a = this.redis) == null ? void 0 : _a.url,
+          url: (_a2 = this.redis) == null ? void 0 : _a2.url,
           socket: {
             reconnectStrategy: (retries, cause) => {
               console.error(cause);
@@ -120,15 +239,17 @@ var Persistor = class {
           this.onSuccess();
           resolve(true);
         }).on("reconnecting", () => {
-          console.log("reconnecting...", this.clientId);
+          var _a3;
+          (_a3 = this.logger) == null ? void 0 : _a3.info("reconnecting...", this.clientId);
         }).on("end", () => {
-          console.log("end...", this.clientId);
+          var _a3;
+          (_a3 = this.logger) == null ? void 0 : _a3.info("end...", this.clientId);
         });
         this.client.connect();
       });
     } catch (ex) {
       this.onError(`${ex}`);
-      console.error(ex);
+      (_a = this.logger) == null ? void 0 : _a.error(ex);
     }
   }
   async size() {
@@ -137,20 +258,6 @@ var Persistor = class {
     }
     return await this.client.DBSIZE();
   }
-  async get(key) {
-    if (!this.client) {
-      throw new Error("Client not initialized");
-    }
-    try {
-      const result = await this.client.get(key);
-      if (!result) {
-        return null;
-      }
-      return JSON.parse(result);
-    } catch (error) {
-      throw new Error(`Error getting data from redis: ${error}`);
-    }
-  }
   getClientId() {
     return this.clientId;
   }
@@ -160,26 +267,67 @@ var Persistor = class {
   }
   createOptions(ttl) {
     if (ttl !== null && ttl !== void 0) {
-      return { PX: Math.round(ttl) };
+      return { PX: Math.round(toMillis(ttl)) };
     }
     return {};
   }
-  async set(key, { value, timestamp, ttl }) {
+  /**
+   * Set a value in the cache.
+   * @param key Cache key.
+   * @param object.value Value to set in the cache.
+   * @param object.ttl Time to live in seconds.
+   * @param object.timestamp Timestamp
+   */
+  async set(key, { value, timestamp = Date.now(), ttl }) {
+    var _a;
     if (!this.client || !this.client.isReady) {
-      console.error("Client not ready");
+      (_a = this.logger) == null ? void 0 : _a.error("Client not ready");
       return;
     }
     try {
-      const serializedData = JSON.stringify({ value, ttl, timestamp });
+      const serializedData = JSON.stringify({
+        value: serialize(value),
+        ttl,
+        timestamp
+      });
       const options = this.createOptions(ttl);
       await this.client.set(key, serializedData, options);
     } catch (error) {
       throw new Error(`Error setting data in redis: ${error}`);
     }
   }
+  /**
+   * Get a value from the cache.
+   * @param key Cache key.
+   * @returns GetType<T> value
+   */
+  async get(key) {
+    if (!this.client) {
+      throw new Error("Client not initialized");
+    }
+    try {
+      const data = await this.client.get(key);
+      if (!data) {
+        return null;
+      }
+      const storedData = JSON.parse(data);
+      const deserialized = JSON.parse(storedData.value);
+      return {
+        ...storedData,
+        value: deserialize(deserialized)
+      };
+    } catch (error) {
+      throw new Error(`Error getting data from redis: ${error}`);
+    }
+  }
+  /**
+   * Delete a value from the cache.
+   * @param key Cache key
+   */
   async delete(key) {
+    var _a;
     if (!this.client || !this.client.isReady) {
-      console.error("Client not ready");
+      (_a = this.logger) == null ? void 0 : _a.error("Client not ready");
       return;
     }
     try {
@@ -194,6 +342,7 @@ var Persistor = class {
 var persistors = {};
 var getPersistor = ({
   redis,
+  logger,
   onError,
   onSuccess,
   clientId
@@ -204,17 +353,18 @@ var getPersistor = ({
       redis,
       onError: (error) => {
         onError == null ? void 0 : onError(error);
-        console.error(
+        logger == null ? void 0 : logger.error(
           `\u274C REDIS | Client Error | ${connectionName} | ${redis == null ? void 0 : redis.url}: ${error}`
         );
       },
       onSuccess: () => {
         onSuccess == null ? void 0 : onSuccess();
-        console.log(
+        logger == null ? void 0 : logger.info(
           `\u{1F4E6} REDIS | Connection Ready | ${connectionName} | ${redis == null ? void 0 : redis.url}`
         );
       },
-      clientId
+      clientId,
+      logger
     });
   }
   return persistors[connectionName];
@@ -235,13 +385,15 @@ var PromiseCache = class {
     caseSensitive = false,
     redis,
     onSuccess,
-    onError
+    onError,
+    logger
   }) {
     this.persistor = getPersistor({
       redis,
       onError,
       onSuccess,
-      clientId: this.clientId
+      clientId: this.clientId,
+      logger
     });
     this.caseSensitive = caseSensitive;
     if (ttlInSeconds) {
@@ -256,14 +408,14 @@ var PromiseCache = class {
     return await this.persistor.size();
   }
   /**
-   * Set a value in the cache.
+   * Override a value in the cache.
    * @param key Cache key.
    * @param value Cache value.
    * @param ttlInSeconds Time to live in seconds.
    */
   async override(key, value, ttlInSeconds) {
     const effectiveKey = this.caseSensitive ? key : key.toLowerCase();
-    const effectiveTTL = ttlInSeconds !== void 0 ? ttlInSeconds * 1e3 : this.ttl;
+    const effectiveTTL = ttlInSeconds !== void 0 ? ttlInSeconds : this.ttl;
     await this.persistor.set(effectiveKey, {
       value,
       timestamp: Date.now(),
@@ -294,7 +446,7 @@ var PromiseCache = class {
     if (cached) {
       if (!ttlKeyInSeconds && cached.ttl !== effectiveTTL) {
         console.error(
-          `WARNING: TTL mismatch for key: ${effectiveKey}. It is recommended to use the same TTL for the same key.`
+          "WARNING: TTL mismatch for key. It is recommended to use the same TTL for the same key."
         );
       }
       return cached.value;
@@ -315,8 +467,6 @@ var PromiseCache = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LocalStorage,
   Persistor,
-  PromiseCache,
-  createLocalMemoryClient
+  PromiseCache
 });

package/dist/index.mjs

@@ -45,24 +45,144 @@ var createLocalMemoryClient = () => {
   return localStorage;
 };
 
+// src/serializerUtils.ts
+function serialize(value) {
+  const type = typeof value;
+  if (value === null) {
+    return JSON.stringify({ type: "null" });
+  }
+  if (value === void 0) {
+    return JSON.stringify({ type: "undefined" });
+  }
+  switch (type) {
+    case "string":
+    case "number":
+    case "boolean":
+      return JSON.stringify({ type, value });
+    case "bigint":
+      return JSON.stringify({ type: "bigint", value: value.toString() });
+    case "object": {
+      if (Array.isArray(value)) {
+        return JSON.stringify({ type: "array", value: value.map(serialize) });
+      }
+      if (value instanceof Map) {
+        const entries = Array.from(value.entries()).map(([key, val]) => [
+          serialize(key),
+          serialize(val)
+        ]);
+        return JSON.stringify({ type: "map", value: entries });
+      }
+      if (value instanceof Set) {
+        const entries = Array.from(value).map(serialize);
+        return JSON.stringify({ type: "set", value: entries });
+      }
+      if (value.constructor === Object) {
+        const entries = Object.entries(value).reduce(
+          (acc, [key, val]) => {
+            acc[key] = serialize(val);
+            return acc;
+          },
+          {}
+        );
+        return JSON.stringify({ type: "object", value: entries });
+      }
+      throw new Error("Cannot serialize non-plain objects");
+    }
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+}
+function deserializePrimitives(serialized) {
+  let parsed = serialized;
+  if (typeof serialized === "string") {
+    parsed = JSON.parse(serialized);
+  }
+  switch (parsed.type) {
+    case "string":
+      return parsed.value;
+    case "number":
+      return Number(parsed.value);
+    case "boolean":
+      return Boolean(parsed.value);
+    case "undefined":
+      return void 0;
+    case "bigint":
+      return BigInt(parsed.value);
+    case "null":
+      return null;
+    default:
+      throw new Error(
+        `Unsupported type during deserialization: ${JSON.stringify(parsed)}`
+      );
+  }
+}
+function deserialize(serialized) {
+  let parsed = serialized;
+  if (typeof serialized === "string") {
+    parsed = JSON.parse(serialized);
+  }
+  switch (parsed.type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+    case "bigint":
+    case "null":
+      return deserializePrimitives(parsed);
+    case "array":
+      return parsed.value.map(deserialize);
+    case "map": {
+      const map = /* @__PURE__ */ new Map();
+      for (const [key, val] of parsed.value) {
+        map.set(deserialize(key), deserialize(val));
+      }
+      return map;
+    }
+    case "set": {
+      const set = /* @__PURE__ */ new Set();
+      for (const item of parsed.value) {
+        set.add(deserialize(item));
+      }
+      return set;
+    }
+    case "object": {
+      const obj = {};
+      for (const [key, val] of Object.entries(parsed.value)) {
+        obj[key] = deserialize(val);
+      }
+      return obj;
+    }
+    default:
+      throw new Error(`Unsupported type during deserialization: ${parsed}`);
+  }
+}
+
 // src/persistor.ts
 var CACHE_CLIENT = createClient;
 var isTestRunning = process.env.NODE_ENV === "test";
+function toMillis(seconds) {
+  return seconds / 1e3;
+}
 var Persistor = class {
   client = null;
   clientId;
   onError;
   onSuccess;
+  logger;
   redis;
   constructor({
     redis,
     clientId,
     onSuccess,
-    onError
+    onError,
+    logger
   }) {
-    this.onError = onError;
-    this.onSuccess = onSuccess;
+    this.onError = onError || (() => {
+    });
+    this.onSuccess = onSuccess || (() => {
+    });
     this.clientId = clientId;
+    this.logger = logger;
     if (redis && !isTestRunning) {
       this.redis = redis;
     } else {
@@ -73,11 +193,12 @@ var Persistor = class {
     }
   }
   async startConnection() {
+    var _a;
     try {
       await new Promise((resolve, reject) => {
-        var _a;
+        var _a2;
         this.client = CACHE_CLIENT({
-          url: (_a = this.redis) == null ? void 0 : _a.url,
+          url: (_a2 = this.redis) == null ? void 0 : _a2.url,
           socket: {
             reconnectStrategy: (retries, cause) => {
               console.error(cause);
@@ -91,15 +212,17 @@ var Persistor = class {
           this.onSuccess();
           resolve(true);
         }).on("reconnecting", () => {
-          console.log("reconnecting...", this.clientId);
+          var _a3;
+          (_a3 = this.logger) == null ? void 0 : _a3.info("reconnecting...", this.clientId);
         }).on("end", () => {
-          console.log("end...", this.clientId);
+          var _a3;
+          (_a3 = this.logger) == null ? void 0 : _a3.info("end...", this.clientId);
         });
         this.client.connect();
       });
     } catch (ex) {
       this.onError(`${ex}`);
-      console.error(ex);
+      (_a = this.logger) == null ? void 0 : _a.error(ex);
     }
   }
   async size() {
@@ -108,20 +231,6 @@ var Persistor = class {
     }
     return await this.client.DBSIZE();
   }
-  async get(key) {
-    if (!this.client) {
-      throw new Error("Client not initialized");
-    }
-    try {
-      const result = await this.client.get(key);
-      if (!result) {
-        return null;
-      }
-      return JSON.parse(result);
-    } catch (error) {
-      throw new Error(`Error getting data from redis: ${error}`);
-    }
-  }
   getClientId() {
     return this.clientId;
   }
@@ -131,26 +240,67 @@ var Persistor = class {
   }
   createOptions(ttl) {
     if (ttl !== null && ttl !== void 0) {
-      return { PX: Math.round(ttl) };
+      return { PX: Math.round(toMillis(ttl)) };
     }
     return {};
   }
-  async set(key, { value, timestamp, ttl }) {
+  /**
+   * Set a value in the cache.
+   * @param key Cache key.
+   * @param object.value Value to set in the cache.
+   * @param object.ttl Time to live in seconds.
+   * @param object.timestamp Timestamp
+   */
+  async set(key, { value, timestamp = Date.now(), ttl }) {
+    var _a;
     if (!this.client || !this.client.isReady) {
-      console.error("Client not ready");
+      (_a = this.logger) == null ? void 0 : _a.error("Client not ready");
       return;
     }
     try {
-      const serializedData = JSON.stringify({ value, ttl, timestamp });
+      const serializedData = JSON.stringify({
+        value: serialize(value),
+        ttl,
+        timestamp
+      });
       const options = this.createOptions(ttl);
       await this.client.set(key, serializedData, options);
     } catch (error) {
       throw new Error(`Error setting data in redis: ${error}`);
     }
   }
+  /**
+   * Get a value from the cache.
+   * @param key Cache key.
+   * @returns GetType<T> value
+   */
+  async get(key) {
+    if (!this.client) {
+      throw new Error("Client not initialized");
+    }
+    try {
+      const data = await this.client.get(key);
+      if (!data) {
+        return null;
+      }
+      const storedData = JSON.parse(data);
+      const deserialized = JSON.parse(storedData.value);
+      return {
+        ...storedData,
+        value: deserialize(deserialized)
+      };
+    } catch (error) {
+      throw new Error(`Error getting data from redis: ${error}`);
+    }
+  }
+  /**
+   * Delete a value from the cache.
+   * @param key Cache key
+   */
   async delete(key) {
+    var _a;
     if (!this.client || !this.client.isReady) {
-      console.error("Client not ready");
+      (_a = this.logger) == null ? void 0 : _a.error("Client not ready");
       return;
     }
     try {
@@ -165,6 +315,7 @@ var Persistor = class {
 var persistors = {};
 var getPersistor = ({
   redis,
+  logger,
   onError,
   onSuccess,
   clientId
@@ -175,17 +326,18 @@ var getPersistor = ({
       redis,
       onError: (error) => {
         onError == null ? void 0 : onError(error);
-        console.error(
+        logger == null ? void 0 : logger.error(
           `\u274C REDIS | Client Error | ${connectionName} | ${redis == null ? void 0 : redis.url}: ${error}`
         );
       },
       onSuccess: () => {
         onSuccess == null ? void 0 : onSuccess();
-        console.log(
+        logger == null ? void 0 : logger.info(
           `\u{1F4E6} REDIS | Connection Ready | ${connectionName} | ${redis == null ? void 0 : redis.url}`
         );
       },
-      clientId
+      clientId,
+      logger
     });
   }
   return persistors[connectionName];
@@ -206,13 +358,15 @@ var PromiseCache = class {
     caseSensitive = false,
     redis,
     onSuccess,
-    onError
+    onError,
+    logger
   }) {
     this.persistor = getPersistor({
       redis,
       onError,
       onSuccess,
-      clientId: this.clientId
+      clientId: this.clientId,
+      logger
     });
     this.caseSensitive = caseSensitive;
     if (ttlInSeconds) {
@@ -227,14 +381,14 @@ var PromiseCache = class {
     return await this.persistor.size();
   }
   /**
-   * Set a value in the cache.
+   * Override a value in the cache.
    * @param key Cache key.
    * @param value Cache value.
    * @param ttlInSeconds Time to live in seconds.
    */
   async override(key, value, ttlInSeconds) {
     const effectiveKey = this.caseSensitive ? key : key.toLowerCase();
-    const effectiveTTL = ttlInSeconds !== void 0 ? ttlInSeconds * 1e3 : this.ttl;
+    const effectiveTTL = ttlInSeconds !== void 0 ? ttlInSeconds : this.ttl;
     await this.persistor.set(effectiveKey, {
       value,
       timestamp: Date.now(),
@@ -265,7 +419,7 @@ var PromiseCache = class {
     if (cached) {
       if (!ttlKeyInSeconds && cached.ttl !== effectiveTTL) {
         console.error(
-          `WARNING: TTL mismatch for key: ${effectiveKey}. It is recommended to use the same TTL for the same key.`
+          "WARNING: TTL mismatch for key. It is recommended to use the same TTL for the same key."
         );
       }
       return cached.value;
@@ -285,8 +439,6 @@ var PromiseCache = class {
   }
 };
 export {
-  LocalStorage,
   Persistor,
-  PromiseCache,
-  createLocalMemoryClient
+  PromiseCache
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebspark/promise-cache",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -19,7 +19,6 @@
     "tsconfig": "*"
   },
   "dependencies": {
-    "redis": "4.7.0",
-    "@sebspark/retry": "*"
+    "redis": "4.7.0"
   }
 }