cacheable 0.2.9 → 0.8.0

package/dist/index.js

@@ -0,0 +1,421 @@
+// src/index.ts
+import { Keyv } from "keyv";
+import { Hookified } from "hookified";
+
+// src/stats.ts
+var CacheableStats = class {
+  _hits = 0;
+  _misses = 0;
+  _gets = 0;
+  _sets = 0;
+  _deletes = 0;
+  _clears = 0;
+  _vsize = 0;
+  _ksize = 0;
+  _count = 0;
+  _enabled = false;
+  constructor(options) {
+    if (options?.enabled) {
+      this._enabled = options.enabled;
+    }
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(enabled) {
+    this._enabled = enabled;
+  }
+  get hits() {
+    return this._hits;
+  }
+  get misses() {
+    return this._misses;
+  }
+  get gets() {
+    return this._gets;
+  }
+  get sets() {
+    return this._sets;
+  }
+  get deletes() {
+    return this._deletes;
+  }
+  get clears() {
+    return this._clears;
+  }
+  get vsize() {
+    return this._vsize;
+  }
+  get ksize() {
+    return this._ksize;
+  }
+  get count() {
+    return this._count;
+  }
+  incrementHits() {
+    if (!this._enabled) {
+      return;
+    }
+    this._hits++;
+  }
+  incrementMisses() {
+    if (!this._enabled) {
+      return;
+    }
+    this._misses++;
+  }
+  incrementGets() {
+    if (!this._enabled) {
+      return;
+    }
+    this._gets++;
+  }
+  incrementSets() {
+    if (!this._enabled) {
+      return;
+    }
+    this._sets++;
+  }
+  incrementDeletes() {
+    if (!this._enabled) {
+      return;
+    }
+    this._deletes++;
+  }
+  incrementClears() {
+    if (!this._enabled) {
+      return;
+    }
+    this._clears++;
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  incrementVSize(value) {
+    if (!this._enabled) {
+      return;
+    }
+    this._vsize += this.roughSizeOfObject(value);
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  decreaseVSize(value) {
+    if (!this._enabled) {
+      return;
+    }
+    this._vsize -= this.roughSizeOfObject(value);
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  incrementKSize(key) {
+    if (!this._enabled) {
+      return;
+    }
+    this._ksize += this.roughSizeOfString(key);
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  decreaseKSize(key) {
+    if (!this._enabled) {
+      return;
+    }
+    this._ksize -= this.roughSizeOfString(key);
+  }
+  incrementCount() {
+    if (!this._enabled) {
+      return;
+    }
+    this._count++;
+  }
+  descreaseCount() {
+    if (!this._enabled) {
+      return;
+    }
+    this._count--;
+  }
+  setCount(count) {
+    if (!this._enabled) {
+      return;
+    }
+    this._count = count;
+  }
+  roughSizeOfString(value) {
+    return value.length * 2;
+  }
+  roughSizeOfObject(object) {
+    const objectList = [];
+    const stack = [object];
+    let bytes = 0;
+    while (stack.length > 0) {
+      const value = stack.pop();
+      if (typeof value === "boolean") {
+        bytes += 4;
+      } else if (typeof value === "string") {
+        bytes += value.length * 2;
+      } else if (typeof value === "number") {
+        bytes += 8;
+      } else if (typeof value === "object" && value !== null && !objectList.includes(value)) {
+        objectList.push(value);
+        for (const key in value) {
+          bytes += key.length * 2;
+          stack.push(value[key]);
+        }
+      }
+    }
+    return bytes;
+  }
+  reset() {
+    this._hits = 0;
+    this._misses = 0;
+    this._gets = 0;
+    this._sets = 0;
+    this._deletes = 0;
+    this._clears = 0;
+    this._vsize = 0;
+    this._ksize = 0;
+    this._count = 0;
+  }
+};
+
+// src/index.ts
+var CacheableHooks = /* @__PURE__ */ ((CacheableHooks2) => {
+  CacheableHooks2["BEFORE_SET"] = "BEFORE_SET";
+  CacheableHooks2["AFTER_SET"] = "AFTER_SET";
+  CacheableHooks2["BEFORE_SET_MANY"] = "BEFORE_SET_MANY";
+  CacheableHooks2["AFTER_SET_MANY"] = "AFTER_SET_MANY";
+  CacheableHooks2["BEFORE_GET"] = "BEFORE_GET";
+  CacheableHooks2["AFTER_GET"] = "AFTER_GET";
+  CacheableHooks2["BEFORE_GET_MANY"] = "BEFORE_GET_MANY";
+  CacheableHooks2["AFTER_GET_MANY"] = "AFTER_GET_MANY";
+  return CacheableHooks2;
+})(CacheableHooks || {});
+var CacheableEvents = /* @__PURE__ */ ((CacheableEvents2) => {
+  CacheableEvents2["ERROR"] = "error";
+  return CacheableEvents2;
+})(CacheableEvents || {});
+var Cacheable = class extends Hookified {
+  _primary = new Keyv();
+  _secondary;
+  _nonBlocking = false;
+  _stats = new CacheableStats({ enabled: false });
+  constructor(options) {
+    super();
+    if (options?.primary) {
+      this.setPrimary(options.primary);
+    }
+    if (options?.secondary) {
+      this.setSecondary(options.secondary);
+    }
+    if (options?.nonBlocking) {
+      this._nonBlocking = options.nonBlocking;
+    }
+    if (options?.stats) {
+      this._stats.enabled = options.stats;
+    }
+  }
+  get stats() {
+    return this._stats;
+  }
+  get primary() {
+    return this._primary;
+  }
+  set primary(primary) {
+    this._primary = primary;
+  }
+  get secondary() {
+    return this._secondary;
+  }
+  set secondary(secondary) {
+    this._secondary = secondary;
+  }
+  get nonBlocking() {
+    return this._nonBlocking;
+  }
+  set nonBlocking(nonBlocking) {
+    this._nonBlocking = nonBlocking;
+  }
+  setPrimary(primary) {
+    this._primary = primary instanceof Keyv ? primary : new Keyv(primary);
+  }
+  setSecondary(secondary) {
+    this._secondary = secondary instanceof Keyv ? secondary : new Keyv(secondary);
+  }
+  async get(key) {
+    let result;
+    try {
+      await this.hook("BEFORE_GET" /* BEFORE_GET */, key);
+      result = await this._primary.get(key);
+      if (!result && this._secondary) {
+        result = await this._secondary.get(key);
+        if (result) {
+          await this._primary.set(key, result);
+        }
+      }
+      await this.hook("AFTER_GET" /* AFTER_GET */, { key, result });
+    } catch (error) {
+      await this.emit("error" /* ERROR */, error);
+    }
+    return result;
+  }
+  async getMany(keys) {
+    let result = [];
+    try {
+      await this.hook("BEFORE_GET_MANY" /* BEFORE_GET_MANY */, keys);
+      result = await this._primary.get(keys);
+      if (this._secondary) {
+        const missingKeys = [];
+        for (const [i, key] of keys.entries()) {
+          if (!result[i]) {
+            missingKeys.push(key);
+          }
+        }
+        const secondaryResult = await this._secondary.get(missingKeys);
+        for (const [i, key] of keys.entries()) {
+          if (!result[i] && secondaryResult[i]) {
+            result[i] = secondaryResult[i];
+            await this._primary.set(key, secondaryResult[i]);
+          }
+        }
+      }
+      await this.hook("AFTER_GET_MANY" /* AFTER_GET_MANY */, { keys, result });
+    } catch (error) {
+      await this.emit("error" /* ERROR */, error);
+    }
+    return result;
+  }
+  async set(key, value, ttl) {
+    let result = false;
+    try {
+      await this.hook("BEFORE_SET" /* BEFORE_SET */, { key, value, ttl });
+      const promises = [];
+      promises.push(this._primary.set(key, value, ttl));
+      if (this._secondary) {
+        promises.push(this._secondary.set(key, value, ttl));
+      }
+      if (this._nonBlocking) {
+        result = await Promise.race(promises);
+      } else {
+        const results = await Promise.all(promises);
+        result = results[0];
+      }
+      await this.hook("AFTER_SET" /* AFTER_SET */, { key, value, ttl });
+    } catch (error) {
+      await this.emit("error" /* ERROR */, error);
+    }
+    return result;
+  }
+  async setMany(items) {
+    let result = false;
+    try {
+      await this.hook("BEFORE_SET_MANY" /* BEFORE_SET_MANY */, items);
+      result = await this.setManyKeyv(this._primary, items);
+      if (this._secondary) {
+        if (this._nonBlocking) {
+          this.setManyKeyv(this._secondary, items);
+        } else {
+          await this.setManyKeyv(this._secondary, items);
+        }
+      }
+      await this.hook("AFTER_SET_MANY" /* AFTER_SET_MANY */, items);
+    } catch (error) {
+      await this.emit("error" /* ERROR */, error);
+    }
+    return result;
+  }
+  async take(key) {
+    const result = await this.get(key);
+    await this.delete(key);
+    return result;
+  }
+  async takeMany(keys) {
+    const result = await this.getMany(keys);
+    await this.deleteMany(keys);
+    return result;
+  }
+  async has(key) {
+    let result = await this._primary.has(key);
+    if (!result && this._secondary) {
+      result = await this._secondary.has(key);
+    }
+    return result;
+  }
+  async hasMany(keys) {
+    const result = await this.hasManyKeyv(this._primary, keys);
+    const missingKeys = [];
+    for (const [i, key] of keys.entries()) {
+      if (!result[i] && this._secondary) {
+        missingKeys.push(key);
+      }
+    }
+    if (missingKeys.length > 0 && this._secondary) {
+      const secondary = await this.hasManyKeyv(this._secondary, keys);
+      for (const [i, key] of keys.entries()) {
+        if (!result[i] && secondary[i]) {
+          result[i] = secondary[i];
+        }
+      }
+    }
+    return result;
+  }
+  async delete(key) {
+    const result = await this._primary.delete(key);
+    if (this._secondary) {
+      if (this._nonBlocking) {
+        this._secondary.delete(key);
+      } else {
+        await this._secondary.delete(key);
+      }
+    }
+    return result;
+  }
+  async deleteMany(keys) {
+    const result = await this.deleteManyKeyv(this._primary, keys);
+    if (this._secondary) {
+      if (this._nonBlocking) {
+        this.deleteManyKeyv(this._secondary, keys);
+      } else {
+        await this.deleteManyKeyv(this._secondary, keys);
+      }
+    }
+    return result;
+  }
+  async clear() {
+    const promises = [];
+    promises.push(this._primary.clear());
+    if (this._secondary) {
+      promises.push(this._secondary.clear());
+    }
+    await (this._nonBlocking ? Promise.race(promises) : Promise.all(promises));
+  }
+  async disconnect() {
+    const promises = [];
+    promises.push(this._primary.disconnect());
+    if (this._secondary) {
+      promises.push(this._secondary.disconnect());
+    }
+    await (this._nonBlocking ? Promise.race(promises) : Promise.all(promises));
+  }
+  async deleteManyKeyv(keyv, keys) {
+    const promises = [];
+    for (const key of keys) {
+      promises.push(keyv.delete(key));
+    }
+    await Promise.all(promises);
+    return true;
+  }
+  async setManyKeyv(keyv, items) {
+    const promises = [];
+    for (const item of items) {
+      promises.push(keyv.set(item.key, item.value, item.ttl));
+    }
+    await Promise.all(promises);
+    return true;
+  }
+  async hasManyKeyv(keyv, keys) {
+    const promises = [];
+    for (const key of keys) {
+      promises.push(keyv.has(key));
+    }
+    return Promise.all(promises);
+  }
+};
+export {
+  Cacheable,
+  CacheableEvents,
+  CacheableHooks
+};

package/package.json

@@ -1,33 +1,44 @@
 {
   "name": "cacheable",
-  "version": "0.2.9",
-  "description": "A cache wrapper with redis",
-  "main": "index.js",
-  "scripts": {
-    "test": "./node_modules/.bin/mocha"
-  },
-  "dependencies": {
-    "debug": "0.7.x",
-    "keyf": "~0.0.1",
-    "storeman": "~0.1.2"
+  "version": "0.8.0",
+  "description": "Simple Caching Engine using Keyv",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
   },
+  "repository": "https://github.com/jaredwray/cacheable.git",
+  "author": "Jared Wray <me@jaredwray.com>",
+  "license": "MIT",
+  "private": false,
   "devDependencies": {
-    "mocha": "*",
-    "should": "*",
-    "lru-cache": "*",
-    "istanbul": "*"
+    "@keyv/redis": "^3.0.1",
+    "@vitest/coverage-v8": "^2.1.1",
+    "lru-cache": "^10.4.3",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4",
+    "vitest": "^2.1.1",
+    "xo": "^0.59.3"
   },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/ktmud/cached.git"
+  "dependencies": {
+    "hookified": "^0.7.1",
+    "keyv": "^5.0.1"
   },
-  "keywords": [
-    "redis",
-    "redis-cache",
-    "cacheable",
-    "cache",
-    "cached"
+  "files": [
+    "dist",
+    "LICENSE"
   ],
-  "author": "Jesse Yang <kissmud@gmail.com>",
-  "license": "MIT"
-}
+  "scripts": {
+    "build": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "xo --fix && vitest run --coverage",
+    "test:ci": "xo && vitest run",
+    "clean": "rimraf ./dist ./coverage ./node_modules"
+  }
+}

package/.npmignore

@@ -1,3 +0,0 @@
-node_modules
-coverage.html
-coverage

package/.travis.yml

@@ -1,4 +0,0 @@
-language: node_js
-node_js:
-  - 0.8
-  - 0.10

package/Makefile

@@ -1,7 +0,0 @@
-.PHONY: test coverage
-
-test:
-	@DEBUG= npm test
-
-coverage:
-	@DEBUG= istanbul cover ./node_modules/.bin/_mocha && open ./coverage/lcov-report/index.html

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./lib/cacheable.js');

package/lib/cacheable.js

@@ -1,162 +0,0 @@
-var Storeman = require('storeman');
-var keyf = require('keyf')
-var debug = require('debug')('cacheable:debug')
-
-var log = require('debug')('cacheable:log')
-var __slice = Array.prototype.slice
-
-// all key pattern definations
-var allkeys = {}
-var RE_KEY_PATTERN = /(%j)?{([\w\.]+)}/g
-var _REALNAME = '__cachedname'
-
-/**
- *
- * A cached wrapper for async funtions
- *
- * Options:
- *
- *   - `prefix` prefix for all keys under this cached manager
- *   - `silent` to ignore `storage.get` error
- *
- */
-function Cacheable(options) {
-  if (!(this instanceof Cacheable)) return new Cacheable(options)
-  if (!options.prefix && options.prefix !== '') {
-    options.prefix = 'cached:'
-  }
-  this.silent = options.silent === false ? false : true
-  this.helpers = {}
-  Storeman.call(this, options);
-}
-// Inherit Storeman to get a bunch of `get`, `set` methods
-require('util').inherits(Cacheable, Storeman)
-
-Cacheable.prototype.debug = debug
-// default key for wrapping standalone functions
-Cacheable.prototype.DEFAULT_KEY =  '{_fn_}:%j{0}'
-
-Cacheable.prototype._applykey = function applykey(ctx, key, fn, args) {
-  return Cacheable.keyReplacer.call(ctx, key, fn, args)
-}
-
-/**
-* Wraps an async funtion, automaticly cache the result
-*
-* The async function must have a signature of `fn(arg1, [arg2...,] callback)`.
-* The `arg1` can be an options object, if `options.fresh` is passed as true,
-* cache will not be used.
-*/
-Cacheable.prototype.wrap = function(fn, key, ttl, ctx) {
-  var cached = this
-
-  if ('number' == typeof key) {
-    // second parameter as ttl
-    ctx = ttl
-    ttl = key
-    key = null
-  }
-  if ('function' == typeof key || 'object' == typeof key) {
-    // second parameter as context
-    ctx = key
-    key = null
-  }
-  key = key || cached.DEFAULT_KEY
-
-  if (!getName(fn) && ~key.indexOf('{_fn_}')) {
-    throw new Error('Cache key referred to "{_fn_}", but the function doesn\'t have a name')
-  }
-
-  // try formating the key in advance
-  var uniqkey = cached._applykey(ctx, key, fn, [])
-  if (uniqkey in allkeys) {
-    log('Possible key conflict -> fn: [%s], key: %s', getName(fn), uniqkey)
-  } else {
-    allkeys[uniqkey] = null
-  }
-
-  debug('wrapping `%s`, key: "%s", ttl: %s', getName(fn) || '[anonymous]', uniqkey, ttl)
-
-  return function cacheWrapped() {
-    var self = ctx || this
-    var args = __slice.apply(arguments)
-    var callback = args[args.length - 1]
-    // the real key
-    var _key = cached._applykey(self, key, fn, args)
-
-    // doesn't need a callback
-    // just do the job as there is no cache
-    if (typeof callback !== 'function') {
-      debug('called with no callback, skip "%s"', _key)
-      return run()
-    }
-    // when `options.fresh` is passed as true,
-    // don't use cache
-    if ('object' == typeof args[0] && args[0].fresh) {
-      return run()
-    }
-    // cache key is not fully formatted means some args are not passed in
-    if (_key.match(RE_KEY_PATTERN)) {
-      debug('cache key not fully formatted, skip "%s"', _key)
-      return run()
-    }
-
-    function run() {
-      fn.apply(self, args)
-    }
-
-    function done(err, reply) {
-      return callback.call(self, err, reply)
-    }
-
-    cached.get(_key, function(err, reply) {
-      if (err) {
-        if (!cached.silent) {
-          // ignore cache error unless not silent
-          return done(err)
-        }
-      }
-      // cache found
-      if (reply !== undefined) {
-        return done(null, reply)
-      }
-      // make sure we save cache after callback
-      args[args.length - 1] = function(err, result) {
-        function _done(){
-          callback.call(self, err, result)
-        }
-        if (err || result === undefined) {
-          return _done()
-        }
-        // save the cache
-        cached.set(_key, result, ttl, _done)
-      }
-      run()
-    })
-  }
-}
-
-/**
- * Get function's realname
- */
-function getName(fn) {
-  return fn[_REALNAME] || fn.name
-}
-
-/**
- * How to replace a cache key
- */
-Cacheable.keyReplacer = function(key, fn, args) {
-  var self = this
-  var data = {
-    _fn_: fn && getName(fn),
-    _model_: self[_REALNAME]
-  }
-  return keyf(key, data).call(self, args)
-}
-
-Cacheable._REALNAME = _REALNAME
-
-module.exports = Cacheable
-
-require('./registry')