@sebspark/promise-cache 6.1.2 → 6.2.0

package/dist/index.js

@@ -1,1323 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/serializer.ts
-var serializer_exports = {};
-__export(serializer_exports, {
-  deserialize: () => deserialize,
-  serialize: () => serialize
-});
-import superjson from "superjson";
-var serialize = (data) => {
-  return superjson.stringify(data);
-};
-var deserialize = (serialized) => {
-  if (serialized === void 0 || serialized === null) return serialized;
-  return superjson.parse(serialized);
-};
-
-// src/setOptions.ts
-var toSetOptions = (expiry) => {
-  const options = {};
-  if (expiry !== void 0) {
-    if (typeof expiry === "number") {
-      options.PX = expiry;
-    } else if (expiry instanceof Date && !Number.isNaN(expiry.getTime())) {
-      const timestamp = expiry.getTime();
-      if (timestamp > Date.now()) {
-        options.PXAT = timestamp;
-      } else {
-        options.PX = 1;
-      }
-    }
-  }
-  if (!options.PX && !options.PXAT) {
-    options.EX = 1;
-  }
-  return options;
-};
-
-// src/cache.ts
-var createCache = (persistor, prefix) => {
-  const pendingPromises = /* @__PURE__ */ new Map();
-  const cache = {
-    persistor,
-    wrap: (delegate, options) => {
-      return async (...args) => {
-        let key = typeof options.key === "string" ? options.key : options.key(...args);
-        if (prefix) {
-          key = `${prefix}:${key}`;
-        }
-        if (pendingPromises.has(key)) {
-          return pendingPromises.get(key);
-        }
-        const resultPromise = (async () => {
-          try {
-            await ensurePersistorIsReady(persistor);
-            const cached = deserialize(await persistor.get(key));
-            if (cached !== null) {
-              return cached;
-            }
-            const result = await delegate(...args);
-            const expiry = typeof options.expiry === "function" ? options.expiry(args, result) : options.expiry;
-            await ensurePersistorIsReady(persistor);
-            const serialized = serialize(result);
-            const setOptions = toSetOptions(expiry);
-            await persistor.set(key, serialized, setOptions);
-            return result;
-          } finally {
-            pendingPromises.delete(key);
-          }
-        })();
-        pendingPromises.set(key, resultPromise);
-        return resultPromise;
-      };
-    }
-  };
-  return cache;
-};
-var ensurePersistorIsReady = async (persistor) => {
-  if (persistor.isReady) {
-    return;
-  }
-  if (persistor.isOpen) {
-    await new Promise((resolve) => {
-      if (persistor.isReady) return resolve();
-      persistor.once("ready", resolve);
-      return;
-    });
-  }
-  try {
-    await persistor.connect();
-  } catch (err) {
-    if (err.message === "Socket already opened") {
-      await new Promise((resolve) => {
-        if (persistor.isReady) return resolve();
-        persistor.once("ready", resolve);
-      });
-    }
-  }
-};
-
-// src/inMemoryPersistor.ts
-var InMemoryPersistor = class {
-  /**
-   * Internal key-value store for caching string values.
-   * @private
-   */
-  store;
-  /**
-   * Tracks active timeouts for expiring keys.
-   * Each key maps to a `setTimeout` reference that deletes the key when triggered.
-   * @private
-   */
-  expirations;
-  /**
-   * Stores absolute expiration timestamps (in milliseconds since epoch) for each key.
-   * Used to compute remaining TTL.
-   * @private
-   */
-  expiryTimestamps;
-  /**
-   * Creates a new instance of `InMemoryPersistor`.
-   * Initializes an empty store, expiration map, and TTL tracker.
-   */
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
-    this.expirations = /* @__PURE__ */ new Map();
-    this.expiryTimestamps = /* @__PURE__ */ new Map();
-  }
-  async connect() {
-    return this;
-  }
-  get isReady() {
-    return true;
-  }
-  get isOpen() {
-    return true;
-  }
-  once() {
-    return this;
-  }
-  /**
-   * Stores a key-value pair with optional expiration settings.
-   * If an expiration is provided (`EX`, `PX`, `EXAT`, `PXAT`), the key is automatically removed when TTL expires.
-   *
-   * @param {string} key - The key to store.
-   * @param {string} value - The string value to associate with the key.
-   * @param {SetOptions} [options] - Optional Redis-style expiration settings.
-   * @returns {Promise<'OK' | null>} Resolves to `'OK'` on success, or `null` if a conditional set (`NX`) fails.
-   */
-  async set(key, value, options) {
-    if (options?.NX && this.store.has(key)) {
-      return null;
-    }
-    if (options?.XX && !this.store.has(key)) {
-      return null;
-    }
-    this.store.set(key, value);
-    if (options?.EX !== void 0) {
-      this.setExpiration(key, options.EX * 1e3);
-    } else if (options?.PX !== void 0) {
-      this.setExpiration(key, options.PX);
-    } else if (options?.EXAT !== void 0) {
-      const timeToExpire = options.EXAT * 1e3 - Date.now();
-      this.setExpiration(key, Math.max(0, timeToExpire));
-    } else if (options?.PXAT !== void 0) {
-      const timeToExpire = options.PXAT - Date.now();
-      this.setExpiration(key, Math.max(0, timeToExpire));
-    }
-    return "OK";
-  }
-  /**
-   * Stores a key-value pair with an expiration time in seconds.
-   * If the key already exists, it will be overwritten.
-   *
-   * @param key - The storage key.
-   * @param seconds - Expiration time in seconds.
-   * @param value - The string value to store.
-   * @returns Resolves to `'OK'` on success.
-   */
-  async setEx(key, seconds2, value) {
-    this.store.set(key, value);
-    await this.expire(key, seconds2);
-    return "OK";
-  }
-  /**
-   * Stores a key-value pair with an expiration time in milliseconds.
-   * If the key already exists, it will be overwritten.
-   *
-   * @param key - The storage key.
-   * @param milliseconds - Expiration time in milliseconds.
-   * @param value - The string value to store.
-   * @returns Resolves to `'OK'` on success.
-   */
-  async pSetEx(key, milliseconds, value) {
-    return this.setEx(key, milliseconds / 1e3, value);
-  }
-  /**
-   * Stores a key-value pair **only if the key does not already exist**.
-   * If the key exists, the operation fails and returns `false`.
-   *
-   * @param key - The storage key.
-   * @param value - The string value to store.
-   * @returns Resolves to `true` if the key was set, or `false` if the key already exists.
-   */
-  async setNX(key, value) {
-    if (this.store.has(key)) return 0;
-    this.store.set(key, value);
-    return 1;
-  }
-  /**
-   * Retrieves the value associated with a key.
-   *
-   * @param {string} key - The key to retrieve.
-   * @returns {Promise<string | null>} Resolves to the string value, or `null` if the key does not exist.
-   */
-  async get(key) {
-    return this.store.get(key) ?? null;
-  }
-  /**
-   * Deletes a key from the store.
-   * If the key exists, it is removed along with any associated expiration.
-   *
-   * @param {string} key - The key to delete.
-   * @returns {Promise<number>} Resolves to `1` if the key was deleted, or `0` if the key did not exist.
-   */
-  async del(key) {
-    const existed = this.store.has(key);
-    if (existed) {
-      this.store.delete(key);
-      this.clearExpiration(key);
-    }
-    return existed ? 1 : 0;
-  }
-  /**
-   * Sets a time-to-live (TTL) in seconds for a key.
-   * If the key exists, it will be deleted after the specified duration.
-   *
-   * @param {string} key - The key to set an expiration on.
-   * @param {number} seconds - The TTL in seconds.
-   * @returns {Promise<number>} Resolves to `1` if the TTL was set, or `0` if the key does not exist.
-   */
-  async expire(key, seconds2) {
-    if (!this.store.has(key)) return 0;
-    this.setExpiration(key, seconds2 * 1e3);
-    return 1;
-  }
-  /**
-   * Retrieves the remaining time-to-live (TTL) of a key in seconds.
-   *
-   * @param {string} key - The key to check.
-   * @returns {Promise<number>} Resolves to:
-   *   - Remaining TTL in **seconds** if the key exists and has an expiration.
-   *   - `-1` if the key exists but has no expiration.
-   *   - `-2` if the key does not exist.
-   */
-  async ttl(key) {
-    if (!this.store.has(key)) return -2;
-    if (!this.expiryTimestamps.has(key)) return -1;
-    const timeLeft = this.expiryTimestamps.get(key) - Date.now();
-    return timeLeft > 0 ? Math.ceil(timeLeft / 1e3) : -2;
-  }
-  /**
-   * Checks if one or more keys exist in the store.
-   *
-   * @param {string | string[]} keys - A single key or an array of keys to check.
-   * @returns {Promise<number>} Resolves to the number of keys that exist.
-   */
-  async exists(keys) {
-    const keyArray = Array.isArray(keys) ? keys : [keys];
-    return keyArray.reduce(
-      (count, key) => this.store.has(key) ? count + 1 : count,
-      0
-    );
-  }
-  /**
-   * Increments a numeric value stored at a key by 1.
-   * If the key does not exist, it is set to `1`.
-   *
-   * @param {string} key - The key to increment.
-   * @returns {Promise<number>} Resolves to the new value after increment.
-   */
-  async incr(key) {
-    const current = Number(this.store.get(key)) || 0;
-    const newValue = current + 1;
-    this.store.set(key, newValue.toString());
-    return newValue;
-  }
-  /**
-   * Increments a numeric value stored at a key by a specified amount.
-   * If the key does not exist, it is set to the increment value.
-   *
-   * @param {string} key - The key to increment.
-   * @param {number} increment - The amount to increase by.
-   * @returns {Promise<number>} Resolves to the new value after increment.
-   */
-  async incrBy(key, increment) {
-    const current = Number(this.store.get(key)) || 0;
-    const newValue = current + increment;
-    this.store.set(key, newValue.toString());
-    return newValue;
-  }
-  /**
-   * Decrements a numeric value stored at a key by 1.
-   * If the key does not exist, it is set to `-1`.
-   *
-   * @param {string} key - The key to decrement.
-   * @returns {Promise<number>} Resolves to the new value after decrement.
-   */
-  async decr(key) {
-    const current = Number(this.store.get(key)) || 0;
-    const newValue = current - 1;
-    this.store.set(key, newValue.toString());
-    return newValue;
-  }
-  /**
-   * Decrements a numeric value stored at a key by a specified amount.
-   * If the key does not exist, it is set to the negative decrement value.
-   *
-   * @param {string} key - The key to decrement.
-   * @param {number} decrement - The amount to decrease by.
-   * @returns {Promise<number>} Resolves to the new value after decrement.
-   */
-  async decrBy(key, decrement) {
-    const current = Number(this.store.get(key)) || 0;
-    const newValue = current - decrement;
-    this.store.set(key, newValue.toString());
-    return newValue;
-  }
-  /**
-   * Sets a field in a hash.
-   * If the field already exists, its value is updated.
-   *
-   * @param key - The hash key.
-   * @param field - The field name.
-   * @param value - The value to store.
-   * @returns Resolves to `1` if a new field was added, `0` if an existing field was updated.
-   */
-  async hSet(key, field, value) {
-    const existingHash = JSON.parse(this.store.get(key) ?? "{}");
-    const isNewField = !Object.hasOwn(existingHash, field);
-    existingHash[field] = value;
-    this.store.set(key, JSON.stringify(existingHash));
-    return isNewField ? 1 : 0;
-  }
-  /**
-   * Retrieves a field from a hash.
-   *
-   * @param key - The hash key.
-   * @param field - The field name to retrieve.
-   * @returns Resolves to the field value, or `null` if the field does not exist.
-   */
-  async hGet(key, field) {
-    const hash = JSON.parse(this.store.get(key) ?? "{}");
-    return hash[field] ?? null;
-  }
-  /**
-   * Pushes elements to the left (head) of a list.
-   *
-   * @param key - The list key.
-   * @param values - One or more values to add.
-   * @returns Resolves to the length of the list after the operation.
-   */
-  async lPush(key, values) {
-    const list = JSON.parse(this.store.get(key) ?? "[]");
-    const newValues = Array.isArray(values) ? values : [values];
-    const updatedList = [...newValues.reverse(), ...list];
-    this.store.set(key, JSON.stringify(updatedList));
-    return updatedList.length;
-  }
-  /**
-   * Pushes elements to the right (tail) of a list.
-   *
-   * @param key - The list key.
-   * @param values - One or more values to add.
-   * @returns Resolves to the length of the list after the operation.
-   */
-  async rPush(key, values) {
-    const list = JSON.parse(this.store.get(key) ?? "[]");
-    const newValues = Array.isArray(values) ? values : [values];
-    const updatedList = [...list, ...newValues];
-    this.store.set(key, JSON.stringify(updatedList));
-    return updatedList.length;
-  }
-  /**
-   * Removes and returns the first element from a list.
-   *
-   * @param key - The list key.
-   * @returns Resolves to the removed element, or `null` if the list is empty.
-   */
-  async lPop(key) {
-    const list = JSON.parse(this.store.get(key) ?? "[]");
-    if (list.length === 0) return null;
-    const value = list.shift();
-    if (list.length > 0) {
-      this.store.set(key, JSON.stringify(list));
-    } else {
-      this.store.delete(key);
-    }
-    return value;
-  }
-  /**
-   * Removes and returns the last element from a list.
-   *
-   * @param key - The list key.
-   * @returns Resolves to the removed element, or `null` if the list is empty.
-   */
-  async rPop(key) {
-    const list = JSON.parse(this.store.get(key) ?? "[]");
-    if (list.length === 0) return null;
-    const value = list.pop();
-    if (list.length > 0) {
-      this.store.set(key, JSON.stringify(list));
-    } else {
-      this.store.delete(key);
-    }
-    return value;
-  }
-  /**
-   * Retrieves a range of elements from a list.
-   *
-   * @param key - The list key.
-   * @param start - The starting index.
-   * @param stop - The stopping index.
-   * @returns Resolves to an array containing the requested range.
-   */
-  async lRange(key, start, stop) {
-    const list = JSON.parse(this.store.get(key) ?? "[]");
-    const normalizedStop = stop === -1 ? list.length : stop + 1;
-    return list.slice(start, normalizedStop);
-  }
-  /**
-   * Adds elements to a set.
-   *
-   * @param key - The set key.
-   * @param values - One or more values to add.
-   * @returns Resolves to the number of new elements added.
-   */
-  async sAdd(key, values) {
-    const set = new Set(JSON.parse(this.store.get(key) ?? "[]"));
-    const newValues = Array.isArray(values) ? values : [values];
-    const initialSize = set.size;
-    for (const value of newValues) {
-      set.add(value);
-    }
-    this.store.set(key, JSON.stringify([...set]));
-    return set.size - initialSize;
-  }
-  /**
-   * Removes elements from a set.
-   *
-   * @param key - The set key.
-   * @param values - One or more values to remove.
-   * @returns Resolves to the number of elements removed.
-   */
-  async sRem(key, values) {
-    const set = new Set(JSON.parse(this.store.get(key) ?? "[]"));
-    const valuesToRemove = Array.isArray(values) ? values : [values];
-    const initialSize = set.size;
-    for (const value of valuesToRemove) {
-      set.delete(value);
-    }
-    this.store.set(key, JSON.stringify([...set]));
-    return initialSize - set.size;
-  }
-  /**
-   * Retrieves all elements from a set.
-   *
-   * @param key - The set key.
-   * @returns Resolves to an array of all set members.
-   */
-  async sMembers(key) {
-    return JSON.parse(this.store.get(key) ?? "[]");
-  }
-  /**
-   * Adds members to a sorted set with scores.
-   *
-   * @param key - The sorted set key.
-   * @param members - An array of objects containing `{ score, value }`.
-   * @returns Resolves to the number of new elements added.
-   */
-  async zAdd(key, members) {
-    const sortedSet = JSON.parse(
-      this.store.get(key) ?? "[]"
-    );
-    const initialSize = sortedSet.length;
-    for (const { score, value } of members) {
-      const existingIndex = sortedSet.findIndex(
-        (entry) => entry.value === value
-      );
-      if (existingIndex !== -1) {
-        sortedSet[existingIndex].score = score;
-      } else {
-        sortedSet.push({ score, value });
-      }
-    }
-    sortedSet.sort((a, b) => a.score - b.score);
-    this.store.set(key, JSON.stringify(sortedSet));
-    return sortedSet.length - initialSize;
-  }
-  /**
-   * Retrieves a range of elements from a sorted set.
-   *
-   * @param key - The sorted set key.
-   * @param start - The starting index.
-   * @param stop - The stopping index.
-   * @returns Resolves to an array of sorted set values in the range.
-   */
-  async zRange(key, start, stop) {
-    const sortedSet = JSON.parse(
-      this.store.get(key) ?? "[]"
-    );
-    const normalizedStop = stop === -1 ? sortedSet.length : stop + 1;
-    return sortedSet.slice(start, normalizedStop).map((entry) => entry.value);
-  }
-  /**
-   * Removes elements from a sorted set.
-   *
-   * @param key - The sorted set key.
-   * @param members - One or more values to remove.
-   * @returns Resolves to the number of elements removed.
-   */
-  async zRem(key, members) {
-    const sortedSet = JSON.parse(
-      this.store.get(key) ?? "[]"
-    );
-    const valuesToRemove = Array.isArray(members) ? members : [members];
-    const initialSize = sortedSet.length;
-    this.store.set(
-      key,
-      JSON.stringify(
-        sortedSet.filter((entry) => !valuesToRemove.includes(entry.value))
-      )
-    );
-    return initialSize - JSON.parse(this.store.get(key) ?? "[]").length;
-  }
-  /**
-   * Removes all keys from the store and clears all active expirations.
-   *
-   * @returns {Promise<'OK'>} Resolves to `'OK'` after all data is cleared.
-   */
-  async flushAll() {
-    this.store.clear();
-    for (const timeout of this.expirations.values()) {
-      clearTimeout(timeout);
-    }
-    this.expirations.clear();
-    this.expiryTimestamps.clear();
-    return "OK";
-  }
-  /**
-   * Creates a new multi-command batch instance.
-   * Commands queued in this batch will be executed together when `exec()` is called.
-   *
-   * @returns A new `IPersistorMulti` instance for batching commands.
-   */
-  multi() {
-    return new InMemoryMulti(this);
-  }
-  /**
-   * Sets an expiration timeout for a key.
-   * Cancels any existing expiration before setting a new one.
-   *
-   * @private
-   * @param {string} key - The key to expire.
-   * @param {number} ttlMs - Time-to-live in milliseconds.
-   */
-  setExpiration(key, ttlMs) {
-    this.clearExpiration(key);
-    const expiryTimestamp = Date.now() + ttlMs;
-    this.expiryTimestamps.set(key, expiryTimestamp);
-    const timeout = setTimeout(() => {
-      this.store.delete(key);
-      this.expirations.delete(key);
-      this.expiryTimestamps.delete(key);
-    }, ttlMs);
-    this.expirations.set(key, timeout);
-  }
-  /**
-   * Cancels an active expiration timeout for a key and removes its TTL record.
-   *
-   * @private
-   * @param {string} key - The key whose expiration should be cleared.
-   */
-  clearExpiration(key) {
-    if (this.expirations.has(key)) {
-      clearTimeout(this.expirations.get(key));
-      this.expirations.delete(key);
-      this.expiryTimestamps.delete(key);
-    }
-  }
-};
-var InMemoryMulti = class {
-  persistor;
-  commands = /* @__PURE__ */ new Set();
-  constructor(persistor) {
-    this.persistor = persistor;
-  }
-  /**
-   * Queues a `SET` command to store a key-value pair with optional expiration settings.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The storage key.
-   * @param value - The string value to store.
-   * @param options - Optional expiration settings.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  set(key, value, options) {
-    this.commands.add(() => this.persistor.set(key, value, options));
-    return this;
-  }
-  /**
-   * Queues a `SETEX` command to store a key-value pair with an expiration time in seconds.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The storage key.
-   * @param seconds - Expiration time in seconds.
-   * @param value - The string value to store.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  setEx(key, seconds2, value) {
-    this.commands.add(() => this.persistor.setEx(key, seconds2, value));
-    return this;
-  }
-  /**
-   * Queues a `PSETEX` command to store a key-value pair with an expiration time in milliseconds.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The storage key.
-   * @param milliseconds - Expiration time in milliseconds.
-   * @param value - The string value to store.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  pSetEx(key, milliseconds, value) {
-    this.commands.add(() => this.persistor.pSetEx(key, milliseconds, value));
-    return this;
-  }
-  /**
-   * Queues a `SETNX` command to store a key-value pair **only if the key does not already exist**.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The storage key.
-   * @param value - The string value to store.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  setNX(key, value) {
-    this.commands.add(() => this.persistor.setNX(key, value));
-    return this;
-  }
-  /**
-   * Queues a `GET` command to retrieve the value associated with a key.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The storage key to retrieve.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  get(key) {
-    this.commands.add(() => this.persistor.get(key));
-    return this;
-  }
-  /**
-   * Queues a `DEL` command to delete a key from the store.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The storage key to delete.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  del(key) {
-    this.commands.add(() => this.persistor.del(key));
-    return this;
-  }
-  /**
-   * Queues an `EXPIRE` command to set a time-to-live (TTL) in seconds for a key.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The storage key.
-   * @param seconds - TTL in seconds.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  expire(key, seconds2) {
-    this.commands.add(() => this.persistor.expire(key, seconds2));
-    return this;
-  }
-  /**
-   * Queues a `TTL` command to get the remaining time-to-live (TTL) of a key in seconds.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The storage key to check.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  ttl(key) {
-    this.commands.add(() => this.persistor.ttl(key));
-    return this;
-  }
-  /**
-   * Queues an `exists` operation in the batch.
-   * @param key - The key(s) to check existence.
-   * @returns The multi instance for method chaining.
-   */
-  exists(key) {
-    this.commands.add(() => this.persistor.exists(key));
-    return this;
-  }
-  /**
-   * Queues an `incr` operation in the batch.
-   * @param key - The key to increment.
-   * @returns The multi instance for method chaining.
-   */
-  incr(key) {
-    this.commands.add(() => this.persistor.incr(key));
-    return this;
-  }
-  /**
-   * Queues an `incrBy` operation in the batch.
-   * @param key - The key to increment.
-   * @param increment - The amount to increment by.
-   * @returns The multi instance for method chaining.
-   */
-  incrBy(key, increment) {
-    this.commands.add(() => this.persistor.incrBy(key, increment));
-    return this;
-  }
-  /**
-   * Queues a `decr` operation in the batch.
-   * @param key - The key to decrement.
-   * @returns The multi instance for method chaining.
-   */
-  decr(key) {
-    this.commands.add(() => this.persistor.decr(key));
-    return this;
-  }
-  /**
-   * Queues a `decrBy` operation in the batch.
-   * @param key - The key to decrement.
-   * @param decrement - The amount to decrement by.
-   * @returns The multi instance for method chaining.
-   */
-  decrBy(key, decrement) {
-    this.commands.add(() => this.persistor.decrBy(key, decrement));
-    return this;
-  }
-  /**
-   * Queues a `flushAll` operation in the batch.
-   * @returns The multi instance for method chaining.
-   */
-  flushAll() {
-    this.commands.add(() => this.persistor.flushAll());
-    return this;
-  }
-  /**
-   * Queues an `hSet` command to store a field-value pair in a hash.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The hash key.
-   * @param field - The field name.
-   * @param value - The value to store.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  hSet(key, field, value) {
-    this.commands.add(() => this.persistor.hSet(key, field, value));
-    return this;
-  }
-  /**
-   * Queues an `hGet` command to retrieve a field value from a hash.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The hash key.
-   * @param field - The field to retrieve.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  hGet(key, field) {
-    this.commands.add(() => this.persistor.hGet(key, field));
-    return this;
-  }
-  /**
-   * Queues an `lPush` command to add elements to the left (head) of a list.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The list key.
-   * @param values - The values to add.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  lPush(key, values) {
-    this.commands.add(() => this.persistor.lPush(key, values));
-    return this;
-  }
-  /**
-   * Queues an `rPush` command to add elements to the right (tail) of a list.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The list key.
-   * @param values - The values to add.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  rPush(key, values) {
-    this.commands.add(() => this.persistor.rPush(key, values));
-    return this;
-  }
-  /**
-   * Queues an `lPop` command to remove and return the first element of a list.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The list key.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  lPop(key) {
-    this.commands.add(() => this.persistor.lPop(key));
-    return this;
-  }
-  /**
-   * Queues an `rPop` command to remove and return the last element of a list.
-   * The command will be executed when `exec()` is called.
-   *
-   * @param key - The list key.
-   * @returns The `IPersistorMulti` instance to allow method chaining.
-   */
-  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 { getLogger } from "@sebspark/otel";
-import { createClient } from "redis";
-import superjson2 from "superjson";
-
-// 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 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,
-    redisClient,
-    clientId,
-    onSuccess,
-    onError
-  }) {
-    this.logger = getLogger("Persistor");
-    this.logger.warn(
-      "Persistor class is deprecated. Use InMemoryPersistor or redis: createClient instead"
-    );
-    this.onError = onError || (() => {
-    });
-    this.onSuccess = onSuccess || (() => {
-    });
-    this.clientId = clientId;
-    if (redisClient) {
-      this.client = redisClient;
-    } else 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 (err) {
-      this.onError(`${err}`);
-      this.logger.error(err);
-    }
-  }
-  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}`);
-    }
-  }
-  /**
-   * 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 superjson2.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
-import { randomUUID } from "crypto";
-import { getLogger as getLogger2 } from "@sebspark/otel";
-var persistors = {};
-var getPersistor = ({
-  redis,
-  onError,
-  onSuccess,
-  clientId
-}) => {
-  const logger = getLogger2("PromiseCache persistor");
-  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
-    });
-  }
-  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
-  }) {
-    this.logger = getLogger2("PromiseCache");
-    this.logger.warn(
-      "PromiseCache class is deprecated. Use createCache instead"
-    );
-    this.persistor = getPersistor({
-      redis,
-      onError,
-      onSuccess,
-      clientId: this.clientId
-    });
-    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
-      );
-    }
-    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/time.ts
-var time_exports = {};
-__export(time_exports, {
-  DAY: () => DAY,
-  HOUR: () => HOUR,
-  MINUTE: () => MINUTE,
-  SECOND: () => SECOND,
-  WEEK: () => WEEK,
-  add: () => add,
-  days: () => days,
-  hours: () => hours,
-  minutes: () => minutes,
-  seconds: () => seconds,
-  sub: () => sub,
-  today: () => today,
-  tomorrow: () => tomorrow,
-  weeks: () => weeks
-});
-import { add, sub } from "date-fns";
-var SECOND = 1e3;
-var MINUTE = 60 * SECOND;
-var HOUR = 60 * MINUTE;
-var DAY = 24 * HOUR;
-var WEEK = 7 * DAY;
-var seconds = (num) => num * SECOND;
-var minutes = (num) => num * MINUTE;
-var hours = (num) => num * HOUR;
-var days = (num) => num * DAY;
-var weeks = (num) => num * WEEK;
-var today = (hours2 = 0, minutes2 = 0, seconds2 = 0) => {
-  const local = /* @__PURE__ */ new Date();
-  const utc = Date.UTC(
-    local.getUTCFullYear(),
-    local.getUTCMonth(),
-    local.getUTCDate(),
-    hours2,
-    minutes2,
-    seconds2
-  );
-  return new Date(utc);
-};
-var tomorrow = (hours2 = 0, minutes2 = 0, seconds2 = 0) => add(today(hours2, minutes2, seconds2), { days: 1 });
-export {
-  InMemoryPersistor,
-  Persistor,
-  PromiseCache,
-  createCache,
-  serializer_exports as serializer,
-  time_exports as time
-};
-//# sourceMappingURL=index.js.map