@sebspark/promise-cache 4.0.3 → 5.0.1

package/README.md

@@ -18,7 +18,139 @@ yarn install @sebspark/promise-cache
 ```
 ## **Usage**
 
-### **PromiseCache Class**
+# Cache implementation
+
+The basic functionality of this new implementation is:
+
+1. You create a persistor to store your cached data. This can be the built in `InMemoryPersistor` or a `Redis` client
+2. You create a cache by calling `createCache(persistor, 'optional-prefix')`
+3. You call the cache's wrap function to wrap your original function(s)
+4. You call the wrapped function(s) instead of the originals
+
+**Why the change?**
+
+When trying to add support for caching _to_ a specified time in addition to _for_ a specified time, it tuyrned out to be hard given the original implementation. Changing the implementation proved hard without breaking changes. So a new implementation is is.
+
+## How to use it
+
+```typescript
+import { createClient } from 'redis'
+import { createCache } from '@sebspark/promise-cache'
+import { myFunction } from './some_function'
+
+const run = async () => {
+  // Create your persistor
+  const persistor = createClient({ url: 'redis' })
+  await persistor.connect() // This is not handled by the cache
+
+  // Create your cache and give it a prefix
+  const cache = createCache(persistor, 'my-prefix')
+  
+  // wrap your function
+  const myCachedFunction = cache.wrap(myFunction, {
+    key: 'my-function', // cached data will be stored with the key 'my-prefix:my-function'
+    expiry: 100, // ttl will be 100 ms
+  })
+
+  // call the wrapped function
+  const response = await myCachedFunction() // the wrapped function will have the same signature as the original
+}
+
+run()
+```
+
+### Keys
+
+Keys can be constructed in two ways: as a fixed string or as a function that generates a string. The generator will accept the arguments of the wrapped function.
+
+```typescript
+const cache = createCache(persistor, 'api')
+
+const getById = async (id: string): Promise<Data> => {
+  // Something gets called
+}
+
+const cachedGetById = cache.wrap(myApiCall, {
+  key: (id) => `getById:${id}`
+})
+
+const result = await cachedGetById('foo')
+
+// key will be 'api:getById:foo'
+```
+
+### Expiry
+
+Expiration can be set as either a number (number of milliseconds from now) or a Date (exact expiry time). It can be set either as a value (`number | Date`) or as a function that generates a value (`number | Date`). The generator will accept the arguments _and_ the response of the wrapped function.
+
+```typescript
+const cache = createCache(persistor, 'api')
+
+type Data = {
+  value: number
+  expires: string // ISO6501 date time string
+}
+
+const getById = async (id: string): Promise<Data> => {
+  // Something gets called
+}
+
+const cachedGetById = cache.wrap(myApiCall, {
+  key: (id) => `getById:${id}`,
+  expires: ([id], data) => new Date(data.expires),
+})
+
+const result = await cachedGetById('foo')
+```
+
+There are also helpers for setting time or manipulating dates
+
+```typescript
+import { createCache, time } from '@sebspark/promise-cache'
+
+const cache = createCache(persistor, 'api')
+
+type Data = {
+  value: number
+  lastUpdated: string // ISO6501 date time string. Data is updated every 30 minutes.
+}
+
+const getById = async (id: string): Promise<Data> => {
+  // Something gets called
+}
+
+// Computed from response
+const cachedGetById = cache.wrap(myApiCall, {
+  key: (id) => `getById:${id}`,
+  expires: ([id], data) => time.add(new Date(data.lastUpdated), { minutes: 30 })
+})
+
+// Fixed at 20 seconds
+const cachedGetById = cache.wrap(myApiCall, {
+  key: (id) => `getById:${id}`,
+  expires: time.seconds(100),
+})
+
+// Fixed at today 20:00:00 UTC
+const cachedGetById = cache.wrap(myApiCall, {
+  key: (id) => `getById:${id}`,
+  expires: time.today(20),
+})
+
+// Fixed at tomorrow 00:00:00
+const cachedGetById = cache.wrap(myApiCall, {
+  key: (id) => `getById:${id}`,
+  expires: time.tomorrow(),
+})
+```
+
+If expiry is not set or yields an unusable value, it will default to 1 sec.
+
+# Old implementation
+
+** Deprecated - do not use **
+
+## **PromiseCache Class**
 
 | Params             | Type                | Default   | Description                                      |
 |--------------------|---------------------|-----------|--------------------------------------------------|
@@ -47,7 +179,7 @@ const cacheLocalMemory = new PromiseCache<T>({
 })
 ```
 
