@sebspark/promise-cache 4.0.0 → 4.0.2

package/dist/index.mjs

@@ -10,369 +10,20 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/promiseCache.ts
-import { randomUUID } from "crypto";
-
-// src/persistor.ts
-import { createClient } from "redis";
-
-// src/localMemory.ts
-var LocalStorage = class {
-  client = /* @__PURE__ */ new Map();
-  isReady = false;
-  get(key) {
-    return this.client.get(key);
-  }
-  set(key, value, options) {
-    this.client.set(key, value);
-    if (options?.PX) {
-      setTimeout(() => {
-        this.client.delete(key);
-      }, options.PX);
-    }
-  }
-  del(key) {
-    this.client.delete(key);
-  }
-  clear() {
-    this.client.clear();
-  }
-  async DBSIZE() {
-    return Promise.resolve(this.client.size);
-  }
-  // This is just for testing
-  on(event, callback) {
-    if (event === "ready" && callback) {
-      this.isReady = true;
-      callback("ready");
-    }
-    return this;
-  }
-  connect() {
-    return Promise.resolve(this);
-  }
-};
-var localStorage = new LocalStorage();
-var createLocalMemoryClient = () => {
-  return localStorage;
-};
-
-// src/persistor.ts
-var fixESM = __require("fix-esm");
-var superjson = fixESM.require("superjson");
-var CACHE_CLIENT = createClient;
-var isTestRunning = process.env.NODE_ENV === "test";
-function toMillis(seconds2) {
-  return seconds2 * 1e3;
-}
-var Persistor = class {
-  client = null;
-  clientId;
-  onError;
-  onSuccess;
-  logger;
-  redis;
-  constructor({
-    redis,
-    clientId,
-    onSuccess,
-    onError,
-    logger
-  }) {
-    this.onError = onError || (() => {
-    });
-    this.onSuccess = onSuccess || (() => {
-    });
-    this.clientId = clientId;
-    this.logger = logger;
-    if (redis && !isTestRunning) {
-      this.redis = redis;
-    } else {
-      CACHE_CLIENT = createLocalMemoryClient;
-    }
-    if (!this.client || !this.client.isReady) {
-      this.startConnection();
-    }
-  }
-  async startConnection() {
-    try {
-      await new Promise((resolve, reject) => {
-        this.client = CACHE_CLIENT({
-          url: this.redis?.url,
-          username: this.redis?.username,
-          password: this.redis?.password,
-          pingInterval: this.redis?.pingInterval || void 0,
-          socket: {
-            ...this.redis?.socket,
-            reconnectStrategy: (retries, cause) => {
-              this.logger?.error(cause);
-              return 1e3 * 2 ** retries;
-            }
-          }
-        }).on("error", (err) => {
-          this.onError(err);
-          reject(err);
-        }).on("ready", () => {
-          this.onSuccess();
-          resolve(true);
-        }).on("reconnecting", () => {
-          this.logger?.info("reconnecting...", this.clientId);
-        }).on("end", () => {
-          this.logger?.info("end...", this.clientId);
-        });
-        this.client.connect();
-      });
-    } catch (ex) {
-      this.onError(`${ex}`);
-      this.logger?.error(ex);
-    }
-  }
-  async size() {
-    if (!this.client) {
-      throw new Error("Client not initialized");
-    }
-    return await this.client.DBSIZE();
-  }
-  getClientId() {
-    return this.clientId;
-  }
-  getIsClientConnected() {
-    return !!this.client?.isReady;
-  }
-  createOptions(ttl) {
-    if (ttl !== null && ttl !== void 0) {
-      return { PX: Math.round(toMillis(ttl)) };
-    }
-    return {};
-  }
-  /**
-   * 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 }) {
-    if (!this.client || !this.client.isReady) {
-      this.logger?.error("Client not ready");
-      return;
-    }
-    try {
-      const serializedData = superjson.stringify({
-        value,
-        ttl,
-        timestamp
-      });
-      const options = this.createOptions(ttl);
-      await this.client.set(key, serializedData, options);
-    } catch (error) {
-      this.logger?.error(`Error setting data in redis: ${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) {
-      this.logger?.error("Client not ready");
-      return null;
-    }
-    try {
-      const data = await this.client.get(key);
-      if (!data) {
-        return null;
-      }
-      return superjson.parse(data);
-    } catch (error) {
-      this.logger?.error(`Error getting data in redis: ${error}`);
-      throw new Error(`Error getting data from redis: ${error}`);
-    }
-  }
-  /**
-   * Delete a value from the cache.
-   * @param key Cache key
-   */
-  async delete(key) {
-    if (!this.client || !this.client.isReady) {
-      this.logger?.error("Client not ready");
-      return;
-    }
-    try {
-      await this.client.del(key);
-    } catch (error) {
-      this.logger?.error(`Error deleting data from redis: ${error}`);
-      throw new Error(`Error deleting data from redis: ${error}`);
-    }
-  }
-};
-
-// src/promiseCache.ts
-var persistors = {};
-var getPersistor = ({
-  redis,
-  logger,
-  onError,
-  onSuccess,
-  clientId
-}) => {
-  const connectionName = redis ? redis?.name || "default" : "local";
-  if (!persistors[connectionName]) {
-    persistors[connectionName] = new Persistor({
-      redis,
-      onError: (error) => {
-        onError?.(error);
-        logger?.error(
-          `\u274C REDIS | Client Error | ${connectionName} | ${redis?.url}: ${error}`
-        );
-      },
-      onSuccess: () => {
-        onSuccess?.();
-        logger?.info(
-          `\u{1F4E6} REDIS | Connection Ready | ${connectionName} | ${redis?.url}`
-        );
-      },
-      clientId,
-      logger
-    });
-  }
-  return persistors[connectionName];
-};
-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.
-   * @param caseSensitive Set to true if you want to differentiate between keys with different casing.
-   */
-  constructor({
-    ttlInSeconds,
-    caseSensitive = false,
-    redis,
-    fallbackToFunction = false,
-    onSuccess,
-    onError,
-    logger
-  }) {
-    this.logger = logger;
-    this.persistor = getPersistor({
-      redis,
-      onError,
-      onSuccess,
-      clientId: this.clientId,
-      logger: this.logger
-    });
-    this.caseSensitive = caseSensitive;
-    this.fallbackToFunction = fallbackToFunction;
-    if (ttlInSeconds) {
-      this.ttl = ttlInSeconds;
-    }
-  }
-  /**
-   * Cache size.
-   * @returns The number of entries in the cache.
-   */
-  async size() {
-    return await this.persistor.size();
-  }
-  /**
-   * 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 : this.ttl;
-    await this.persistor.set(effectiveKey, {
-      value,
-      timestamp: Date.now(),
-      ttl: effectiveTTL
-    });
-  }
-  /**
-   * Get a value from the cache.
-   * @param key Cache key.
-   */
-  async find(key) {
-    const result = await this.persistor.get(key);
-    return result?.value ?? null;
-  }
-  /**
-   * A 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.
-   */
-  async wrap(key, delegate, ttlInSeconds, ttlKeyInSeconds) {
-    const now = Date.now();
-    const effectiveKey = this.caseSensitive ? key : key.toLowerCase();
-    let effectiveTTL = ttlInSeconds ?? this.ttl;
-    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;
-      }
-      this.logger?.error(
-        "redis error, falling back to function execution",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    const response = await delegate();
-    if (ttlKeyInSeconds) {
-      const responseDict = response;
-      const responseTTL = Number(responseDict[ttlKeyInSeconds]);
-      effectiveTTL = responseTTL || 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;
-  }
-};
-
 // src/serializer.ts
 var serializer_exports = {};
 __export(serializer_exports, {
   deserialize: () => deserialize,
   serialize: () => serialize
 });
