exframe-cache-manager 2.2.0 → 2.2.2

package/index.js

@@ -1,272 +1,5 @@
-'use strict';
+const cacheManagerModule = require('./src/cacheManager/index');
 
-import util from 'node:util';
-import { setTimeout as waitTimeout } from 'node:timers/promises';
-import CacheManager from 'cache-manager';
-import RedisStore from 'cache-manager-redis-store';
-import { lazyInstrument } from 'exframe-metrics';
-import health from 'exframe-health';
-import service from 'exframe-service';
-import { generateShortId } from 'exframe-utilities';
+const { cachemanager } = cacheManagerModule;
 
-const DEFAULT_TTL = 600;
-
-const db = 0;
-
-/**
- * Cache manager for storing stuff.
- * Options is required to pass the redis location
- * @param {Options} options
- */
-function cachemanager(options) {
-  if (options.url) {
-    options.host = undefined;
-    options.port = undefined;
-  }
-
-  const redisCache = CacheManager.caching({
-    store: RedisStore,
-    ttl: DEFAULT_TTL,
-    db,
-    ...options
-  });
-
-  // @ts-ignore
-  const redisStore = redisCache.store;
-  const redisClient = redisStore.getClient();
-  redisClient.setMaxListeners(0);
-
-  redisClient.on('error', (e) => {
-    console.log('Unhandled Redis Error', { errorDetails: e }); // eslint-disable-line
-  });
-
-  process.on('beforeExit', () => {
-    if (redisClient.connected) {
-      redisClient.removeAllListeners();
-      redisClient.end(true);
-    }
-  });
-
-  const instance = {
-    id: generateShortId(),
-    get cacheStorePool() {
-      return redisClient;
-    },
-
-    /**
-     *
-     * @param {string} key
-     * @param {object} context
-     * @param {Options} options
-     */
-
-    async getItem(context, key, { timeout } = {}) {
-      if (arguments.length === 1) {
-        // context = key, param order was switched in function def to preserve backwards compatability
-        return redisCache.get(context);
-      }
-
-      const controller = new AbortController();
-      if (timeout) {
-        const result = await Promise.race([
-          redisCache.get(key),
-          waitTimeout(timeout, false, { signal: controller.signal, ref: false })
-        ]);
-
-        if (!result) {
-          context.log.info('CACHE TIMEOUT ERROR');
-          return Promise.reject(new Error('Timed out attempting to retrieve item from cache.'));
-        }
-
-        controller.abort();
-        return result;
-      }
-      return redisCache.get(key);
-    },
-
-    /**
-     *
-     * @template T
-     * @param {string} key
-     * @param {T} value
-     * @param {number} [ttl]
-     * @returns {Promise<T>}
-     */
-    async setItem(key, value, ttl) {
-      await redisCache.set(key, value, {
-        ttl: ttl || Number(process.env.REDIS_CACHE_TTL)
-      });
-
-      return value;
-    },
-
-    /**
-     * Set the item if it does not exist yet. If the item already exists, do not set and return null.
-     * @template T
-     * @param {String} key
-     * @param {T} value
-     * @param {Number} ttl
-     * @returns {Promise<T|null>}
-     */
-    async setItemIfNotExists(key, value, ttl) {
-      const ttlToSet = ttl ?? (process.env.REDIS_CACHE_TTL
-        ? Number(process.env.REDIS_CACHE_TTL)
-        : DEFAULT_TTL);
-
-      return new Promise((resolve, reject) => {
-        redisClient.set(key, value, 'NX', 'EX', ttlToSet, (error, result) => {
-          if (error) {
-            return reject(error);
-          }
-
-          resolve(result === 'OK' ? value : null);
-        });
-      });
-    },
-
-    /**
-     *
-     * @param {string} key
-     * @param {any} value
-     */
-    addSetItem(key, value) {
-      return this.processRedisCommands(client => client.sadd(key, value));
-    },
-
-    /**
-     *
-     * @param {string} key
-     * @param {any} value
-     */
-    removeSetItem(key, value) {
-      return this.processRedisCommands(client => client.srem(key, value));
-    },
-
-    /**
-     *
-     * @param {string} key
-     * @param {any} value
-     * @returns {Promise<Boolean>}
-     */
-    isSetMember(key, value) {
-      return this.processRedisCommands(async client => new Promise((res, rej) => {
-        client.sismember(key, value, (ex, result) => {
-          if (ex) return rej(ex);
-          res(result === 1);
-        });
-      }));
-    },
-
-    /**
-     * @returns {Promise<true>}
-     */
-    async healthCheck() {
-      return this.processRedisCommands(client => client && client.server_info.loading === '0');
-    },
-
-    close() {
-      return new Promise(res => {
-        redisClient.removeAllListeners();
-        redisClient.end(true);
-        res();
-      });
-    },
-
-    getClient() {
-      return new Promise((resolve, reject) => {
-        if (redisClient.connected) {
-          return resolve(redisClient);
-        }
-
-        redisClient.on('ready', () => resolve(redisClient));
-        redisClient.on('error', (e) => reject(e));
-      });
-    },
-
-    /**
-     *
-     * @param {(client: any) => any} fn
-     */
-    async processRedisCommands(fn) {
-      const client = await this.getClient();
-      const result = await fn(client);
-
-      return result;
-    },
-
-    /**
-     *
-     * @param {Context} context
-     * @param {string | RegExp} pattern
-     */
-    flushCache(context, pattern) {
-      return this.processRedisCommands(async (client) => {
-        const scanAsync = util.promisify(client.scan).bind(client);
-        const delAsync = util.promisify(client.del).bind(client);
-        let cursor = '0';
-        do {
-          const result = await scanAsync(cursor, 'MATCH', pattern);
-          ([cursor] = result);
-          const keys = result[1];
-          context.log.info('matched keys', {
-            keys: result[1]
-          });
-          if (keys.length > 0) {
-            await delAsync(...keys);
-          }
-        } while (cursor !== '0');
-      });
-    },
-    redisClient,
-    redisCache
-  };
-
-  health.add(`redis-${instance.id}`, async () => {
-    try {
-      const controller = new AbortController();
-
-      const result = await Promise.race([
-        instance.healthCheck(),
-        waitTimeout(3000, false, { signal: controller.signal, ref: false })
-      ]);
-
-      if (!result) {
-        throw new Error('Timed out waiting to verify health status');
-      }
-
-      controller.abort();
-      return { status: 200, message: 'OK' };
-    } catch (ex) { // eslint-disable-line no-unused-vars
-      return { status: 503, message: 'Error connecting to Redis' };
-    }
-  }, { promotionTimeout: 60000 });
-
-  service.registerResource(`exframe-cache-manager-${instance.id}`, { onSignal: () => instance.close(), order: 'last' });
-
-  Object.keys(instance).forEach((key) => {
-    if (typeof instance[key] === 'function') {
-      instance[key] = lazyInstrument(instance[key].bind(instance), { metricPrefix: 'cache' });
-    }
-  });
-
-  return instance;
-}
-
-// eslint-disable-next-line import/prefer-default-export
-export { cachemanager as create };
-
-/**
- * @typedef {RedisCacheManagerOptions & { store?: any, ttl?: number, db?: number }} Options
- */
-
-/**
- * @typedef {{ db?: number, url?: string, host?: string, port?: string }} RedisCacheManagerOptions
- */
-
-/**
- * @typedef {{ [key: string]: any, log: { [key: string]: LogLevel, info: LogLevel, error: LogLevel } }} Context
- */
-
-/**
- * @typedef {(message: string, meta: { [key: string]: any }) => void} LogLevel
- */
+module.exports = { create: cachemanager };

