cache-manager-memory-store-with-ttl 1.0.13 → 1.0.14

package/dist/memory-store.js

@@ -0,0 +1,259 @@
+/* eslint no-unused-vars:0 */
+const Lru = require('lru-cache');
+const cloneDeep = require('lodash.clonedeep');
+const utils = require('./utils');
+
+const { isObject } = utils;
+
+function clone(object) {
+  if (typeof object === 'object' && object !== null) {
+    return cloneDeep(object);
+  }
+  return object;
+}
+
+/**
+ * Wrapper for lru-cache.
+ * NOTE: If you want to use a memory store, you want to write your own to have full
+ * control over its behavior.  E.g., you might need the extra Promise overhead or
+ * you may want to clone objects a certain way before storing.
+ *
+ * @param {object} args - Args passed to underlying lru-cache, plus additional optional args:
+ * @param {boolean} [args.shouldCloneBeforeSet=true] - Whether to clone the data being stored.
+ *   Default: true
+ * @param {boolean} [args.usePromises=true] - Whether to enable the use of Promises. Default: true
+ */
+const memoryStore = function (args) {
+  args = args || {};
+  const self = {};
+  self.name = 'memory';
+  const Promise = args.promiseDependency || global.Promise;
+  self.usePromises = !(typeof Promise === 'undefined' || args.noPromises);
+  self.shouldCloneBeforeSet = args.shouldCloneBeforeSet !== false; // clone by default
+
+  const lruOpts = {
+    max: args.max || 500,
+    maxSize: args.maxSize,
+    ttl: args.ttl || args.ttl === 0 ? args.ttl * 1000 : undefined,
+    dispose: args.dispose,
+    sizeCalculation: args.sizeCalculation || args.length,
+    allowStale: args.allowStale || args.stale,
+    updateAgeOnGet: args.updateAgeOnGet,
+    updateAgeOnHas: args.updateAgeOnHas,
+  };
+
+  const lruCache = new Lru(lruOpts);
+
+  const setMultipleKeys = function setMultipleKeys(keysValues, ttl) {
+    const { length } = keysValues;
+    const values = [];
+    for (let i = 0; i < length; i += 2) {
+      lruCache.set(keysValues[i], keysValues[i + 1], { ttl });
+      values.push(keysValues[i + 1]);
+    }
+    return values;
+  };
+
+  self.set = function (key, value, options, cb) {
+    if (self.shouldCloneBeforeSet) {
+      value = clone(value);
+    }
+
+    if (typeof options === 'function') {
+      cb = options;
+      options = {};
+    }
+    options = options || {};
+
+    if (options && typeof options === 'number') {
+      options = { ttl: options };
+    }
+
+    const ttl =
+      options.ttl || options.ttl === 0 ? options.ttl * 1000 : lruOpts.ttl;
+
+    lruCache.set(key, value, { ttl });
+    if (cb) {
+      process.nextTick(cb.bind(null, null));
+    } else if (self.usePromises) {
+      return Promise.resolve(value);
+    }
+  };
+
+  self.mset = function () {
+    const args = Array.prototype.slice.apply(arguments);
+    let cb;
+    let options = {};
+
+    if (typeof args[args.length - 1] === 'function') {
+      cb = args.pop();
+    }
+
+    if (args.length % 2 > 0 && isObject(args[args.length - 1])) {
+      options = args.pop();
+    }
+
+    const ttl =
+      options.ttl || options.ttl === 0 ? options.ttl * 1000 : lruOpts.ttl;
+
+    const values = setMultipleKeys(args, ttl);
+
+    if (cb) {
+      process.nextTick(cb.bind(null, null));
+    } else if (self.usePromises) {
+      return Promise.resolve(values);
+    }
+  };
+
+  self.get = function (key, options, cb) {
+    if (typeof options === 'function') {
+      cb = options;
+    }
+    const value = lruCache.get(key);
+
+    if (cb) {
+      process.nextTick(cb.bind(null, null, value));
+    } else if (self.usePromises) {
+      return Promise.resolve(value);
+    } else {
+      return value;
+    }
+  };
+
+  self.mget = function () {
+    const args = Array.prototype.slice.apply(arguments);
+    let cb;
+    let options = {};
+
+    if (typeof args[args.length - 1] === 'function') {
+      cb = args.pop();
+    }
+
+    if (isObject(args[args.length - 1])) {
+      options = args.pop();
+    }
+
+    const values = args.map(function (key) {
+      return lruCache.get(key);
+    });
+
+    if (cb) {
+      process.nextTick(cb.bind(null, null, values));
+    } else if (self.usePromises) {
+      return Promise.resolve(values);
+    } else {
+      return values;
+    }
+  };
+
+  self.ttl = function (key, cb) {
+    const value = lruCache.getRemainingTTL(key);
+
+    if (cb) {
+      process.nextTick(cb.bind(null, null, value));
+    } else if (self.usePromises) {
+      return Promise.resolve(value);
+    } else {
+      return value;
+    }
+  };
+
+  self.del = function () {
+    let args = Array.prototype.slice.apply(arguments);
+    let cb;
+    let options = {};
+
+    if (typeof args[args.length - 1] === 'function') {
+      cb = args.pop();
+    }
+
+    if (isObject(args[args.length - 1])) {
+      options = args.pop();
+    }
+
+    if (Array.isArray(args[0])) {
+      args = args[0];
+    }
+
+    args.forEach(function (key) {
+      lruCache.delete(key);
+    });
+
+    if (cb) {
+      process.nextTick(cb.bind(null, null));
+    } else if (self.usePromises) {
+      return Promise.resolve();
+    }
+  };
+
+  self.reset = function (cb) {
+    lruCache.clear();
+    if (cb) {
+      process.nextTick(cb.bind(null, null));
+    } else if (self.usePromises) {
+      return Promise.resolve();
+    }
+  };
+
+  self.keys = function (cb) {
+    const keys = [...lruCache.keys()];
+    if (cb) {
+      process.nextTick(cb.bind(null, null, keys));
+    } else if (self.usePromises) {
+      return Promise.resolve(keys);
+    } else {
+      return keys;
+    }
+  };
+
+  /**
+   * This method is not available in the caching modules.
+   */
+  self.keyCount = function () {
+    return lruCache.size;
+  };
+
+  /**
+   * This method is not available in the caching modules.
+   */
+  self.dump = function () {
+    const args = Array.prototype.slice.apply(arguments);
+    let cb;
+
+    if (typeof args[args.length - 1] === 'function') {
+      cb = args.pop();
+    }
+    const value = lruCache.dump();
+
+    if (cb) {
+      process.nextTick(cb.bind(null, null, value));
+    } else if (self.usePromises) {
+      return Promise.resolve(value);
+    } else {
+      return value;
+    }
+  };
+
+  /**
+   * This method is not available in the caching modules.
+   */
+  self.load = function (cacheEntries, cb) {
+    lruCache.load(cacheEntries);
+
+    if (typeof cb === 'function') {
+      process.nextTick(cb.bind(null, null));
+    } else if (self.usePromises) {
+      return Promise.resolve();
+    }
+  };
+
+  return self;
+};
+
+const methods = {
+  create(args) {
+    return memoryStore(args);
+  },
+};
+
+module.exports = methods;

