|
|
/* |
|
|
* node-cache 4.2.1 ( 2019-07-24 ) |
|
|
* https://github.com/mpneuried/nodecache |
|
|
* |
|
|
* Released under the MIT license |
|
|
* https://github.com/mpneuried/nodecache/blob/master/LICENSE |
|
|
* |
|
|
* Maintained by ( ) |
|
|
*/ |
|
|
(function() { |
|
|
// lodash requires |
|
|
var EventEmitter, NodeCache, _assignIn, _isArray, _isFunction, _isNumber, _isObject, _isString, _size, _template, clone, |
|
|
boundMethodCheck = function(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new Error('Bound instance method accessed before binding'); } }, |
|
|
indexOf = [].indexOf; |
|
|
|
|
|
_assignIn = require("lodash/assignIn"); |
|
|
|
|
|
_isArray = require("lodash/isArray"); |
|
|
|
|
|
_isString = require("lodash/isString"); |
|
|
|
|
|
_isFunction = require("lodash/isFunction"); |
|
|
|
|
|
_isNumber = require("lodash/isNumber"); |
|
|
|
|
|
_isObject = require("lodash/isObject"); |
|
|
|
|
|
_size = require("lodash/size"); |
|
|
|
|
|
_template = require("lodash/template"); |
|
|
|
|
|
clone = require("clone"); |
|
|
|
|
|
EventEmitter = require('events').EventEmitter; |
|
|
|
|
|
// generate superclass |
|
|
module.exports = NodeCache = (function() { |
|
|
class NodeCache extends EventEmitter { |
|
|
constructor(options = {}) { |
|
|
super(); |
|
|
// ## get |
|
|
|
|
|
// get a cached key and change the stats |
|
|
|
|
|
// **Parameters:** |
|
|
|
|
|
// * `key` ( String | Number ): cache key |
|
|
// * `[cb]` ( Function ): Callback function |
|
|
// * `[errorOnMissing=false]` ( Boolean ) return a error to the `cb` or throw it if no `cb` is used. Otherwise the get will return `undefined` on a miss. |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// myCache.get "myKey", ( err, val )-> |
|
|
// console.log( err, val ) |
|
|
// return |
|
|
|
|
|
this.get = this.get.bind(this); |
|
|
// ## mget |
|
|
|
|
|
// get multiple cached keys at once and change the stats |
|
|
|
|
|
// **Parameters:** |
|
|
|
|
|
// * `keys` ( String|Number[] ): an array of keys |
|
|
// * `[cb]` ( Function ): Callback function |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// myCache.mget [ "foo", "bar" ], ( err, val )-> |
|
|
// console.log( err, val ) |
|
|
// return |
|
|
|
|
|
this.mget = this.mget.bind(this); |
|
|
// ## set |
|
|
|
|
|
// set a cached key and change the stats |
|
|
|
|
|
// **Parameters:** |
|
|
|
|
|
// * `key` ( String | Number ): cache key |
|
|
// * `value` ( Any ): A element to cache. If the option `option.forceString` is `true` the module trys to translate it to a serialized JSON |
|
|
// * `[ ttl ]` ( Number | String ): ( optional ) The time to live in seconds. |
|
|
// * `[cb]` ( Function ): Callback function |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// myCache.set "myKey", "my_String Value", ( err, success )-> |
|
|
// console.log( err, success ) |
|
|
|
|
|
// myCache.set "myKey", "my_String Value", "10", ( err, success )-> |
|
|
// console.log( err, success ) |
|
|
|
|
|
this.set = this.set.bind(this); |
|
|
// ## del |
|
|
|
|
|
// remove keys |
|
|
|
|
|
// **Parameters:** |
|
|
|
|
|
// * `keys` ( String | Number | String|Number[] ): cache key to delete or a array of cache keys |
|
|
// * `[cb]` ( Function ): Callback function |
|
|
|
|
|
// **Return** |
|
|
|
|
|
// ( Number ): Number of deleted keys |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// myCache.del( "myKey" ) |
|
|
|
|
|
// myCache.del( "myKey", ( err, delCount )-> |
|
|
// console.log( err, delCount ) |
|
|
// return |
|
|
this.del = this.del.bind(this); |
|
|
// ## ttl |
|
|
|
|
|
// reset or redefine the ttl of a key. `ttl` = 0 means infinite lifetime. |
|
|
// If `ttl` is not passed the default ttl is used. |
|
|
// If `ttl` < 0 the key will be deleted. |
|
|
|
|
|
// **Parameters:** |
|
|
|
|
|
// * `key` ( String | Number ): cache key to reset the ttl value |
|
|
// * `ttl` ( Number ): ( optional -> options.stdTTL || 0 ) The time to live in seconds |
|
|
// * `[cb]` ( Function ): Callback function |
|
|
|
|
|
// **Return** |
|
|
|
|
|
// ( Boolen ): key found and ttl set |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// myCache.ttl( "myKey" ) // will set ttl to default ttl |
|
|
|
|
|
// myCache.ttl( "myKey", 1000, ( err, keyFound )-> |
|
|
// console.log( err, success ) |
|
|
|
|
|
this.ttl = this.ttl.bind(this); |
|
|
// ## getTtl |
|
|
|
|
|
// receive the ttl of a key. |
|
|
|
|
|
// **Parameters:** |
|
|
|
|
|
// * `key` ( String | Number ): cache key to check the ttl value |
|
|
// * `[cb]` ( Function ): Callback function |
|
|
|
|
|
// **Return** |
|
|
|
|
|
// ( Number|undefined ): The timestamp in ms when the key will expire, 0 if it will never expire or undefined if it not exists |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// ts = myCache.getTtl( "myKey" ) |
|
|
|
|
|
// myCache.getTtl( "myKey",( err, ttl )-> |
|
|
// console.log( err, ttl ) |
|
|
// return |
|
|
|
|
|
this.getTtl = this.getTtl.bind(this); |
|
|
// ## keys |
|
|
|
|
|
// list all keys within this cache |
|
|
|
|
|
// **Parameters:** |
|
|
|
|
|
// * `[cb]` ( Function ): Callback function |
|
|
|
|
|
// **Return** |
|
|
|
|
|
// ( Array ): An array of all keys |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// _keys = myCache.keys() |
|
|
|
|
|
// # [ "foo", "bar", "fizz", "buzz", "anotherKeys" ] |
|
|
|
|
|
this.keys = this.keys.bind(this); |
|
|
// ## getStats |
|
|
|
|
|
// get the stats |
|
|
|
|
|
// **Parameters:** |
|
|
|
|
|
// - |
|
|
|
|
|
// **Return** |
|
|
|
|
|
// ( Object ): Stats data |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// myCache.getStats() |
|
|
// # { |
|
|
// # hits: 0, |
|
|
// # misses: 0, |
|
|
// # keys: 0, |
|
|
// # ksize: 0, |
|
|
// # vsize: 0 |
|
|
// # } |
|
|
|
|
|
this.getStats = this.getStats.bind(this); |
|
|
// ## flushAll |
|
|
|
|
|
// flush the whole data and reset the stats |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// myCache.flushAll() |
|
|
|
|
|
// myCache.getStats() |
|
|
// # { |
|
|
// # hits: 0, |
|
|
// # misses: 0, |
|
|
// # keys: 0, |
|
|
// # ksize: 0, |
|
|
// # vsize: 0 |
|
|
// # } |
|
|
|
|
|
this.flushAll = this.flushAll.bind(this); |
|
|
// ## close |
|
|
|
|
|
// This will clear the interval timeout which is set on checkperiod option. |
|
|
|
|
|
// **Example:** |
|
|
|
|
|
// myCache.close() |
|
|
|
|
|
this.close = this.close.bind(this); |
|
|
// ## _checkData |
|
|
|
|
|
// internal housekeeping method. |
|
|
// Check all the cached data and delete the invalid values |
|
|
this._checkData = this._checkData.bind(this); |
|
|
// ## _check |
|
|
|
|
|
// internal method the check the value. If it's not valid any more delete it |
|
|
this._check = this._check.bind(this); |
|
|
// ## _isInvalidKey |
|
|
|
|
|
// internal method to check if the type of a key is either `number` or `string` |
|
|
this._isInvalidKey = this._isInvalidKey.bind(this); |
|
|
// ## _wrap |
|
|
|
|
|
// internal method to wrap a value in an object with some metadata |
|
|
this._wrap = this._wrap.bind(this); |
|
|
// ## _getValLength |
|
|
|
|
|
// internal method to calculate the value length |
|
|
this._getValLength = this._getValLength.bind(this); |
|
|
// ## _error |
|
|
|
|
|
// internal method to handle an error message |
|
|
this._error = this._error.bind(this); |
|
|
// ## _initErrors |
|
|
|
|
|
// internal method to generate error message templates |
|
|
this._initErrors = this._initErrors.bind(this); |
|
|
this.options = options; |
|
|
this._initErrors(); |
|
|
// container for cached data |
|
|
this.data = {}; |
|
|
// module options |
|
|
this.options = _assignIn({ |
|
|
// convert all elements to string |
|
|
forceString: false, |
|
|
// used standard size for calculating value size |
|
|
objectValueSize: 80, |
|
|
promiseValueSize: 80, |
|
|
arrayValueSize: 40, |
|
|
// standard time to live in seconds. 0 = infinity; |
|
|
stdTTL: 0, |
|
|
// time in seconds to check all data and delete expired keys |
|
|
checkperiod: 600, |
|
|
// en/disable cloning of variables. If `true` you'll get a copy of the cached variable. If `false` you'll save and get just the reference |
|
|
useClones: true, |
|
|
// en/disable throwing errors when trying to `.get` missing or expired values. |
|
|
errorOnMissing: false, |
|
|
// whether values should be deleted automatically at expiration |
|
|
deleteOnExpire: true |
|
|
}, this.options); |
|
|
// statistics container |
|
|
this.stats = { |
|
|
hits: 0, |
|
|
misses: 0, |
|
|
keys: 0, |
|
|
ksize: 0, |
|
|
vsize: 0 |
|
|
}; |
|
|
// pre allocate valid keytypes array |
|
|
this.validKeyTypes = ["string", "number"]; |
|
|
// initalize checking period |
|
|
this._checkData(); |
|
|
return; |
|
|
} |
|
|
|
|
|
get(key, cb, errorOnMissing) { |
|
|
var _err, _ret, err; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
// handle passing in errorOnMissing without cb |
|
|
if (typeof cb === "boolean" && arguments.length === 2) { |
|
|
errorOnMissing = cb; |
|
|
cb = void 0; |
|
|
} |
|
|
// handle invalid key types |
|
|
if ((err = this._isInvalidKey(key)) != null) { |
|
|
if (cb != null) { |
|
|
cb(err); |
|
|
return; |
|
|
} else { |
|
|
throw err; |
|
|
} |
|
|
} |
|
|
// get data and incremet stats |
|
|
if ((this.data[key] != null) && this._check(key, this.data[key])) { |
|
|
this.stats.hits++; |
|
|
_ret = this._unwrap(this.data[key]); |
|
|
if (cb != null) { |
|
|
// return data |
|
|
cb(null, _ret); |
|
|
} |
|
|
return _ret; |
|
|
} else { |
|
|
// if not found return a error |
|
|
this.stats.misses++; |
|
|
if (this.options.errorOnMissing || errorOnMissing) { |
|
|
_err = this._error("ENOTFOUND", { |
|
|
key: key |
|
|
}, cb); |
|
|
if (_err != null) { |
|
|
throw _err; |
|
|
} |
|
|
return; |
|
|
} else { |
|
|
if (cb != null) { |
|
|
cb(null, void 0); |
|
|
} |
|
|
} |
|
|
return void 0; |
|
|
} |
|
|
} |
|
|
|
|
|
mget(keys, cb) { |
|
|
var _err, err, i, key, len, oRet; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
// convert a string to an array of one key |
|
|
if (!_isArray(keys)) { |
|
|
_err = this._error("EKEYSTYPE"); |
|
|
if (cb != null) { |
|
|
cb(_err); |
|
|
} |
|
|
return _err; |
|
|
} |
|
|
// define return |
|
|
oRet = {}; |
|
|
for (i = 0, len = keys.length; i < len; i++) { |
|
|
key = keys[i]; |
|
|
// handle invalid key types |
|
|
if ((err = this._isInvalidKey(key)) != null) { |
|
|
if (cb != null) { |
|
|
cb(err); |
|
|
return; |
|
|
} else { |
|
|
throw err; |
|
|
} |
|
|
} |
|
|
// get data and increment stats |
|
|
if ((this.data[key] != null) && this._check(key, this.data[key])) { |
|
|
this.stats.hits++; |
|
|
oRet[key] = this._unwrap(this.data[key]); |
|
|
} else { |
|
|
// if not found return a error |
|
|
this.stats.misses++; |
|
|
} |
|
|
} |
|
|
if (cb != null) { |
|
|
// return all found keys |
|
|
cb(null, oRet); |
|
|
} |
|
|
return oRet; |
|
|
} |
|
|
|
|
|
set(key, value, ttl, cb) { |
|
|
var err, existent; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
// force the data to string |
|
|
if (this.options.forceString && !_isString(value)) { |
|
|
value = JSON.stringify(value); |
|
|
} |
|
|
// remap the arguments if `ttl` is not passed |
|
|
if (arguments.length === 3 && _isFunction(ttl)) { |
|
|
cb = ttl; |
|
|
ttl = this.options.stdTTL; |
|
|
} |
|
|
// handle invalid key types |
|
|
if ((err = this._isInvalidKey(key)) != null) { |
|
|
if (cb != null) { |
|
|
cb(err); |
|
|
return; |
|
|
} else { |
|
|
throw err; |
|
|
} |
|
|
} |
|
|
// internal helper variables |
|
|
existent = false; |
|
|
// remove existing data from stats |
|
|
if (this.data[key]) { |
|
|
existent = true; |
|
|
this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false)); |
|
|
} |
|
|
// set the value |
|
|
this.data[key] = this._wrap(value, ttl); |
|
|
this.stats.vsize += this._getValLength(value); |
|
|
// only add the keys and key-size if the key is new |
|
|
if (!existent) { |
|
|
this.stats.ksize += this._getKeyLength(key); |
|
|
this.stats.keys++; |
|
|
} |
|
|
this.emit("set", key, value); |
|
|
if (cb != null) { |
|
|
// return true |
|
|
cb(null, true); |
|
|
} |
|
|
return true; |
|
|
} |
|
|
|
|
|
del(keys, cb) { |
|
|
var delCount, err, i, key, len, oldVal; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
// convert keys to an array of itself |
|
|
if (!_isArray(keys)) { |
|
|
keys = [keys]; |
|
|
} |
|
|
delCount = 0; |
|
|
for (i = 0, len = keys.length; i < len; i++) { |
|
|
key = keys[i]; |
|
|
// handle invalid key types |
|
|
if ((err = this._isInvalidKey(key)) != null) { |
|
|
if (cb != null) { |
|
|
cb(err); |
|
|
return; |
|
|
} else { |
|
|
throw err; |
|
|
} |
|
|
} |
|
|
// only delete if existent |
|
|
if (this.data[key] != null) { |
|
|
// calc the stats |
|
|
this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false)); |
|
|
this.stats.ksize -= this._getKeyLength(key); |
|
|
this.stats.keys--; |
|
|
delCount++; |
|
|
// delete the value |
|
|
oldVal = this.data[key]; |
|
|
delete this.data[key]; |
|
|
// return true |
|
|
this.emit("del", key, oldVal.v); |
|
|
} else { |
|
|
// if the key has not been found return an error |
|
|
this.stats.misses++; |
|
|
} |
|
|
} |
|
|
if (cb != null) { |
|
|
cb(null, delCount); |
|
|
} |
|
|
return delCount; |
|
|
} |
|
|
|
|
|
ttl() { |
|
|
var arg, args, cb, err, i, key, len, ttl; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
// change args if only key and callback are passed |
|
|
[key, ...args] = arguments; |
|
|
for (i = 0, len = args.length; i < len; i++) { |
|
|
arg = args[i]; |
|
|
switch (typeof arg) { |
|
|
case "number": |
|
|
ttl = arg; |
|
|
break; |
|
|
case "function": |
|
|
cb = arg; |
|
|
} |
|
|
} |
|
|
ttl || (ttl = this.options.stdTTL); |
|
|
if (!key) { |
|
|
if (cb != null) { |
|
|
cb(null, false); |
|
|
} |
|
|
return false; |
|
|
} |
|
|
// handle invalid key types |
|
|
if ((err = this._isInvalidKey(key)) != null) { |
|
|
if (cb != null) { |
|
|
cb(err); |
|
|
return; |
|
|
} else { |
|
|
throw err; |
|
|
} |
|
|
} |
|
|
// check for existant data and update the ttl value |
|
|
if ((this.data[key] != null) && this._check(key, this.data[key])) { |
|
|
// if ttl < 0 delete the key. otherwise reset the value |
|
|
if (ttl >= 0) { |
|
|
this.data[key] = this._wrap(this.data[key].v, ttl, false); |
|
|
} else { |
|
|
this.del(key); |
|
|
} |
|
|
if (cb != null) { |
|
|
cb(null, true); |
|
|
} |
|
|
return true; |
|
|
} else { |
|
|
if (cb != null) { |
|
|
// return false if key has not been found |
|
|
cb(null, false); |
|
|
} |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
getTtl(key, cb) { |
|
|
var _ttl, err; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
if (!key) { |
|
|
if (cb != null) { |
|
|
cb(null, void 0); |
|
|
} |
|
|
return void 0; |
|
|
} |
|
|
// handle invalid key types |
|
|
if ((err = this._isInvalidKey(key)) != null) { |
|
|
if (cb != null) { |
|
|
cb(err); |
|
|
return; |
|
|
} else { |
|
|
throw err; |
|
|
} |
|
|
} |
|
|
// check for existant data and update the ttl value |
|
|
if ((this.data[key] != null) && this._check(key, this.data[key])) { |
|
|
_ttl = this.data[key].t; |
|
|
if (cb != null) { |
|
|
cb(null, _ttl); |
|
|
} |
|
|
return _ttl; |
|
|
} else { |
|
|
if (cb != null) { |
|
|
// return undefined if key has not been found |
|
|
cb(null, void 0); |
|
|
} |
|
|
return void 0; |
|
|
} |
|
|
} |
|
|
|
|
|
keys(cb) { |
|
|
var _keys; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
_keys = Object.keys(this.data); |
|
|
if (cb != null) { |
|
|
cb(null, _keys); |
|
|
} |
|
|
return _keys; |
|
|
} |
|
|
|
|
|
getStats() { |
|
|
boundMethodCheck(this, NodeCache); |
|
|
return this.stats; |
|
|
} |
|
|
|
|
|
flushAll(_startPeriod = true) { |
|
|
boundMethodCheck(this, NodeCache); |
|
|
// parameter just for testing |
|
|
|
|
|
// set data empty |
|
|
this.data = {}; |
|
|
// reset stats |
|
|
this.stats = { |
|
|
hits: 0, |
|
|
misses: 0, |
|
|
keys: 0, |
|
|
ksize: 0, |
|
|
vsize: 0 |
|
|
}; |
|
|
// reset check period |
|
|
this._killCheckPeriod(); |
|
|
this._checkData(_startPeriod); |
|
|
this.emit("flush"); |
|
|
} |
|
|
|
|
|
close() { |
|
|
boundMethodCheck(this, NodeCache); |
|
|
this._killCheckPeriod(); |
|
|
} |
|
|
|
|
|
_checkData(startPeriod = true) { |
|
|
var key, ref, value; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
ref = this.data; |
|
|
// run the housekeeping method |
|
|
for (key in ref) { |
|
|
value = ref[key]; |
|
|
this._check(key, value); |
|
|
} |
|
|
if (startPeriod && this.options.checkperiod > 0) { |
|
|
this.checkTimeout = setTimeout(this._checkData, this.options.checkperiod * 1000, startPeriod); |
|
|
if (this.checkTimeout.unref != null) { |
|
|
this.checkTimeout.unref(); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
// ## _killCheckPeriod |
|
|
|
|
|
// stop the checkdata period. Only needed to abort the script in testing mode. |
|
|
_killCheckPeriod() { |
|
|
if (this.checkTimeout != null) { |
|
|
return clearTimeout(this.checkTimeout); |
|
|
} |
|
|
} |
|
|
|
|
|
_check(key, data) { |
|
|
var _retval; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
_retval = true; |
|
|
// data is invalid if the ttl is too old and is not 0 |
|
|
// console.log data.t < Date.now(), data.t, Date.now() |
|
|
if (data.t !== 0 && data.t < Date.now()) { |
|
|
if (this.options.deleteOnExpire) { |
|
|
_retval = false; |
|
|
this.del(key); |
|
|
} |
|
|
this.emit("expired", key, this._unwrap(data)); |
|
|
} |
|
|
return _retval; |
|
|
} |
|
|
|
|
|
_isInvalidKey(key) { |
|
|
var ref; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
if (ref = typeof key, indexOf.call(this.validKeyTypes, ref) < 0) { |
|
|
return this._error("EKEYTYPE", { |
|
|
type: typeof key |
|
|
}); |
|
|
} |
|
|
} |
|
|
|
|
|
_wrap(value, ttl, asClone = true) { |
|
|
var livetime, now, oReturn, ttlMultiplicator; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
if (!this.options.useClones) { |
|
|
asClone = false; |
|
|
} |
|
|
// define the time to live |
|
|
now = Date.now(); |
|
|
livetime = 0; |
|
|
ttlMultiplicator = 1000; |
|
|
// use given ttl |
|
|
if (ttl === 0) { |
|
|
livetime = 0; |
|
|
} else if (ttl) { |
|
|
livetime = now + (ttl * ttlMultiplicator); |
|
|
} else { |
|
|
// use standard ttl |
|
|
if (this.options.stdTTL === 0) { |
|
|
livetime = this.options.stdTTL; |
|
|
} else { |
|
|
livetime = now + (this.options.stdTTL * ttlMultiplicator); |
|
|
} |
|
|
} |
|
|
// return the wrapped value |
|
|
return oReturn = { |
|
|
t: livetime, |
|
|
v: asClone ? clone(value) : value |
|
|
}; |
|
|
} |
|
|
|
|
|
// ## _unwrap |
|
|
|
|
|
// internal method to extract get the value out of the wrapped value |
|
|
_unwrap(value, asClone = true) { |
|
|
if (!this.options.useClones) { |
|
|
asClone = false; |
|
|
} |
|
|
if (value.v != null) { |
|
|
if (asClone) { |
|
|
return clone(value.v); |
|
|
} else { |
|
|
return value.v; |
|
|
} |
|
|
} |
|
|
return null; |
|
|
} |
|
|
|
|
|
// ## _getKeyLength |
|
|
|
|
|
// internal method the calculate the key length |
|
|
_getKeyLength(key) { |
|
|
return key.length; |
|
|
} |
|
|
|
|
|
_getValLength(value) { |
|
|
boundMethodCheck(this, NodeCache); |
|
|
if (_isString(value)) { |
|
|
// if the value is a String get the real length |
|
|
return value.length; |
|
|
} else if (this.options.forceString) { |
|
|
// force string if it's defined and not passed |
|
|
return JSON.stringify(value).length; |
|
|
} else if (_isArray(value)) { |
|
|
// if the data is an Array multiply each element with a defined default length |
|
|
return this.options.arrayValueSize * value.length; |
|
|
} else if (_isNumber(value)) { |
|
|
return 8; |
|
|
} else if (typeof (value != null ? value.then : void 0) === "function") { |
|
|
// if the data is a Promise, use defined default |
|
|
// (can't calculate actual/resolved value size synchronously) |
|
|
return this.options.promiseValueSize; |
|
|
} else if (_isObject(value)) { |
|
|
// if the data is an Object multiply each element with a defined default length |
|
|
return this.options.objectValueSize * _size(value); |
|
|
} else { |
|
|
// default fallback |
|
|
return 0; |
|
|
} |
|
|
} |
|
|
|
|
|
_error(type, data = {}, cb) { |
|
|
var error; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
// generate the error object |
|
|
error = new Error(); |
|
|
error.name = type; |
|
|
error.errorcode = type; |
|
|
error.message = this.ERRORS[type] != null ? this.ERRORS[type](data) : "-"; |
|
|
error.data = data; |
|
|
if (cb && _isFunction(cb)) { |
|
|
// return the error |
|
|
cb(error, null); |
|
|
} else { |
|
|
// if no callback is defined return the error object |
|
|
return error; |
|
|
} |
|
|
} |
|
|
|
|
|
_initErrors() { |
|
|
var _errMsg, _errT, ref; |
|
|
boundMethodCheck(this, NodeCache); |
|
|
this.ERRORS = {}; |
|
|
ref = this._ERRORS; |
|
|
for (_errT in ref) { |
|
|
_errMsg = ref[_errT]; |
|
|
this.ERRORS[_errT] = _template(_errMsg); |
|
|
} |
|
|
} |
|
|
|
|
|
}; |
|
|
|
|
|
NodeCache.prototype._ERRORS = { |
|
|
"ENOTFOUND": "Key `<%= key %>` not found", |
|
|
"EKEYTYPE": "The key argument has to be of type `string` or `number`. Found: `<%= type %>`", |
|
|
"EKEYSTYPE": "The keys argument has to be an array." |
|
|
}; |
|
|
|
|
|
return NodeCache; |
|
|
|
|
|
}).call(this); |
|
|
|
|
|
}).call(this);
|
|
|
|