-var fixESM2 = __require("fix-esm");
-var superjson2 = fixESM2.require("superjson");
+var fixESM = __require("fix-esm");
+var superjson = fixESM.require("superjson");
 var serialize = (data) => {
-  return superjson2.stringify(data);
+  return superjson.stringify(data);
 };
 var deserialize = (serialized) => {
   if (serialized === void 0 || serialized === null) return serialized;
-  return superjson2.parse(serialized);
+  return superjson.parse(serialized);
 };
 
 // src/setOptions.ts
@@ -697,10 +348,7 @@ var InMemoryPersistor = class {
    */
   async hSet(key, field, value) {
     const existingHash = JSON.parse(this.store.get(key) ?? "{}");
-    const isNewField = !Object.prototype.hasOwnProperty.call(
-      existingHash,
-      field
-    );
+    const isNewField = !Object.hasOwn(existingHash, field);
     existingHash[field] = value;
     this.store.set(key, JSON.stringify(existingHash));
     return isNewField ? 1 : 0;
@@ -1176,103 +824,450 @@ var InMemoryMulti = class {
    * @param key - The list key.
    * @returns The `IPersistorMulti` instance to allow method chaining.
    */
-  rPop(key) {
-    this.commands.add(() => this.persistor.rPop(key));
-    return this;
+  rPop(key) {
+    this.commands.add(() => this.persistor.rPop(key));
+    return this;
+  }
+  /**
+   * Queues an `lRange` command to retrieve a range of elements from a list.
+   * The command will be executed when `exec()` is called.
+   *
+   * @param key - The list key.
+   * @param start - The start index.
+   * @param stop - The stop index (inclusive).
+   * @returns The `IPersistorMulti` instance to allow method chaining.
+   */
+  lRange(key, start, stop) {
+    this.commands.add(() => this.persistor.lRange(key, start, stop));
+    return this;
+  }
+  /**
+   * Queues an `sAdd` command to add elements to a set.
+   * The command will be executed when `exec()` is called.
+   *
+   * @param key - The set key.
+   * @param values - The values to add.
+   * @returns The `IPersistorMulti` instance to allow method chaining.
+   */
+  sAdd(key, values) {
+    this.commands.add(() => this.persistor.sAdd(key, values));
+    return this;
+  }
+  /**
+   * Queues an `sRem` command to remove elements from a set.
+   * The command will be executed when `exec()` is called.
+   *
+   * @param key - The set key.
+   * @param values - The values to remove.
+   * @returns The `IPersistorMulti` instance to allow method chaining.
+   */
+  sRem(key, values) {
+    this.commands.add(() => this.persistor.sRem(key, values));
+    return this;
+  }
+  /**
+   * Queues an `sMembers` command to retrieve all members of a set.
+   * The command will be executed when `exec()` is called.
+   *
+   * @param key - The set key.
+   * @returns The `IPersistorMulti` instance to allow method chaining.
+   */
+  sMembers(key) {
+    this.commands.add(() => this.persistor.sMembers(key));
+    return this;
+  }
+  /**
+   * Queues a `zAdd` command to add elements to a sorted set with scores.
+   * The command will be executed when `exec()` is called.
+   *
+   * @param key - The sorted set key.
+   * @param members - An array of objects with `score` and `value`.
+   * @returns The `IPersistorMulti` instance to allow method chaining.
+   */
+  zAdd(key, members) {
+    this.commands.add(() => this.persistor.zAdd(key, members));
+    return this;
+  }
+  /**
+   * Queues a `zRange` command to retrieve a range of elements from a sorted set.
+   * The command will be executed when `exec()` is called.
+   *
+   * @param key - The sorted set key.
+   * @param start - The start index.
+   * @param stop - The stop index (inclusive).
+   * @returns The `IPersistorMulti` instance to allow method chaining.
+   */
+  zRange(key, start, stop) {
+    this.commands.add(() => this.persistor.zRange(key, start, stop));
+    return this;
+  }
+  /**
+   * Queues a `zRem` command to remove elements from a sorted set.
+   * The command will be executed when `exec()` is called.
+   *
+   * @param key - The sorted set key.
+   * @param members - The members to remove.
+   * @returns The `IPersistorMulti` instance to allow method chaining.
+   */
+  zRem(key, members) {
+    this.commands.add(() => this.persistor.zRem(key, members));
+    return this;
+  }
+  /**
+   * Executes multiple commands in a batch operation.
+   * Each command is executed in sequence, and results are collected in an array.
+   *
+   * @returns Resolves to an array containing the results of each queued command.
+   */
+  async exec() {
+    return Promise.all([...this.commands].map((cmd) => cmd()));
+  }
+};
+
+// src/persistor.ts
+import { createClient } from "redis";
+
+// src/localMemory.ts
+var LocalStorage = class {
+  client = /* @__PURE__ */ new Map();
+  isReady = false;
+  get(key) {
+    return this.client.get(key);
+  }
+  set(key, value, options) {
+    this.client.set(key, value);
+    if (options?.PX) {
+      setTimeout(() => {
+        this.client.delete(key);
+      }, options.PX);
+    }
+  }
+  del(key) {
+    this.client.delete(key);
+  }
+  clear() {
+    this.client.clear();
+  }
+  async DBSIZE() {
+    return Promise.resolve(this.client.size);
+  }
+  // This is just for testing
+  on(event, callback) {
+    if (event === "ready" && callback) {
+      this.isReady = true;
+      callback("ready");
+    }
+    return this;
+  }
+  connect() {
+    return Promise.resolve(this);
+  }
+};
+var localStorage = new LocalStorage();
+var createLocalMemoryClient = () => {
+  return localStorage;
+};
+
+// src/persistor.ts
+var fixESM2 = __require("fix-esm");
+var superjson2 = fixESM2.require("superjson");
+var CACHE_CLIENT = createClient;
+var isTestRunning = process.env.NODE_ENV === "test";
+function toMillis(seconds2) {
+  return seconds2 * 1e3;
+}
+var Persistor = class {
+  client = null;
+  clientId;
+  onError;
+  onSuccess;
+  logger;
+  redis;
+  constructor({
+    redis,
+    clientId,
+    onSuccess,
+    onError,
+    logger
+  }) {
+    this.onError = onError || (() => {
+    });
+    this.onSuccess = onSuccess || (() => {
+    });
+    this.clientId = clientId;
+    this.logger = logger;
+    if (redis && !isTestRunning) {
+      this.redis = redis;
+    } else {
+      CACHE_CLIENT = createLocalMemoryClient;
+    }
+    if (!this.client || !this.client.isReady) {
+      this.startConnection();
+    }
+  }
+  async startConnection() {
+    try {
+      await new Promise((resolve, reject) => {
+        this.client = CACHE_CLIENT({
+          url: this.redis?.url,
+          username: this.redis?.username,
+          password: this.redis?.password,
+          pingInterval: this.redis?.pingInterval || void 0,
+          socket: {
+            ...this.redis?.socket,
+            reconnectStrategy: (retries, cause) => {
+              this.logger?.error(cause);
+              return 1e3 * 2 ** retries;
+            }
+          }
+        }).on("error", (err) => {
+          this.onError(err);
+          reject(err);
+        }).on("ready", () => {
+          this.onSuccess();
+          resolve(true);
+        }).on("reconnecting", () => {
+          this.logger?.info("reconnecting...", this.clientId);
+        }).on("end", () => {
+          this.logger?.info("end...", this.clientId);
+        });
+        this.client.connect();
+      });
+    } catch (ex) {
+      this.onError(`${ex}`);
+      this.logger?.error(ex);
+    }
+  }
+  async size() {
+    if (!this.client) {
+      throw new Error("Client not initialized");
+    }
+    return await this.client.DBSIZE();
+  }
+  getClientId() {
+    return this.clientId;
+  }
+  getIsClientConnected() {
+    return !!this.client?.isReady;
+  }
+  createOptions(ttl) {
+    if (ttl !== null && ttl !== void 0 && ttl > 0) {
+      return { PX: Math.round(toMillis(ttl)) };
+    }
+    return {};
+  }
+  /**
+   * 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 }) {
+    if (!this.client || !this.client.isReady) {
+      this.logger?.error("Client not ready");
+      return;
+    }
+    try {
+      const serializedData = superjson2.stringify({
+        value,
+        ttl,
+        timestamp
+      });
+      const options = this.createOptions(ttl);
+      await this.client.set(key, serializedData, options);
+    } catch (error) {
+      this.logger?.error(`Error setting data in redis: ${error}`);
+      throw new Error(`Error setting data in redis: ${error}`);
+    }
   }
   /**
-   * Queues an `lRange` command to retrieve a range of elements from a list.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The list key.
-   * @param start - The start index.
-   * @param stop - The stop index (inclusive).
-   * @returns The `IPersistorMulti` instance to allow method chaining.
+   * Get a value from the cache.
+   * @param key Cache key.
+   * @returns GetType<T> value
    */
-  lRange(key, start, stop) {
-    this.commands.add(() => this.persistor.lRange(key, start, stop));
-    return this;
+  async get(key) {
+    if (!this.client) {
+      this.logger?.error("Client not ready");
+      return null;
+    }
+    try {
+      const data = await this.client.get(key);
+      if (!data) {
+        return null;
+      }
+      return superjson2.parse(data);
+    } catch (error) {
+      this.logger?.error(`Error getting data in redis: ${error}`);
+      throw new Error(`Error getting data from redis: ${error}`);
+    }
   }
   /**
-   * Queues an `sAdd` command to add elements to a set.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The set key.
-   * @param values - The values to add.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
+   * Delete a value from the cache.
+   * @param key Cache key
    */
-  sAdd(key, values) {
-    this.commands.add(() => this.persistor.sAdd(key, values));
-    return this;
+  async delete(key) {
+    if (!this.client || !this.client.isReady) {
+      this.logger?.error("Client not ready");
+      return;
+    }
+    try {
+      await this.client.del(key);
+    } catch (error) {
+      this.logger?.error(`Error deleting data from redis: ${error}`);
+      throw new Error(`Error deleting data from redis: ${error}`);
+    }
   }
-  /**
-   * Queues an `sRem` command to remove elements from a set.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The set key.
-   * @param values - The values to remove.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  sRem(key, values) {
-    this.commands.add(() => this.persistor.sRem(key, values));
-    return this;
+};
+
+// src/promiseCache.ts
+import { randomUUID } from "crypto";
+var persistors = {};
+var getPersistor = ({
+  redis,
+  logger,
+  onError,
+  onSuccess,
+  clientId
+}) => {
+  const connectionName = redis ? redis?.name || "default" : "local";
+  if (!persistors[connectionName]) {
+    persistors[connectionName] = new Persistor({
+      redis,
+      onError: (error) => {
+        onError?.(error);
+        logger?.error(
+          `\u274C REDIS | Client Error | ${connectionName} | ${redis?.url}: ${error}`
+        );
+      },
+      onSuccess: () => {
+        onSuccess?.();
+        logger?.info(
+          `\u{1F4E6} REDIS | Connection Ready | ${connectionName} | ${redis?.url}`
+        );
+      },
+      clientId,
+      logger
+    });
   }
+  return persistors[connectionName];
+};
+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;
   /**
-   * Queues an `sMembers` command to retrieve all members of a set.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The set key.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
+   * Initialize a new PromiseCache.
+   * @param ttlInSeconds Default cache TTL.
+   * @param caseSensitive Set to true if you want to differentiate between keys with different casing.
    */
-  sMembers(key) {
-    this.commands.add(() => this.persistor.sMembers(key));
-    return this;
+  constructor({
+    ttlInSeconds,
+    caseSensitive = false,
+    redis,
+    fallbackToFunction = false,
+    onSuccess,
+    onError,
+    logger
+  }) {
+    this.logger = logger;
+    this.persistor = getPersistor({
+      redis,
+      onError,
+      onSuccess,
+      clientId: this.clientId,
+      logger: this.logger
+    });
+    this.caseSensitive = caseSensitive;
+    this.fallbackToFunction = fallbackToFunction;
+    if (ttlInSeconds) {
+      this.ttl = ttlInSeconds;
+    }
   }
   /**
-   * Queues a `zAdd` command to add elements to a sorted set with scores.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The sorted set key.
-   * @param members - An array of objects with `score` and `value`.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
+   * Cache size.
+   * @returns The number of entries in the cache.
    */
-  zAdd(key, members) {
-    this.commands.add(() => this.persistor.zAdd(key, members));
-    return this;
+  async size() {
+    return await this.persistor.size();
   }
   /**
-   * Queues a `zRange` command to retrieve a range of elements from a sorted set.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The sorted set key.
-   * @param start - The start index.
-   * @param stop - The stop index (inclusive).
-   * @returns The `IPersistorMulti` instance to allow method chaining.
+   * Override a value in the cache.
+   * @param key Cache key.
+   * @param value Cache value.
+   * @param ttlInSeconds Time to live in seconds.
    */
-  zRange(key, start, stop) {
-    this.commands.add(() => this.persistor.zRange(key, start, stop));
-    return this;
+  async override(key, value, ttlInSeconds) {
+    const effectiveKey = this.caseSensitive ? key : key.toLowerCase();
+    const effectiveTTL = ttlInSeconds !== void 0 ? ttlInSeconds : this.ttl;
+    await this.persistor.set(effectiveKey, {
+      value,
+      timestamp: Date.now(),
+      ttl: effectiveTTL
+    });
   }
   /**
-   * Queues a `zRem` command to remove elements from a sorted set.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The sorted set key.
-   * @param members - The members to remove.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
+   * Get a value from the cache.
+   * @param key Cache key.
    */
-  zRem(key, members) {
-    this.commands.add(() => this.persistor.zRem(key, members));
-    return this;
+  async find(key) {
+    const result = await this.persistor.get(key);
+    return result?.value ?? null;
   }
   /**
-   * Executes multiple commands in a batch operation.
-   * Each command is executed in sequence, and results are collected in an array.
-   *
-   * @returns Resolves to an array containing the results of each queued command.
+   * A 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.
    */
-  async exec() {
-    return Promise.all([...this.commands].map((cmd) => cmd()));
+  async wrap(key, delegate, ttlInSeconds, ttlKeyInSeconds) {
+    const now = Date.now();
+    const effectiveKey = this.caseSensitive ? key : key.toLowerCase();
+    let effectiveTTL = ttlInSeconds ?? this.ttl;
+    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;
+      }
+      this.logger?.error(
+        "redis error, falling back to function execution",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    const response = await delegate();
+    if (ttlKeyInSeconds) {
+      const responseDict = response;
+      const responseTTL = Number(responseDict[ttlKeyInSeconds]);
+      effectiveTTL = responseTTL || 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;
   }
 };