exframe-cache-manager 1.3.2 → 1.3.3

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

@@ -9,7 +9,6 @@ RUN apk update && \
 COPY ./package.json /app/package.json
 WORKDIR /app
 RUN npm install && \
-  npm run pretest
   npm cache clean --force
 
 COPY . /app

package/index.js

@@ -1,208 +1,206 @@
-'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');
+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 {
+          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');
+      });
+    },
+    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
+ */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exframe-cache-manager",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Managing the cache",
   "main": "index.js",
   "config": {
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "pretest": "npm-install-peers && npm run lint",
-    "lint": "./node_modules/.bin/eslint .",
+    "lint": "eslint ./",
     "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\""
   },
@@ -33,7 +33,7 @@
   "devDependencies": {
     "chai": "^4.3.4",
     "eslint": "^8.3.0",
-    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-exzeo": "*",
     "eslint-plugin-import": "^2.25.3",
     "mocha": "*",
     "mocha-exzeo-reporter": "0.0.3",
@@ -45,5 +45,5 @@
     "url": "https://bitbucket.org/exzeo-usa/exframe",
     "directory": "packages/exframe-cache-manager"
   },
-  "gitHead": "56ff8bc05dfaf32745361c9685fe276ddc5f8478"
+  "gitHead": "ef87c842aa08c54cbcb03ee075db8463ebc8fd43"
 }

package/test/.eslintrc.json

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