@sebspark/promise-cache 0.2.3 → 0.2.5

package/README.md

@@ -9,9 +9,15 @@ A simple caching wrapper for promises.
 import { PromiseCache } from '@sebspark/promise-cache'
 
 // Instantiate the cache with a TTL.
-const cache = new PromiseCache<string, number>(60) // 1 minute cache TTL.
+const cache = new PromiseCache<number>(60, true, true) // 1 minute cache TTL / is case sensitive / use local storage
+
+const redisCache = new PromiseCache<number>(60, false, false) // 1 minute cache TTL / is not case sensitive / use redis storage
 
 // Use the cache wrapper for a database query to relieve the database.
 const query = 'SELECT username FROM users ORDER BY created DESC LIMIT 1'
 const newestUser = await cache.wrap('newestUser', () => database.query(query))
-```
+
+// Use the cache wrapper for a database query to relieve the database.
+const query = 'SELECT username FROM users ORDER BY created DESC LIMIT 1'
+const newestUser = await redisCache.wrap('newestUserRedis', () => database.query(query))
+```

package/dist/index.d.mts

@@ -1,20 +1,23 @@
+import { createClient } from 'redis';
+
 type GetType<T> = {
     value: T;
-    ttl: number;
+    ttl?: number;
     timestamp: number;
 };
 type SetParams<T> = {
     value: T;
     timestamp: number;
-    ttl: number;
+    ttl?: number;
 };
 declare class Persistor {
-    private client;
+    client: ReturnType<typeof createClient> | null;
     status: 'connected' | 'disconnected';
-    constructor();
+    constructor(isLocalPersistor: boolean);
     connect(): Promise<void>;
     size(): Promise<number>;
     get<T>(key: string): Promise<GetType<T> | null>;
+    private createOptions;
     set<T>(key: string, { value, timestamp, ttl }: SetParams<T>): Promise<void>;
     delete(key: string): Promise<void>;
 }
