@sebspark/promise-cache 0.2.2 → 0.2.4

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.
@@ -41,6 +44,11 @@ declare class PromiseCache<U> {
      * @param ttlInSeconds Time to live in seconds.
      */
     override<U>(key: string, value: U, ttlInSeconds?: number): Promise<void>;
+    /**
+     * Get a value from the cache.
+     * @param key Cache key.
+     */
+    find<U>(key: string): Promise<U | null>;
     /**
      * A simple promise cache wrapper.
      * @param key Cache key.
@@ -51,4 +59,18 @@ declare class PromiseCache<U> {
     wrap(key: string, delegate: () => Promise<U>, ttlInSeconds?: number): Promise<U>;
 }
 
-export { PromiseCache };
+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: (message: string) => void): this;
+    connect(): Promise<this>;
+}
+declare const createLocalMemoryClient: () => LocalStorage;
+
+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.
@@ -41,6 +44,11 @@ declare class PromiseCache<U> {
      * @param ttlInSeconds Time to live in seconds.
      */
     override<U>(key: string, value: U, ttlInSeconds?: number): Promise<void>;
+    /**
+     * Get a value from the cache.
+     * @param key Cache key.
+     */
+    find<U>(key: string): Promise<U | null>;
     /**
      * A simple promise cache wrapper.
      * @param key Cache key.
@@ -51,4 +59,18 @@ declare class PromiseCache<U> {
     wrap(key: string, delegate: () => Promise<U>, ttlInSeconds?: number): Promise<U>;
 }
 
-export { PromiseCache };
+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: (message: string) => void): this;
+    connect(): Promise<this>;
+}
+declare const createLocalMemoryClient: () => LocalStorage;
+
+export { LocalStorage, PromiseCache, createLocalMemoryClient };

package/dist/index.js

@@ -20,24 +20,73 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  PromiseCache: () => PromiseCache
+  LocalStorage: () => LocalStorage,
+  PromiseCache: () => PromiseCache,
+  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 = await (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";
@@ -49,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);
         });
@@ -80,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;
@@ -106,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 {
@@ -119,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.
@@ -146,6 +205,14 @@ var PromiseCache = class {
       ttl: effectiveTTL
     });
   }
+  /**
+   * Get a value from the cache.
+   * @param key Cache key.
+   */
+  async find(key) {
+    const result = await this.persistor.get(key);
+    return (result == null ? void 0 : result.value) ?? null;
+  }
   /**
    * A simple promise cache wrapper.
    * @param key Cache key.
@@ -177,5 +244,7 @@ var PromiseCache = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PromiseCache
+  LocalStorage,
+  PromiseCache,
+  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 = await 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.
@@ -120,6 +177,14 @@ var PromiseCache = class {
       ttl: effectiveTTL
     });
   }
+  /**
+   * Get a value from the cache.
+   * @param key Cache key.
+   */
+  async find(key) {
+    const result = await this.persistor.get(key);
+    return (result == null ? void 0 : result.value) ?? null;
+  }
   /**
    * A simple promise cache wrapper.
    * @param key Cache key.
@@ -150,5 +215,7 @@ var PromiseCache = class {
   }
 };
 export {
-  PromiseCache
+  LocalStorage,
+  PromiseCache,
+  createLocalMemoryClient
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebspark/promise-cache",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",