exframe-cache-manager 1.3.2 → 2.0.1

package/.eslintrc.json

@@ -1,17 +1,3 @@
 {
-  "env": {
-    "es6": true,
-    "node": true
-  },
-  "extends": "airbnb-base",
-  "rules": {
-    "comma-dangle": ["error", "never"],
-    "strict": ["off", "global"] ,
-    "consistent-return": "off",
-    "linebreak-style": ["error", "windows"],
-    "max-len": ["error", 200],
-    "no-param-reassign": ["error", { "props": false }],
-    "no-underscore-dangle": "off",
-    "arrow-parens": "off"
-  }
-}
+  "extends": "exzeo/base"
+}

package/Dockerfile

@@ -7,12 +7,11 @@ RUN apk update && \
   addgroup -S docker && adduser -S -G docker docker
 
 COPY ./package.json /app/package.json
-WORKDIR /app
-RUN npm install && \
-  npm run pretest
-  npm cache clean --force
-
 COPY . /app
 
+WORKDIR /app
+RUN yarn install
+RUN npm run peers
+
 # Override the command, to run the test instead of the application
 CMD ["npm", "run", "unit-test"]

package/index.js

@@ -1,208 +1,196 @@
-'use strict';
-
-const CacheManager = require('cache-manager');
-const RedisStore = require('cache-manager-redis');
-const util = require('util');
-const { lazyInstrument } = require('exframe-metrics');
-
-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: 600,
-    db,
-    ...options
-  });
-
-  // @ts-ignore
-  const redisStore = redisCache.store;
-
-  // need to expose the store's connection pool after it's created by the cache manager as it does not seem to have a way to pass it in
-  // if we use something besides redis, we'll have to tackle this differently
-  const cacheStorePool = Object.assign(redisStore._pool, { db });
-  cacheStorePool.setMaxListeners(0);
-
-  const instance = {
-    /**
-     *
-     * @param {string} key
-     */
-    getItem(key) {
-      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;
-    },
-
-    /**
-     *
-     * @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 => {
-        cacheStorePool.drain(res);
-      });
-    },
-
-    getClient() {
-      return new Promise((resolve, reject) => {
-        cacheStorePool.acquireDb(async (connError, client) => {
-          let timeout;
-
-          if (connError) {
-            return reject(connError);
-          }
-
-          if (client.connected) {
-            return resolve(client);
-          }
-
-          client.once('ready', () => {
-            clearTimeout(timeout);
-            resolve(client);
-          });
-
-          timeout = setTimeout(() => {
-            cacheStorePool.release(client);
-            reject(new Error('Timeout waiting for redis client connection'));
-          }, 10000);
-        }, db);
-      });
-    },
-
-    /**
-     *
-     * @param {(client: any) => any} fn
-     */
-    async processRedisCommands(fn) {
-      let client;
-      let result;
-
-      try {
-        client = await this.getClient();
-        result = await fn(client);
-      } finally {
-        if (client) {
-          cacheStorePool.release(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 {
-          // eslint-disable-next-line no-await-in-loop
-          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) {
-            // eslint-disable-next-line no-await-in-loop
-            await delAsync(...keys);
-          }
-        } while (cursor !== '0');
-      });
-    },
-    cacheStorePool
-  };
-
-  Object.keys(instance).forEach((key) => {
-    if (typeof instance[key] === 'function') {
-      instance[key] = lazyInstrument(instance[key].bind(instance), { metricPrefix: 'cache' });
-    }
-  });
-
-  return instance;
-}
-
-module.exports = {
-  create: 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
- */
+'use strict';
+
+const CacheManager = require('cache-manager');
+const RedisStore = require('cache-manager-redis-store');
+const util = require('util');
+const { lazyInstrument } = require('exframe-metrics');
+
+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: 600,
+    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 = {
+    get cacheStorePool() {
+      return redisClient;
+    },
+
+    /**
+     *
+     * @param {string} key
+     */
+    getItem(key) {
+      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;
+    },
+
+    /**
+     *
+     * @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
+  };
+
+  Object.keys(instance).forEach((key) => {
+    if (typeof instance[key] === 'function') {
+      instance[key] = lazyInstrument(instance[key].bind(instance), { metricPrefix: 'cache' });
+    }
+  });
+
+  return instance;
+}
+
+module.exports = {
+  create: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exframe-cache-manager",
-  "version": "1.3.2",
+  "version": "2.0.1",
   "description": "Managing the cache",
   "main": "index.js",
   "config": {
@@ -11,9 +11,10 @@
   },
   "scripts": {
     "pretest": "npm-install-peers && npm run lint",
-    "lint": "./node_modules/.bin/eslint .",
+    "lint": "eslint ./",
+    "peers": "npm-install-peers",
     "test": "docker-compose -f docker-compose.yml up --abort-on-container-exit --exit-code-from exframe-cache-manager",
-    "unit-test": "./node_modules/.bin/nyc -r lcov --report-dir ./documentation/coverage -t ./documentation/coverage mocha --reporter $npm_package_config_reporter \"./test/**/*.test.js\""
+    "unit-test": "./node_modules/.bin/nyc -r lcov --report-dir ./documentation/coverage -t ./documentation/coverage mocha --exit --reporter $npm_package_config_reporter \"./test/**/*.test.js\""
   },
   "author": "Exzeo",
   "license": "ISC",
@@ -24,26 +25,25 @@
   },
   "dependencies": {
     "@types/cache-manager": "^3.4.2",
-    "@types/redis": "^2.8.32",
     "cache-manager": "^3.6.0",
-    "cache-manager-redis": "^0.6.0",
-    "exframe-metrics": "^1.1.0",
-    "redis": "^3.1.2"
+    "cache-manager-redis-store": "^2.0.0",
+    "exframe-metrics": "^1.1.0"
   },
   "devDependencies": {
-    "chai": "^4.3.4",
-    "eslint": "^8.3.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-plugin-import": "^2.25.3",
+    "chai": "*",
+    "eslint": "*",
+    "eslint-config-exzeo": "*",
+    "eslint-plugin-import": "*",
     "mocha": "*",
-    "mocha-exzeo-reporter": "0.0.3",
+    "mocha-exzeo-reporter": "*",
     "npm-install-peers": "*",
-    "nyc": "*"
+    "nyc": "*",
+    "sinon": "*"
   },
   "repository": {
     "type": "git",
     "url": "https://bitbucket.org/exzeo-usa/exframe",
     "directory": "packages/exframe-cache-manager"
   },
-  "gitHead": "56ff8bc05dfaf32745361c9685fe276ddc5f8478"
+  "gitHead": "a4d35e7c49768aee0a7e487f0bf7ec0a88a3f33b"
 }

package/test/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": "exzeo/mocha"
+}

package/test/cacheManager.test.js

@@ -105,7 +105,7 @@ context('Test User Profile Middleware', () => {
         const result = await app1.getItem(cacheKey);
         expect(result).to.not.be.ok();
       } catch (ex) {
-        expect(ex.message).to.be.equal('pool is draining and cannot accept work');
+        expect(ex.message).to.be.equal('GET can\'t be processed. The connection is already closed.');
         const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('close'));
         expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
       }
@@ -122,7 +122,6 @@ context('Test User Profile Middleware', () => {
     it('validate the cacheStorePool', () => {
       const catchepool = app.cacheStorePool;
       expect(app).to.not.eql(null);
-      expect(catchepool.db).to.eql(0);
       expect(catchepool._maxListeners).to.eql(0);
     });