@@ -22,13 +25,13 @@ declare class Persistor {
 declare class PromiseCache<U> {
     persistor: Persistor;
     private readonly caseSensitive;
-    private readonly ttl;
+    private readonly ttl?;
     /**
      * 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: number, caseSensitive?: boolean);
+    constructor(ttlInSeconds?: number, caseSensitive?: boolean, isLocalPersistor?: boolean);
     /**
      * Cache size.
      * @returns The number of entries in the cache.
@@ -56,17 +59,18 @@ declare class PromiseCache<U> {
     wrap(key: string, delegate: () => Promise<U>, ttlInSeconds?: number): Promise<U>;
 }
 
-declare class MockedRedis {
+declare class LocalStorage {
     client: Map<any, any>;
     get(key: string): any;
     set(key: string, value: string, options?: {
         EX: number;
     }): void;
+    del(key: string): void;
     clear(): void;
     DBSIZE(): Promise<number>;
-    on(event: string, callback: () => void): this;
+    on(event: string, callback: (message: string) => void): this;
     connect(): Promise<this>;
 }
-declare const createClient: () => MockedRedis;
+declare const createLocalMemoryClient: () => LocalStorage;
 
-export { PromiseCache, createClient };
+export { LocalStorage, PromiseCache, createLocalMemoryClient };

package/dist/index.d.ts

@@ -1,20 +1,23 @@
+import { createClient } from 'redis';
+
 type GetType<T> = {
     value: T;
-    ttl: number;
+    ttl?: number;
     timestamp: number;
 };
 type SetParams<T> = {
     value: T;
     timestamp: number;
-    ttl: number;
+    ttl?: number;
 };
 declare class Persistor {
-    private client;
+    client: ReturnType<typeof createClient> | null;
     status: 'connected' | 'disconnected';
-    constructor();
+    constructor(isLocalPersistor: boolean);
     connect(): Promise<void>;
     size(): Promise<number>;
     get<T>(key: string): Promise<GetType<T> | null>;
+    private createOptions;
     set<T>(key: string, { value, timestamp, ttl }: SetParams<T>): Promise<void>;
     delete(key: string): Promise<void>;
 }
@@ -22,13 +25,13 @@ declare class Persistor {
 declare class PromiseCache<U> {
     persistor: Persistor;
     private readonly caseSensitive;
-    private readonly ttl;
+    private readonly ttl?;
     /**
      * 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: number, caseSensitive?: boolean);
+    constructor(ttlInSeconds?: number, caseSensitive?: boolean, isLocalPersistor?: boolean);
     /**
      * Cache size.
      * @returns The number of entries in the cache.
@@ -56,17 +59,18 @@ declare class PromiseCache<U> {
     wrap(key: string, delegate: () => Promise<U>, ttlInSeconds?: number): Promise<U>;
 }
 
-declare class MockedRedis {
+declare class LocalStorage {
     client: Map<any, any>;
     get(key: string): any;
     set(key: string, value: string, options?: {
         EX: number;
     }): void;
+    del(key: string): void;
     clear(): void;
     DBSIZE(): Promise<number>;
-    on(event: string, callback: () => void): this;
+    on(event: string, callback: (message: string) => void): this;
     connect(): Promise<this>;
 }
-declare const createClient: () => MockedRedis;
+declare const createLocalMemoryClient: () => LocalStorage;
 
-export { PromiseCache, createClient };
+export { LocalStorage, PromiseCache, createLocalMemoryClient };

package/dist/index.js

@@ -20,25 +20,73 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  LocalStorage: () => LocalStorage,
   PromiseCache: () => PromiseCache,
-  createClient: () => createClient2
+  createLocalMemoryClient: () => createLocalMemoryClient
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/persistor.ts
 var import_redis = require("redis");
+
+// src/localMemory.ts
+var LocalStorage = class {
+  client = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.client.get(key);
+  }
+  set(key, value, options) {
+    this.client.set(key, value);
+    if (options == null ? void 0 : options.EX) {
+      setTimeout(() => {
+        this.client.delete(key);
+      }, options.EX / 1e3);
+    }
+  }
+  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 === "connect") {
+      callback("connect");
+    }
+    return this;
+  }
+  connect() {
+    return Promise.resolve(this);
+  }
+};
+var createLocalMemoryClient = () => {
+  return new LocalStorage();
+};
+
+// src/persistor.ts
 var REDIS_HOST = process.env.REDIS_HOST || "127.0.0.1";
 var REDIS_PORT = process.env.REDIS_PORT || 6379;
 var REDIS_URL = `redis://${REDIS_HOST}:${REDIS_PORT}`;
+var CACHE_CLIENT = import_redis.createClient;
+if (process.env.JEST_WORKER_ID) {
+  CACHE_CLIENT = createLocalMemoryClient;
+}
 var Persistor = class {
-  client;
+  client = null;
   status = "disconnected";
-  constructor() {
+  constructor(isLocalPersistor) {
+    if (isLocalPersistor) {
+      CACHE_CLIENT = createLocalMemoryClient;
+    }
     this.connect();
   }
   async connect() {
     try {
-      this.client = (0, import_redis.createClient)({ url: REDIS_URL });
+      this.client = CACHE_CLIENT({ url: REDIS_URL });
       this.client.on("error", (err) => {
         console.error(`\u274C REDIS | Client Error | ${REDIS_URL}`, err);
         this.status = "disconnected";
@@ -50,7 +98,7 @@ var Persistor = class {
           return;
         }
         this.client.on("connect", () => {
-          console.info(`\u{1F4E6} REDIS | Connection Ready | ${REDIS_URL}`);
+          console.log(`\u{1F4E6} REDIS | Connection Ready | ${REDIS_URL}`);
           this.status = "connected";
           resolve(true);
         });
@@ -81,15 +129,20 @@ var Persistor = class {
       throw error;
     }
   }
+  createOptions(ttl) {
+    if (ttl !== null && ttl !== void 0) {
+      return { EX: ttl / 1e3 };
+    }
+    return {};
+  }
   async set(key, { value, timestamp, ttl }) {
     if (!this.client) {
       throw new Error("Client not initialized");
     }
     try {
       const serializedData = JSON.stringify({ value, ttl, timestamp });
-      await this.client.set(key, serializedData, {
-        EX: ttl / 1e3
-      });
+      const options = this.createOptions(ttl);
+      await this.client.set(key, serializedData, options);
     } catch (error) {
       console.error(`Error setting data in redis: ${error}`);
       throw error;
@@ -107,7 +160,10 @@ var Persistor = class {
     }
   }
 };
-var persistor = new Persistor();
+var createPersistor = (isLocalPersistor) => {
+  const persistor = new Persistor(isLocalPersistor);
+  return persistor;
+};
 
 // src/promiseCache.ts
 var PromiseCache = class {
@@ -120,10 +176,12 @@ var PromiseCache = class {
    * @param ttlInSeconds Default cache TTL.
    * @param caseSensitive Set to true if you want to differentiate between keys with different casing.
    */
-  constructor(ttlInSeconds, caseSensitive = false) {
-    this.persistor = persistor;
+  constructor(ttlInSeconds, caseSensitive = false, isLocalPersistor = false) {
+    this.persistor = createPersistor(isLocalPersistor);
     this.caseSensitive = caseSensitive;
-    this.ttl = ttlInSeconds * 1e3;
+    if (ttlInSeconds) {
+      this.ttl = ttlInSeconds * 1e3;
+    }
   }
   /**
    * Cache size.
@@ -184,41 +242,9 @@ var PromiseCache = class {
     return response;
   }
 };
-
-// src/test/mockedRedis.ts
-var MockedRedis = class {
-  client = /* @__PURE__ */ new Map();
-  get(key) {
-    return this.client.get(key);
-  }
-  set(key, value, options) {
-    this.client.set(key, value);
-    if (options == null ? void 0 : options.EX) {
-      setTimeout(() => {
-        this.client.delete(key);
-      }, options.EX / 1e3);
-    }
-  }
-  clear() {
-    this.client.clear();
-  }
-  async DBSIZE() {
-    return Promise.resolve(this.client.size);
-  }
-  // Fake connection to fake server
-  on(event, callback) {
-    if (event === "connect") {
-      callback();
-    }
-    return this;
-  }
-  connect() {
-    return Promise.resolve(this);
-  }
-};
-var createClient2 = () => new MockedRedis();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  LocalStorage,
   PromiseCache,
-  createClient
+  createLocalMemoryClient
 });