-## **PromiseCache Methods**
+### **PromiseCache Methods**
 
 ```typescript
 // Wrap
@@ -94,7 +226,7 @@ const cached = cacheInRedis.find('Key')
 expect(cached).toBe(234)
 ```
 
-### **Persistor Class**
+## **Persistor Class**
 
 | Params        | Type     | Default |Description                                  |
 |---------------|----------|---------|---------------------------------------------|
@@ -116,7 +248,7 @@ const store = new Persistor<T>({
 const store = new Persistor<T>()
 ```
 
-## **Persistor Methods**
+### **Persistor Methods**
 
 ```typescript
 
@@ -164,131 +296,3 @@ expect(cached).toBe({
 await store.delete('MyKey')
 expect(await store.get('MyKey').toBe(null)
 ```
-
-# Cache implementation
-
-The basic functionality of this new implementation is:
-
-1. You create a persistor to store your cached data. This can be the built in `InMemoryPersistor` or a `Redis` client
-2. You create a cache by calling `createCache(persistor, 'optional-prefix')`
-3. You call the cache's wrap function to wrap your original function(s)
-4. You call the wrapped function(s) instead of the originals
-
-**Why the change?**
-
-When trying to add support for caching _to_ a specified time in addition to _for_ a specified time, it tuyrned out to be hard given the original implementation. Changing the implementation proved hard without breaking changes. So a new implementation is is.
-
-## How to use it
-
-```typescript
-import { createClient } from 'redis'
-import { createCache } from '@sebspark/promise-cache'
-import { myFunction } from './some_function'
-
-const run = async () => {
-  // Create your persistor
-  const persistor = createClient({ url: 'redis' })
-  await persistor.connect() // This is not handled by the cache
-
-  // Create your cache and give it a prefix
-  const cache = createCache(persistor, 'my-prefix')
-  
-  // wrap your function
-  const myCachedFunction = cache.wrap(myFunction, {
-    key: 'my-function', // cached data will be stored with the key 'my-prefix:my-function'
-    expiry: 100, // ttl will be 100 ms
-  })
-
-  // call the wrapped function
-  const response = await myCachedFunction() // the wrapped function will have the same signature as the original
-}
-
-run()
-```
-
-### Keys
-
-Keys can be constructed in two ways: as a fixed string or as a function that generates a string. The generator will accept the arguments of the wrapped function.
-
-```typescript
-const cache = createCache(persistor, 'api')
-
-const getById = async (id: string): Promise<Data> => {
-  // Something gets called
-}
-
-const cachedGetById = cache.wrap(myApiCall, {
-  key: (id) => `getById:${id}`
-})
-
-const result = await cachedGetById('foo')
-
-// key will be 'api:getById:foo'
-```
-
-### Expiry
-
-Expiration can be set as either a number (number of milliseconds from now) or a Date (exact expiry time). It can be set either as a value (`number | Date`) or as a function that generates a value (`number | Date`). The generator will accept the arguments _and_ the response of the wrapped function.
-
-```typescript
-const cache = createCache(persistor, 'api')
-
-type Data = {
-  value: number
-  expires: string // ISO6501 date time string
-}
-
-const getById = async (id: string): Promise<Data> => {
-  // Something gets called
-}
-
-const cachedGetById = cache.wrap(myApiCall, {
-  key: (id) => `getById:${id}`,
-  expires: ([id], data) => new Date(data.expires),
-})
-
-const result = await cachedGetById('foo')
-```
-
-There are also helpers for setting time or manipulating dates
-
-```typescript
-import { createCache, time } from '@sebspark/promise-cache'
-
-const cache = createCache(persistor, 'api')
-
-type Data = {
-  value: number
-  lastUpdated: string // ISO6501 date time string. Data is updated every 30 minutes.
-}
-
-const getById = async (id: string): Promise<Data> => {
-  // Something gets called
-}
-
-// Computed from response
-const cachedGetById = cache.wrap(myApiCall, {
-  key: (id) => `getById:${id}`,
-  expires: ([id], data) => time.add(new Date(data.lastUpdated), { minutes: 30 })
-})
-
-// Fixed at 20 seconds
-const cachedGetById = cache.wrap(myApiCall, {
-  key: (id) => `getById:${id}`,
-  expires: time.seconds(100),
-})
-
-// Fixed at today 20:00:00 UTC
-const cachedGetById = cache.wrap(myApiCall, {
-  key: (id) => `getById:${id}`,
-  expires: time.today(20),
-})
-
-// Fixed at tomorrow 00:00:00
-const cachedGetById = cache.wrap(myApiCall, {
-  key: (id) => `getById:${id}`,
-  expires: time.tomorrow(),
-})
-```
-
-If expiry is not set or yields an unusable value, it will default to 1 sec.

package/dist/index.d.mts

@@ -1,7 +1,6 @@
 import { SetOptions, RedisClientOptions, createClient } from 'redis';
 export { RedisClientOptions } from 'redis';
 import { UUID } from 'node:crypto';
-import { Logger } from 'winston';
 import { add, sub } from 'date-fns';
 
 type MultiExecReturnTypes = string[] | string | number | boolean | null | undefined;
@@ -768,7 +767,6 @@ type PersistorConstructorType = {
     clientId?: UUID;
     onError?: (error: string) => void;
     onSuccess?: () => void;
-    logger?: Logger;
 };
 declare class Persistor {
     client: ReturnType<typeof createClient> | null;
@@ -777,7 +775,7 @@ declare class Persistor {
     private readonly onSuccess;
     private readonly logger;
     private readonly redis?;
-    constructor({ redis, clientId, onSuccess, onError, logger, }: PersistorConstructorType);
+    constructor({ redis, clientId, onSuccess, onError, }: PersistorConstructorType);
     startConnection(): Promise<void>;
     size(): Promise<number>;
     getClientId(): UUID | undefined;
@@ -811,7 +809,6 @@ type PromiseCacheOptions = {
     fallbackToFunction?: boolean;
     onError?: (error: string) => void;
     onSuccess?: () => void;
-    logger?: Logger;
 };
 declare class PromiseCache<U> {
     persistor: Persistor;
@@ -825,7 +822,7 @@ 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, fallbackToFunction, onSuccess, onError, logger, }: PromiseCacheOptions);
+    constructor({ ttlInSeconds, caseSensitive, redis, fallbackToFunction, onSuccess, onError, }: PromiseCacheOptions);
     /**
      * Cache size.
      * @returns The number of entries in the cache.

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 import { SetOptions, RedisClientOptions, createClient } from 'redis';
 export { RedisClientOptions } from 'redis';
 import { UUID } from 'node:crypto';
-import { Logger } from 'winston';
 import { add, sub } from 'date-fns';
 
 type MultiExecReturnTypes = string[] | string | number | boolean | null | undefined;
@@ -768,7 +767,6 @@ type PersistorConstructorType = {
     clientId?: UUID;
     onError?: (error: string) => void;
     onSuccess?: () => void;
-    logger?: Logger;
 };
 declare class Persistor {
     client: ReturnType<typeof createClient> | null;
@@ -777,7 +775,7 @@ declare class Persistor {
     private readonly onSuccess;
     private readonly logger;
     private readonly redis?;
-    constructor({ redis, clientId, onSuccess, onError, logger, }: PersistorConstructorType);
+    constructor({ redis, clientId, onSuccess, onError, }: PersistorConstructorType);
     startConnection(): Promise<void>;
     size(): Promise<number>;
     getClientId(): UUID | undefined;
@@ -811,7 +809,6 @@ type PromiseCacheOptions = {
     fallbackToFunction?: boolean;
     onError?: (error: string) => void;
     onSuccess?: () => void;
-    logger?: Logger;
 };
 declare class PromiseCache<U> {
     persistor: Persistor;
@@ -825,7 +822,7 @@ 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, fallbackToFunction, onSuccess, onError, logger, }: PromiseCacheOptions);
+    constructor({ ttlInSeconds, caseSensitive, redis, fallbackToFunction, onSuccess, onError, }: PromiseCacheOptions);
     /**
      * Cache size.
      * @returns The number of entries in the cache.

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -35,14 +45,13 @@ __export(serializer_exports, {
   deserialize: () => deserialize,
   serialize: () => serialize
 });
-var fixESM = require("fix-esm");
-var superjson = fixESM.require("superjson");
+var import_superjson = __toESM(require("superjson"));
 var serialize = (data) => {
-  return superjson.stringify(data);
+  return import_superjson.default.stringify(data);
 };
 var deserialize = (serialized) => {
   if (serialized === void 0 || serialized === null) return serialized;
-  return superjson.parse(serialized);
+  return import_superjson.default.parse(serialized);
 };
 
 // src/setOptions.ts
@@ -988,8 +997,9 @@ var createLocalMemoryClient = () => {
 };
 
 // src/persistor.ts
-var fixESM2 = require("fix-esm");
-var superjson2 = fixESM2.require("superjson");
+var import_otel = require("@sebspark/otel");
+var fixESM = require("fix-esm");
+var superjson2 = fixESM.require("superjson");
 var CACHE_CLIENT = import_redis.createClient;
 var isTestRunning = process.env.NODE_ENV === "test";
 function toMillis(seconds2) {
@@ -1006,15 +1016,17 @@ var Persistor = class {
     redis,
     clientId,
     onSuccess,
-    onError,
-    logger
+    onError
   }) {
+    this.logger = (0, import_otel.getLogger)("Persistor");
+    this.logger.warn(
+      "Persistor class is deprecated. Use InMemoryPersistor or redis: createClient instead"
+    );
     this.onError = onError || (() => {
     });
     this.onSuccess = onSuccess || (() => {
     });
     this.clientId = clientId;
-    this.logger = logger;
     if (redis && !isTestRunning) {
       this.redis = redis;
     } else {
@@ -1035,7 +1047,7 @@ var Persistor = class {
           socket: {
             ...this.redis?.socket,
             reconnectStrategy: (retries, cause) => {
-              this.logger?.error(cause);
+              this.logger.error(cause);
               return 1e3 * 2 ** retries;
             }
           }
@@ -1046,15 +1058,15 @@ var Persistor = class {
           this.onSuccess();
           resolve(true);
         }).on("reconnecting", () => {
-          this.logger?.info("reconnecting...", this.clientId);
+          this.logger.info(`reconnecting... ${this.clientId}`);
         }).on("end", () => {
-          this.logger?.info("end...", this.clientId);
+          this.logger.info(`end... ${this.clientId}`);
         });
         this.client.connect();
       });
-    } catch (ex) {
-      this.onError(`${ex}`);
-      this.logger?.error(ex);
+    } catch (err) {
+      this.onError(`${err}`);
+      this.logger.error(err);
     }
   }
   async size() {
@@ -1084,7 +1096,7 @@ var Persistor = class {
    */
   async set(key, { value, timestamp = Date.now(), ttl }) {
     if (!this.client || !this.client.isReady) {
-      this.logger?.error("Client not ready");
+      this.logger.error("Client not ready");
       return;
     }
     try {
@@ -1096,7 +1108,7 @@ var Persistor = class {
       const options = this.createOptions(ttl);
       await this.client.set(key, serializedData, options);
     } catch (error) {
-      this.logger?.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}`);
     }
   }
@@ -1107,7 +1119,7 @@ var Persistor = class {
    */
   async get(key) {
     if (!this.client) {
-      this.logger?.error("Client not ready");
+      this.logger.error("Client not ready");
       return null;
     }
     try {
@@ -1117,7 +1129,7 @@ var Persistor = class {
       }
       return superjson2.parse(data);
     } catch (error) {
-      this.logger?.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}`);
     }
   }
@@ -1127,13 +1139,13 @@ var Persistor = class {
    */
   async delete(key) {
     if (!this.client || !this.client.isReady) {
-      this.logger?.error("Client not ready");
+      this.logger.error("Client not ready");
       return;
     }
     try {
       await this.client.del(key);
     } catch (error) {
-      this.logger?.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}`);
     }
   }
@@ -1141,14 +1153,15 @@ var Persistor = class {
 
 // src/promiseCache.ts
 var import_node_crypto = require("crypto");
+var import_otel2 = require("@sebspark/otel");
 var persistors = {};
 var getPersistor = ({
   redis,
-  logger,
   onError,
   onSuccess,
   clientId
 }) => {
+  const logger = (0, import_otel2.getLogger)("PromiseCache persistor");
   const connectionName = redis ? redis?.name || "default" : "local";
   if (!persistors[connectionName]) {
     persistors[connectionName] = new Persistor({
@@ -1165,8 +1178,7 @@ var getPersistor = ({
           `\u{1F4E6} REDIS | Connection Ready | ${connectionName} | ${redis?.url}`
         );
       },
-      clientId,
-      logger
+      clientId
     });
   }
   return persistors[connectionName];
@@ -1191,16 +1203,17 @@ var PromiseCache = class {
     redis,
     fallbackToFunction = false,
     onSuccess,
-    onError,
-    logger
+    onError
   }) {
-    this.logger = logger;
+    this.logger = (0, import_otel2.getLogger)("PromiseCache");
+    this.logger.warn(
+      "PromiseCache class is deprecated. Use createCache instead"
+    );
     this.persistor = getPersistor({
       redis,
       onError,
       onSuccess,
-      clientId: this.clientId,
-      logger: this.logger
+      clientId: this.clientId
     });
     this.caseSensitive = caseSensitive;
     this.fallbackToFunction = fallbackToFunction;
@@ -1267,7 +1280,7 @@ var PromiseCache = class {
       }
       this.logger?.error(
         "redis error, falling back to function execution",
-        error instanceof Error ? error.message : String(error)
+        error
       );
     }
     const response = await delegate();

package/dist/index.mjs

@@ -16,8 +16,7 @@ __export(serializer_exports, {
   deserialize: () => deserialize,
   serialize: () => serialize
 });
-var fixESM = __require("fix-esm");
-var superjson = fixESM.require("superjson");
+import superjson from "superjson";
 var serialize = (data) => {
   return superjson.stringify(data);
 };
@@ -969,8 +968,9 @@ var createLocalMemoryClient = () => {
 };
 
 // src/persistor.ts
-var fixESM2 = __require("fix-esm");
-var superjson2 = fixESM2.require("superjson");
+import { getLogger } from "@sebspark/otel";
+var fixESM = __require("fix-esm");
+var superjson2 = fixESM.require("superjson");
 var CACHE_CLIENT = createClient;
 var isTestRunning = process.env.NODE_ENV === "test";
 function toMillis(seconds2) {
@@ -987,15 +987,17 @@ var Persistor = class {
     redis,
     clientId,
     onSuccess,
-    onError,
-    logger
+    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;
-    this.logger = logger;
     if (redis && !isTestRunning) {
       this.redis = redis;
     } else {
@@ -1016,7 +1018,7 @@ var Persistor = class {
           socket: {
             ...this.redis?.socket,
             reconnectStrategy: (retries, cause) => {
-              this.logger?.error(cause);
+              this.logger.error(cause);
               return 1e3 * 2 ** retries;
             }
           }
@@ -1027,15 +1029,15 @@ var Persistor = class {
           this.onSuccess();
           resolve(true);
         }).on("reconnecting", () => {
-          this.logger?.info("reconnecting...", this.clientId);
+          this.logger.info(`reconnecting... ${this.clientId}`);
         }).on("end", () => {
-          this.logger?.info("end...", this.clientId);
+          this.logger.info(`end... ${this.clientId}`);
         });
         this.client.connect();
       });
-    } catch (ex) {
-      this.onError(`${ex}`);
-      this.logger?.error(ex);
+    } catch (err) {
+      this.onError(`${err}`);
+      this.logger.error(err);
     }
   }
   async size() {
@@ -1065,7 +1067,7 @@ var Persistor = class {
    */
   async set(key, { value, timestamp = Date.now(), ttl }) {
     if (!this.client || !this.client.isReady) {
-      this.logger?.error("Client not ready");
+      this.logger.error("Client not ready");
       return;
     }
     try {
@@ -1077,7 +1079,7 @@ var Persistor = class {
       const options = this.createOptions(ttl);
       await this.client.set(key, serializedData, options);
     } catch (error) {
-      this.logger?.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}`);
     }
   }
@@ -1088,7 +1090,7 @@ var Persistor = class {
    */
   async get(key) {
     if (!this.client) {
-      this.logger?.error("Client not ready");
+      this.logger.error("Client not ready");
       return null;
     }
     try {
@@ -1098,7 +1100,7 @@ var Persistor = class {
       }
       return superjson2.parse(data);
     } catch (error) {
-      this.logger?.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}`);
     }
   }
@@ -1108,13 +1110,13 @@ var Persistor = class {
    */
   async delete(key) {
     if (!this.client || !this.client.isReady) {
-      this.logger?.error("Client not ready");
+      this.logger.error("Client not ready");
       return;
     }
     try {
       await this.client.del(key);
     } catch (error) {
-      this.logger?.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}`);
     }
   }
@@ -1122,14 +1124,15 @@ var Persistor = class {
 
 // src/promiseCache.ts
 import { randomUUID } from "crypto";
+import { getLogger as getLogger2 } from "@sebspark/otel";
 var persistors = {};
 var getPersistor = ({
   redis,
-  logger,
   onError,
   onSuccess,
   clientId
 }) => {
+  const logger = getLogger2("PromiseCache persistor");
   const connectionName = redis ? redis?.name || "default" : "local";
   if (!persistors[connectionName]) {
     persistors[connectionName] = new Persistor({
@@ -1146,8 +1149,7 @@ var getPersistor = ({
           `\u{1F4E6} REDIS | Connection Ready | ${connectionName} | ${redis?.url}`
         );
       },
-      clientId,
-      logger
+      clientId
     });
   }
   return persistors[connectionName];
@@ -1172,16 +1174,17 @@ var PromiseCache = class {
     redis,
     fallbackToFunction = false,
     onSuccess,
-    onError,
-    logger
+    onError
   }) {
-    this.logger = logger;
+    this.logger = getLogger2("PromiseCache");
+    this.logger.warn(
+      "PromiseCache class is deprecated. Use createCache instead"
+    );
     this.persistor = getPersistor({
       redis,
       onError,
       onSuccess,
-      clientId: this.clientId,
-      logger: this.logger
+      clientId: this.clientId
     });
     this.caseSensitive = caseSensitive;
     this.fallbackToFunction = fallbackToFunction;
@@ -1248,7 +1251,7 @@ var PromiseCache = class {
       }
       this.logger?.error(
         "redis error, falling back to function execution",
-        error instanceof Error ? error.message : String(error)
+        error
       );
     }
     const response = await delegate();

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "@sebspark/promise-cache",
-  "version": "4.0.3",
+  "version": "5.0.1",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
   "files": [
     "dist"
   ],
@@ -17,14 +24,18 @@
     "typecheck": "vitest --typecheck.only --passWithNoTests"
   },
   "devDependencies": {
-    "@testcontainers/redis": "11.7.1",
-    "testcontainers": "11.7.1",
-    "tsconfig": "*"
+    "@sebspark/otel": "*",
+    "@sebspark/tsconfig": "*",
+    "@testcontainers/redis": "11.7.2",
+    "testcontainers": "11.7.2"
   },
   "dependencies": {
-    "date-fn": "^0.0.2",
+    "date-fns": "4.1.0",
     "fix-esm": "1.0.1",
-    "redis": "5.8.3",
-    "superjson": "2.2.2"
+    "redis": "5.9.0",
+    "superjson": "2.2.3"
+  },
+  "peerDependencies": {
+    "@sebspark/otel": ">=1.1.4"
   }
 }