cacheable 0.3.0 → 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.3.0",
+  "version": "0.8.0",
   "description": "Simple Caching Engine using Keyv",
-  "main": "./dist/index.js",
+  "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": {
-    "eslint": "^9.9.1",
+    "@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"
   },
   "dependencies": {
-    "eventemitter3": "^5.0.1",
-    "hookified": "^0.7.0",
+    "hookified": "^0.7.1",
     "keyv": "^5.0.1"
   },
-  "xo": {
-    "rules": {
-      "unicorn/prefer-event-target": "off"
-    }
-  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "test": "xo --fix",
-    "test:ci": "xo",
-    "clean": "rm -rf dist && rm -rf node_modules"
+    "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/src/index.ts

@@ -1,122 +0,0 @@
-import {Keyv} from 'keyv';
-import {Hookified} from 'hookified';
-
-type CacheableStatsItem = {
-	key: string;
-	lastAccessed: number;
-	accessCount: number;
-};
-
-type CacheableStats = {
-	cacheSize: number;
-	currentSize: number;
-	hits: number;
-	misses: number;
-	hitRate: number;
-	averageLoadPenalty: number;
-	loadSuccessCount: number;
-	loadExceptionCount: number;
-	totalLoadTime: number;
-	topHits: CacheableStatsItem[];
-	leastUsed: CacheableStatsItem[];
-};
-
-export enum CacheableHooks {
-	BEFORE_SET = 'beforeSet',
-	AFTER_SET = 'afterSet',
-	BEFORE_SET_MANY = 'beforeSetMany',
-	AFTER_SET_MANY = 'afterSetMany',
-	BEFORE_GET = 'beforeGet',
-	AFTER_GET = 'afterGet',
-	BEFORE_GET_MANY = 'beforeGetMany',
-	AFTER_GET_MANY = 'afterGetMany',
-}
-
-export enum CacheableEvents {
-	ERROR = 'error',
-}
-
-export enum CacheableTieringModes {
-	PRIMARY_WITH_FAILOVER = 'primarySecondary',
-	ACID = 'allPrimary',
-	PRIMARY_ALL_FAILOVER = 'primaryAllFailover',
-}
-
-export type CacheableOptions = {
-	store?: Keyv;
-	enableStats?: boolean;
-	enableOffline?: boolean;
-	nonBlocking?: boolean;
-};
-
-export class Cacheable extends Hookified {
-	private _store: Keyv = new Keyv();
-	private readonly _stats: CacheableStats = {
-		currentSize: 0, cacheSize: 0, hits: 0, misses: 0, hitRate: 0, averageLoadPenalty: 0, loadSuccessCount: 0, loadExceptionCount: 0, totalLoadTime: 0, topHits: [], leastUsed: [],
-	};
-
-	private _enableStats = false;
-	private _enableOffline = false;
-
-	constructor(keyv?: Keyv) {
-		super();
-
-		if (keyv) {
-			this._store = keyv;
-		}
-	}
-
-	public get enableStats(): boolean {
-		return this._enableStats;
-	}
-
-	public set enableStats(enabled: boolean) {
-		this._enableStats = enabled;
-	}
-
-	public get enableOffline(): boolean {
-		return this._enableOffline;
-	}
-
-	public set enableOffline(enabled: boolean) {
-		this._enableOffline = enabled;
-	}
-
-	public get store(): Keyv {
-		return this._store;
-	}
-
-	public set store(keyv: Keyv) {
-		this._store = keyv;
-	}
-
-	public get stats(): CacheableStats {
-		return this._stats;
-	}
-
-	public async get<T>(key: string): Promise<T | undefined> {
-		let result;
-		try {
-			await this.hook(CacheableHooks.BEFORE_GET, key);
-			result = await this._store.get(key) as T;
-			await this.hook(CacheableHooks.AFTER_GET, {key, result});
-		} catch (error: unknown) {
-			await this.emit(CacheableEvents.ERROR, error);
-		}
-
-		return result;
-	}
-
-	public async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
-		let result = false;
-		try {
-			await this.hook(CacheableHooks.BEFORE_SET, {key, value, ttl});
-			result = await this._store.set(key, value, ttl);
-			await this.hook(CacheableHooks.AFTER_SET, {key, value, ttl});
-		} catch (error: unknown) {
-			await this.emit(CacheableEvents.ERROR, error);
-		}
-
-		return result;
-	}
-}

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "include": ["src/**/*"]
-}