@sebspark/promise-cache 3.3.2 → 3.4.0

package/dist/index.js

@@ -18,12 +18,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
+  InMemoryPersistor: () => InMemoryPersistor,
   Persistor: () => Persistor,
-  PromiseCache: () => PromiseCache
+  PromiseCache: () => PromiseCache,
+  createCache: () => createCache,
+  time: () => time_exports
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/promiseCache.ts
 var import_node_crypto = require("crypto");
@@ -40,7 +43,7 @@ var LocalStorage = class {
   }
   set(key, value, options) {
     this.client.set(key, value);
-    if (options == null ? void 0 : options.PX) {
+    if (options?.PX) {
       setTimeout(() => {
         this.client.delete(key);
       }, options.PX);
@@ -77,8 +80,8 @@ var fixESM = require("fix-esm");
 var superjson = fixESM.require("superjson");
 var CACHE_CLIENT = import_redis.createClient;
 var isTestRunning = process.env.NODE_ENV === "test";
-function toMillis(seconds) {
-  return seconds * 1e3;
+function toMillis(seconds2) {
+  return seconds2 * 1e3;
 }
 var Persistor = class {
   client = null;
@@ -110,17 +113,15 @@ var Persistor = class {
     }
   }
   async startConnection() {
-    var _a;
     try {
       await new Promise((resolve, reject) => {
-        var _a2, _b, _c, _d, _e;
         this.client = CACHE_CLIENT({
-          url: (_a2 = this.redis) == null ? void 0 : _a2.url,
-          username: (_b = this.redis) == null ? void 0 : _b.username,
-          password: (_c = this.redis) == null ? void 0 : _c.password,
-          pingInterval: ((_d = this.redis) == null ? void 0 : _d.pingInterval) || void 0,
+          url: this.redis?.url,
+          username: this.redis?.username,
+          password: this.redis?.password,
+          pingInterval: this.redis?.pingInterval || void 0,
           socket: {
-            ...(_e = this.redis) == null ? void 0 : _e.socket,
+            ...this.redis?.socket,
             reconnectStrategy: (retries, cause) => {
               console.error(cause);
               return 1e3 * 2 ** retries;
@@ -133,17 +134,15 @@ var Persistor = class {
           this.onSuccess();
           resolve(true);
         }).on("reconnecting", () => {
-          var _a3;
-          (_a3 = this.logger) == null ? void 0 : _a3.info("reconnecting...", this.clientId);
+          this.logger?.info("reconnecting...", this.clientId);
         }).on("end", () => {
-          var _a3;
-          (_a3 = this.logger) == null ? void 0 : _a3.info("end...", this.clientId);
+          this.logger?.info("end...", this.clientId);
         });
         this.client.connect();
       });
     } catch (ex) {
       this.onError(`${ex}`);
-      (_a = this.logger) == null ? void 0 : _a.error(ex);
+      this.logger?.error(ex);
     }
   }
   async size() {
@@ -156,8 +155,7 @@ var Persistor = class {
     return this.clientId;
   }
   getIsClientConnected() {
-    var _a;
-    return !!((_a = this.client) == null ? void 0 : _a.isReady);
+    return !!this.client?.isReady;
   }
   createOptions(ttl) {
     if (ttl !== null && ttl !== void 0) {
@@ -173,9 +171,8 @@ var Persistor = class {
    * @param object.timestamp Timestamp
    */
   async set(key, { value, timestamp = Date.now(), ttl }) {
-    var _a, _b;
     if (!this.client || !this.client.isReady) {
-      (_a = this.logger) == null ? void 0 : _a.error("Client not ready");
+      this.logger?.error("Client not ready");
       return;
     }
     try {
@@ -187,7 +184,7 @@ var Persistor = class {
       const options = this.createOptions(ttl);
       await this.client.set(key, serializedData, options);
     } catch (error) {
-      (_b = this.logger) == null ? void 0 : _b.error(`Error setting data in redis: ${error}`);
+      this.logger?.error(`Error setting data in redis: ${error}`);
       throw new Error(`Error setting data in redis: ${error}`);
     }
   }
@@ -197,9 +194,8 @@ var Persistor = class {
    * @returns GetType<T> value
    */
   async get(key) {
-    var _a, _b;
     if (!this.client) {
-      (_a = this.logger) == null ? void 0 : _a.error("Client not ready");
+      this.logger?.error("Client not ready");
       return null;
     }
     try {
@@ -209,7 +205,7 @@ var Persistor = class {
       }
       return superjson.parse(data);
     } catch (error) {
-      (_b = this.logger) == null ? void 0 : _b.error(`Error getting data in redis: ${error}`);
+      this.logger?.error(`Error getting data in redis: ${error}`);
       throw new Error(`Error getting data from redis: ${error}`);
     }
   }
@@ -218,15 +214,14 @@ var Persistor = class {
    * @param key Cache key
    */
   async delete(key) {
-    var _a, _b;
     if (!this.client || !this.client.isReady) {
-      (_a = this.logger) == null ? void 0 : _a.error("Client not ready");
+      this.logger?.error("Client not ready");
       return;
     }
     try {
       await this.client.del(key);
     } catch (error) {
-      (_b = this.logger) == null ? void 0 : _b.error(`Error deleting data from redis: ${error}`);
+      this.logger?.error(`Error deleting data from redis: ${error}`);
       throw new Error(`Error deleting data from redis: ${error}`);
     }
   }
@@ -241,20 +236,20 @@ var getPersistor = ({
   onSuccess,
   clientId
 }) => {
-  const connectionName = redis ? (redis == null ? void 0 : redis.name) || "default" : "local";
+  const connectionName = redis ? redis?.name || "default" : "local";
   if (!persistors[connectionName]) {
     persistors[connectionName] = new Persistor({
       redis,
       onError: (error) => {
-        onError == null ? void 0 : onError(error);
-        logger == null ? void 0 : logger.error(
-          `\u274C REDIS | Client Error | ${connectionName} | ${redis == null ? void 0 : redis.url}: ${error}`
+        onError?.(error);
+        logger?.error(
+          `\u274C REDIS | Client Error | ${connectionName} | ${redis?.url}: ${error}`
         );
       },
       onSuccess: () => {
-        onSuccess == null ? void 0 : onSuccess();
-        logger == null ? void 0 : logger.info(
-          `\u{1F4E6} REDIS | Connection Ready | ${connectionName} | ${redis == null ? void 0 : redis.url}`
+        onSuccess?.();
+        logger?.info(
+          `\u{1F4E6} REDIS | Connection Ready | ${connectionName} | ${redis?.url}`
         );
       },
       clientId,
@@ -291,7 +286,7 @@ var PromiseCache = class {
     });
     this.caseSensitive = caseSensitive;
     if (ttlInSeconds) {
-      this.ttl = ttlInSeconds * 1e3;
+      this.ttl = ttlInSeconds;
     }
   }
   /**
@@ -322,7 +317,7 @@ var PromiseCache = class {
    */
   async find(key) {
     const result = await this.persistor.get(key);
-    return (result == null ? void 0 : result.value) ?? null;
+    return result?.value ?? null;
   }
   /**
    * A simple promise cache wrapper.
@@ -335,7 +330,7 @@ var PromiseCache = class {
   async wrap(key, delegate, ttlInSeconds, ttlKeyInSeconds) {
     const now = Date.now();
     const effectiveKey = this.caseSensitive ? key : key.toLowerCase();
-    let effectiveTTL = ttlInSeconds !== void 0 ? ttlInSeconds * 1e3 : this.ttl;
+    let effectiveTTL = ttlInSeconds ?? this.ttl;
     const cached = await this.persistor.get(effectiveKey);
     if (cached) {
       if (!ttlKeyInSeconds && cached.ttl !== effectiveTTL) {
@@ -348,7 +343,7 @@ var PromiseCache = class {
     const response = await delegate();
     if (ttlKeyInSeconds) {
       const responseDict = response;
-      const responseTTL = Number(responseDict[ttlKeyInSeconds]) * 1e3;
+      const responseTTL = Number(responseDict[ttlKeyInSeconds]);
       effectiveTTL = responseTTL || effectiveTTL;
     }
     this.persistor.set(effectiveKey, {
@@ -359,8 +354,260 @@ var PromiseCache = class {
     return response;
   }
 };
+
+// src/serializer.ts
+var fixESM2 = require("fix-esm");
+var superjson2 = fixESM2.require("superjson");
+var serialize = (data) => {
+  return superjson2.stringify(data);
+};
+var deserialize = (serialized) => {
+  if (serialized === void 0 || serialized === null) return serialized;
+  return superjson2.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 {
+            const cached = await persistor.get(key);
+            if (cached !== null) {
+              return deserialize(cached);
+            }
+            const result = await delegate(...args);
+            const expiry = typeof options.expiry === "function" ? options.expiry(args, result) : options.expiry;
+            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;
+};
+
+// 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();
+  }
+  /**
+   * 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) {
+    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";
+  }
+  /**
+   * 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 false;
+    this.setExpiration(key, seconds2 * 1e3);
+    return true;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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";
+  }
+  /**
+   * 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);
+    }
+  }
+};
+
+// src/time.ts
+var time_exports = {};
+__export(time_exports, {
+  DAY: () => DAY,
+  HOUR: () => HOUR,
+  MINUTE: () => MINUTE,
+  SECOND: () => SECOND,
+  WEEK: () => WEEK,
+  add: () => import_date_fns.add,
+  days: () => days,
+  hours: () => hours,
+  minutes: () => minutes,
+  seconds: () => seconds,
+  weeks: () => weeks
+});
+var import_date_fns = require("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;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  InMemoryPersistor,
   Persistor,
-  PromiseCache
+  PromiseCache,
+  createCache,
+  time
 });