package/dist/utils.js

@@ -0,0 +1,42 @@
+var isObject = function isObject(value) {
+  return value instanceof Object && value.constructor === Object;
+};
+
+var parseWrapArguments = function parseWrapArguments(args) {
+  var length = args.length;
+  var work;
+  var options = {};
+  var cb;
+
+  /**
+   * As we can receive an unlimited number of keys
+   * we find the index of the first function which is
+   * the "work" handler to fetch the keys.
+   */
+  for (var i = 0; i < length; i += 1) {
+      if (typeof args[i] === 'function') {
+          if (typeof args[i + 2] === 'function') {
+              cb = args.pop();
+          } else if (typeof args[i + 1] === 'function') {
+              cb = args.pop();
+          }
+          if (isObject(args[i + 1])) {
+              options = args.pop();
+          }
+          work = args.pop();
+          break;
+      }
+  }
+
+  return {
+      keys: args,
+      work: work,
+      options: options,
+      cb: cb
+  };
+};
+
+module.exports = {
+  isObject: isObject,
+  parseWrapArguments: parseWrapArguments
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "cache-manager-memory-store-with-ttl",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "",
   "main": "dist/index.js",
   "files": [
-    "dist/**/*"
+    "dist/*"
   ],
   "scripts": {
     "test": "jest",