package/dist/index.mjs

@@ -1,17 +1,64 @@
 // src/persistor.ts
 import { createClient } from "redis";
+
+// src/localMemory.ts
+var LocalStorage = class {
+  client = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.client.get(key);
+  }
+  set(key, value, options) {
+    this.client.set(key, value);
+    if (options == null ? void 0 : options.EX) {
+      setTimeout(() => {
+        this.client.delete(key);
+      }, options.EX / 1e3);
+    }
+  }
+  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 === "connect") {
+      callback("connect");
+    }
+    return this;
+  }
+  connect() {
+    return Promise.resolve(this);
+  }
+};
+var createLocalMemoryClient = () => {
+  return new LocalStorage();
+};
+
+// src/persistor.ts
 var REDIS_HOST = process.env.REDIS_HOST || "127.0.0.1";
 var REDIS_PORT = process.env.REDIS_PORT || 6379;
 var REDIS_URL = `redis://${REDIS_HOST}:${REDIS_PORT}`;
+var CACHE_CLIENT = createClient;
+if (process.env.JEST_WORKER_ID) {
+  CACHE_CLIENT = createLocalMemoryClient;
+}
 var Persistor = class {
-  client;
+  client = null;
   status = "disconnected";
-  constructor() {
+  constructor(isLocalPersistor) {
+    if (isLocalPersistor) {
+      CACHE_CLIENT = createLocalMemoryClient;
+    }
     this.connect();
   }
   async connect() {
     try {
-      this.client = createClient({ url: REDIS_URL });
+      this.client = CACHE_CLIENT({ url: REDIS_URL });
       this.client.on("error", (err) => {
         console.error(`\u274C REDIS | Client Error | ${REDIS_URL}`, err);
         this.status = "disconnected";
@@ -23,7 +70,7 @@ var Persistor = class {
           return;
         }
         this.client.on("connect", () => {
-          console.info(`\u{1F4E6} REDIS | Connection Ready | ${REDIS_URL}`);
+          console.log(`\u{1F4E6} REDIS | Connection Ready | ${REDIS_URL}`);
           this.status = "connected";
           resolve(true);
         });
@@ -54,15 +101,20 @@ var Persistor = class {
       throw error;
     }
   }
+  createOptions(ttl) {
+    if (ttl !== null && ttl !== void 0) {
+      return { EX: ttl / 1e3 };
+    }
+    return {};
+  }
   async set(key, { value, timestamp, ttl }) {
     if (!this.client) {
       throw new Error("Client not initialized");
     }
     try {
       const serializedData = JSON.stringify({ value, ttl, timestamp });
-      await this.client.set(key, serializedData, {
-        EX: ttl / 1e3
-      });
+      const options = this.createOptions(ttl);
+      await this.client.set(key, serializedData, options);
     } catch (error) {
       console.error(`Error setting data in redis: ${error}`);
       throw error;
@@ -80,7 +132,10 @@ var Persistor = class {
     }
   }
 };
-var persistor = new Persistor();
+var createPersistor = (isLocalPersistor) => {
+  const persistor = new Persistor(isLocalPersistor);
+  return persistor;
+};
 
 // src/promiseCache.ts
 var PromiseCache = class {
@@ -93,10 +148,12 @@ var PromiseCache = class {
    * @param ttlInSeconds Default cache TTL.
    * @param caseSensitive Set to true if you want to differentiate between keys with different casing.
    */
-  constructor(ttlInSeconds, caseSensitive = false) {
-    this.persistor = persistor;
+  constructor(ttlInSeconds, caseSensitive = false, isLocalPersistor = false) {
+    this.persistor = createPersistor(isLocalPersistor);
     this.caseSensitive = caseSensitive;
-    this.ttl = ttlInSeconds * 1e3;
+    if (ttlInSeconds) {
+      this.ttl = ttlInSeconds * 1e3;
+    }
   }
   /**
    * Cache size.
@@ -157,40 +214,8 @@ var PromiseCache = class {
     return response;
   }
 };
-
-// src/test/mockedRedis.ts
-var MockedRedis = class {
-  client = /* @__PURE__ */ new Map();
-  get(key) {
-    return this.client.get(key);
-  }
-  set(key, value, options) {
-    this.client.set(key, value);
-    if (options == null ? void 0 : options.EX) {
-      setTimeout(() => {
-        this.client.delete(key);
-      }, options.EX / 1e3);
-    }
-  }
-  clear() {
-    this.client.clear();
-  }
-  async DBSIZE() {
-    return Promise.resolve(this.client.size);
-  }
-  // Fake connection to fake server
-  on(event, callback) {
-    if (event === "connect") {
-      callback();
-    }
-    return this;
-  }
-  connect() {
-    return Promise.resolve(this);
-  }
-};
-var createClient2 = () => new MockedRedis();
 export {
+  LocalStorage,
   PromiseCache,
-  createClient2 as createClient
+  createLocalMemoryClient
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebspark/promise-cache",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -17,6 +17,6 @@
     "tsconfig": "*"
   },
   "dependencies": {
-    "redis": "^4.6.13"
+    "redis": "4.6.12"
   }
 }