package/index.mjs

@@ -0,0 +1,3 @@
+import { cachemanager } from './src/cacheManager/index.js';
+
+export default { create: cachemanager };

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "exframe-cache-manager",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Managing the cache",
-  "main": "index.js",
   "type": "module",
+  "main": "index.js",
+  "module": "index.mjs",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.mjs"
+    }
+  },
   "config": {
     "reporter": "mocha-exzeo-reporter"
   },
@@ -47,5 +55,5 @@
     "url": "https://bitbucket.org/exzeo-usa/exframe",
     "directory": "packages/exframe-cache-manager"
   },
-  "gitHead": "25463e1a2459e770277640472111e372cacf4aa5"
+  "gitHead": "3e1aa0feed298e624741cedcf3195c8725a23e34"
 }

package/src/cacheManager/index.js

@@ -0,0 +1,272 @@
+'use strict';
+
+import util from 'node:util';
+import { setTimeout as waitTimeout } from 'node:timers/promises';
+import CacheManager from 'cache-manager';
+import RedisStore from 'cache-manager-redis-store';
+import { lazyInstrument } from 'exframe-metrics';
+import health from 'exframe-health';
+import service from 'exframe-service';
+import { generateShortId } from 'exframe-utilities';
+
+const DEFAULT_TTL = 600;
+
+const db = 0;
+
+/**
+ * Cache manager for storing stuff.
+ * Options is required to pass the redis location
+ * @param {Options} options
+ */
+function cachemanager(options) {
+  if (options.url) {
+    options.host = undefined;
+    options.port = undefined;
+  }
+
+  const redisCache = CacheManager.caching({
+    store: RedisStore,
+    ttl: DEFAULT_TTL,
+    db,
+    ...options
+  });
+
+  // @ts-ignore
+  const redisStore = redisCache.store;
+  const redisClient = redisStore.getClient();
+  redisClient.setMaxListeners(0);
+
+  redisClient.on('error', (e) => {
+    console.log('Unhandled Redis Error', { errorDetails: e }); // eslint-disable-line
+  });
+
+  process.on('beforeExit', () => {
+    if (redisClient.connected) {
+      redisClient.removeAllListeners();
+      redisClient.end(true);
+    }
+  });
+
+  const instance = {
+    id: generateShortId(),
+    get cacheStorePool() {
+      return redisClient;
+    },
+
+    /**
+     *
+     * @param {string} key
+     * @param {object} context
+     * @param {Options} options
+     */
+
+    async getItem(context, key, { timeout } = {}) {
+      if (arguments.length === 1) {
+        // context = key, param order was switched in function def to preserve backwards compatability
+        return redisCache.get(context);
+      }
+
+      const controller = new AbortController();
+      if (timeout) {
+        const result = await Promise.race([
+          redisCache.get(key),
+          waitTimeout(timeout, false, { signal: controller.signal, ref: false })
+        ]);
+
+        if (!result) {
+          context.log.info('CACHE TIMEOUT ERROR');
+          return Promise.reject(new Error('Timed out attempting to retrieve item from cache.'));
+        }
+
+        controller.abort();
+        return result;
+      }
+      return redisCache.get(key);
+    },
+
+    /**
+     *
+     * @template T
+     * @param {string} key
+     * @param {T} value
+     * @param {number} [ttl]
+     * @returns {Promise<T>}
+     */
+    async setItem(key, value, ttl) {
+      await redisCache.set(key, value, {
+        ttl: ttl || Number(process.env.REDIS_CACHE_TTL)
+      });
+
+      return value;
+    },
+
+    /**
+     * Set the item if it does not exist yet. If the item already exists, do not set and return null.
+     * @template T
+     * @param {String} key
+     * @param {T} value
+     * @param {Number} ttl
+     * @returns {Promise<T|null>}
+     */
+    async setItemIfNotExists(key, value, ttl) {
+      const ttlToSet = ttl ?? (process.env.REDIS_CACHE_TTL
+        ? Number(process.env.REDIS_CACHE_TTL)
+        : DEFAULT_TTL);
+
+      return new Promise((resolve, reject) => {
+        redisClient.set(key, value, 'NX', 'EX', ttlToSet, (error, result) => {
+          if (error) {
+            return reject(error);
+          }
+
+          resolve(result === 'OK' ? value : null);
+        });
+      });
+    },
+
+    /**
+     *
+     * @param {string} key
+     * @param {any} value
+     */
+    addSetItem(key, value) {
+      return this.processRedisCommands(client => client.sadd(key, value));
+    },
+
+    /**
+     *
+     * @param {string} key
+     * @param {any} value
+     */
+    removeSetItem(key, value) {
+      return this.processRedisCommands(client => client.srem(key, value));
+    },
+
+    /**
+     *
+     * @param {string} key
+     * @param {any} value
+     * @returns {Promise<Boolean>}
+     */
+    isSetMember(key, value) {
+      return this.processRedisCommands(async client => new Promise((res, rej) => {
+        client.sismember(key, value, (ex, result) => {
+          if (ex) return rej(ex);
+          res(result === 1);
+        });
+      }));
+    },
+
+    /**
+     * @returns {Promise<true>}
+     */
+    async healthCheck() {
+      return this.processRedisCommands(client => client && client.server_info.loading === '0');
+    },
+
+    close() {
+      return new Promise(res => {
+        redisClient.removeAllListeners();
+        redisClient.end(true);
+        res();
+      });
+    },
+
+    getClient() {
+      return new Promise((resolve, reject) => {
+        if (redisClient.connected) {
+          return resolve(redisClient);
+        }
+
+        redisClient.on('ready', () => resolve(redisClient));
+        redisClient.on('error', (e) => reject(e));
+      });
+    },
+
+    /**
+     *
+     * @param {(client: any) => any} fn
+     */
+    async processRedisCommands(fn) {
+      const client = await this.getClient();
+      const result = await fn(client);
+
+      return result;
+    },
+
+    /**
+     *
+     * @param {Context} context
+     * @param {string | RegExp} pattern
+     */
+    flushCache(context, pattern) {
+      return this.processRedisCommands(async (client) => {
+        const scanAsync = util.promisify(client.scan).bind(client);
+        const delAsync = util.promisify(client.del).bind(client);
+        let cursor = '0';
+        do {
+          const result = await scanAsync(cursor, 'MATCH', pattern);
+          ([cursor] = result);
+          const keys = result[1];
+          context.log.info('matched keys', {
+            keys: result[1]
+          });
+          if (keys.length > 0) {
+            await delAsync(...keys);
+          }
+        } while (cursor !== '0');
+      });
+    },
+    redisClient,
+    redisCache
+  };
+
+  health.add(`redis-${instance.id}`, async () => {
+    try {
+      const controller = new AbortController();
+
+      const result = await Promise.race([
+        instance.healthCheck(),
+        waitTimeout(3000, false, { signal: controller.signal, ref: false })
+      ]);
+
+      if (!result) {
+        throw new Error('Timed out waiting to verify health status');
+      }
+
+      controller.abort();
+      return { status: 200, message: 'OK' };
+    } catch (ex) { // eslint-disable-line no-unused-vars
+      return { status: 503, message: 'Error connecting to Redis' };
+    }
+  }, { promotionTimeout: 60000 });
+
+  service.registerResource(`exframe-cache-manager-${instance.id}`, { onSignal: () => instance.close(), order: 'last' });
+
+  Object.keys(instance).forEach((key) => {
+    if (typeof instance[key] === 'function') {
+      instance[key] = lazyInstrument(instance[key].bind(instance), { metricPrefix: 'cache' });
+    }
+  });
+
+  return instance;
+}
+
+// eslint-disable-next-line import/prefer-default-export
+export { cachemanager };
+
+/**
+ * @typedef {RedisCacheManagerOptions & { store?: any, ttl?: number, db?: number }} Options
+ */
+
+/**
+ * @typedef {{ db?: number, url?: string, host?: string, port?: string }} RedisCacheManagerOptions
+ */
+
+/**
+ * @typedef {{ [key: string]: any, log: { [key: string]: LogLevel, info: LogLevel, error: LogLevel } }} Context
+ */
+
+/**
+ * @typedef {(message: string, meta: { [key: string]: any }) => void} LogLevel
+ */

package/test/cacheManager.test.js

@@ -6,7 +6,7 @@ import service from 'exframe-service';
 import health from 'exframe-health';
 import { setTimeout as waitTimeout } from 'node:timers/promises';
 
-import { create } from '../index.js';
+import cacheManager from '../index.mjs';
 
 const { prometheusClient } = service;
 const userId = 'auth0|1234567890';
@@ -36,7 +36,7 @@ context('Test User Profile Middleware', () => {
       it('adds a health check with the instance ID in the name, check function, and liveness timeout of 60 seconds', () => {
         const healthAddSpy = sinonInstance.spy(health, 'add');
 
-        const instance = create(options);
+        const instance = cacheManager.create(options);
         expect(healthAddSpy.calledOnce).to.equal(true);
         expect(healthAddSpy.calledWithMatch(`redis-${instance.id}`, match.func, { promotionTimeout: 60000 })).to.be.true;
       });
@@ -44,7 +44,7 @@ context('Test User Profile Middleware', () => {
       it('registers a service resource with the instance ID in the name, onSignal function, and order of "last"', () => {
         const registerSpy = sinonInstance.spy(service, 'registerResource');
 
-        const instance = create(options);
+        const instance = cacheManager.create(options);
         expect(registerSpy.calledOnce).to.equal(true);
         expect(registerSpy.calledWithMatch(`exframe-cache-manager-${instance.id}`, match({
           onSignal: match.func,
@@ -54,7 +54,7 @@ context('Test User Profile Middleware', () => {
     });
 
     describe('instance', () => {
-      const app = create(options);
+      const app = cacheManager.create(options);
 
       beforeEach(() => {
         prometheusClient.register.clear();
@@ -178,7 +178,7 @@ context('Test User Profile Middleware', () => {
       });
 
       it('close drains the redis pool', async () => {
-        const app1 = create(options);
+        const app1 = cacheManager.create(options);
         await app1.setItem(cacheKey, 'someValue');
         const value = await app1.getItem(cacheKey);
         expect(value).to.eql('someValue');