cacheable 0.3.0 → 0.8.0

package/dist/index.cjs

@@ -0,0 +1,448 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Cacheable: () => Cacheable,
+  CacheableEvents: () => CacheableEvents,
+  CacheableHooks: () => CacheableHooks
+});
+module.exports = __toCommonJS(src_exports);
+var import_keyv = require("keyv");
+var import_hookified = require("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 import_hookified.Hookified {
+  _primary = new import_keyv.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 import_keyv.Keyv ? primary : new import_keyv.Keyv(primary);
+  }
+  setSecondary(secondary) {
+    this._secondary = secondary instanceof import_keyv.Keyv ? secondary : new import_keyv.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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cacheable,
+  CacheableEvents,
+  CacheableHooks
+});

package/dist/index.d.cts

@@ -0,0 +1,104 @@
+import { Keyv, KeyvStoreAdapter } from 'keyv';
+import { Hookified } from 'hookified';
+
+type CacheableOptions$1 = {
+    enabled?: boolean;
+};
+declare class CacheableStats {
+    private _hits;
+    private _misses;
+    private _gets;
+    private _sets;
+    private _deletes;
+    private _clears;
+    private _vsize;
+    private _ksize;
+    private _count;
+    private _enabled;
+    constructor(options?: CacheableOptions$1);
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    get hits(): number;
+    get misses(): number;
+    get gets(): number;
+    get sets(): number;
+    get deletes(): number;
+    get clears(): number;
+    get vsize(): number;
+    get ksize(): number;
+    get count(): number;
+    incrementHits(): void;
+    incrementMisses(): void;
+    incrementGets(): void;
+    incrementSets(): void;
+    incrementDeletes(): void;
+    incrementClears(): void;
+    incrementVSize(value: any): void;
+    decreaseVSize(value: any): void;
+    incrementKSize(key: string): void;
+    decreaseKSize(key: string): void;
+    incrementCount(): void;
+    descreaseCount(): void;
+    setCount(count: number): void;
+    roughSizeOfString(value: string): number;
+    roughSizeOfObject(object: any): number;
+    reset(): void;
+}
+
+declare enum CacheableHooks {
+    BEFORE_SET = "BEFORE_SET",
+    AFTER_SET = "AFTER_SET",
+    BEFORE_SET_MANY = "BEFORE_SET_MANY",
+    AFTER_SET_MANY = "AFTER_SET_MANY",
+    BEFORE_GET = "BEFORE_GET",
+    AFTER_GET = "AFTER_GET",
+    BEFORE_GET_MANY = "BEFORE_GET_MANY",
+    AFTER_GET_MANY = "AFTER_GET_MANY"
+}
+declare enum CacheableEvents {
+    ERROR = "error"
+}
+type CacheableItem = {
+    key: string;
+    value: unknown;
+    ttl?: number;
+};
+type CacheableOptions = {
+    primary?: Keyv | KeyvStoreAdapter;
+    secondary?: Keyv | KeyvStoreAdapter;
+    stats?: boolean;
+    nonBlocking?: boolean;
+};
+declare class Cacheable extends Hookified {
+    private _primary;
+    private _secondary;
+    private _nonBlocking;
+    private readonly _stats;
+    constructor(options?: CacheableOptions);
+    get stats(): CacheableStats;
+    get primary(): Keyv;
+    set primary(primary: Keyv);
+    get secondary(): Keyv | undefined;
+    set secondary(secondary: Keyv | undefined);
+    get nonBlocking(): boolean;
+    set nonBlocking(nonBlocking: boolean);
+    setPrimary(primary: Keyv | KeyvStoreAdapter): void;
+    setSecondary(secondary: Keyv | KeyvStoreAdapter): void;
+    get<T>(key: string): Promise<T | undefined>;
+    getMany<T>(keys: string[]): Promise<Array<T | undefined>>;
+    set<T>(key: string, value: T, ttl?: number): Promise<boolean>;
+    setMany(items: CacheableItem[]): Promise<boolean>;
+    take<T>(key: string): Promise<T | undefined>;
+    takeMany<T>(keys: string[]): Promise<Array<T | undefined>>;
+    has(key: string): Promise<boolean>;
+    hasMany(keys: string[]): Promise<boolean[]>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+    disconnect(): Promise<void>;
+    private deleteManyKeyv;
+    private setManyKeyv;
+    private hasManyKeyv;
+}
+
+export { Cacheable, CacheableEvents, CacheableHooks, type CacheableItem, type CacheableOptions };

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+import { Keyv, KeyvStoreAdapter } from 'keyv';
+import { Hookified } from 'hookified';
+
+type CacheableOptions$1 = {
+    enabled?: boolean;
+};
+declare class CacheableStats {
+    private _hits;
+    private _misses;
+    private _gets;
+    private _sets;
+    private _deletes;
+    private _clears;
+    private _vsize;
+    private _ksize;
+    private _count;
+    private _enabled;
+    constructor(options?: CacheableOptions$1);
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    get hits(): number;
+    get misses(): number;
+    get gets(): number;
+    get sets(): number;
+    get deletes(): number;
+    get clears(): number;
+    get vsize(): number;
+    get ksize(): number;
+    get count(): number;
+    incrementHits(): void;
+    incrementMisses(): void;
+    incrementGets(): void;
+    incrementSets(): void;
+    incrementDeletes(): void;
+    incrementClears(): void;
+    incrementVSize(value: any): void;
+    decreaseVSize(value: any): void;
+    incrementKSize(key: string): void;
+    decreaseKSize(key: string): void;
+    incrementCount(): void;
+    descreaseCount(): void;
+    setCount(count: number): void;
+    roughSizeOfString(value: string): number;
+    roughSizeOfObject(object: any): number;
+    reset(): void;
+}
+
+declare enum CacheableHooks {
+    BEFORE_SET = "BEFORE_SET",
+    AFTER_SET = "AFTER_SET",
+    BEFORE_SET_MANY = "BEFORE_SET_MANY",
+    AFTER_SET_MANY = "AFTER_SET_MANY",
+    BEFORE_GET = "BEFORE_GET",
+    AFTER_GET = "AFTER_GET",
+    BEFORE_GET_MANY = "BEFORE_GET_MANY",
+    AFTER_GET_MANY = "AFTER_GET_MANY"
+}
+declare enum CacheableEvents {
+    ERROR = "error"
+}
+type CacheableItem = {
+    key: string;
+    value: unknown;
+    ttl?: number;
+};
+type CacheableOptions = {
+    primary?: Keyv | KeyvStoreAdapter;
+    secondary?: Keyv | KeyvStoreAdapter;
+    stats?: boolean;
+    nonBlocking?: boolean;
+};
+declare class Cacheable extends Hookified {
+    private _primary;
+    private _secondary;
+    private _nonBlocking;
+    private readonly _stats;
+    constructor(options?: CacheableOptions);
+    get stats(): CacheableStats;
+    get primary(): Keyv;
+    set primary(primary: Keyv);
+    get secondary(): Keyv | undefined;
+    set secondary(secondary: Keyv | undefined);
+    get nonBlocking(): boolean;
+    set nonBlocking(nonBlocking: boolean);
+    setPrimary(primary: Keyv | KeyvStoreAdapter): void;
+    setSecondary(secondary: Keyv | KeyvStoreAdapter): void;
+    get<T>(key: string): Promise<T | undefined>;
+    getMany<T>(keys: string[]): Promise<Array<T | undefined>>;
+    set<T>(key: string, value: T, ttl?: number): Promise<boolean>;
+    setMany(items: CacheableItem[]): Promise<boolean>;
+    take<T>(key: string): Promise<T | undefined>;
+    takeMany<T>(keys: string[]): Promise<Array<T | undefined>>;
+    has(key: string): Promise<boolean>;
+    hasMany(keys: string[]): Promise<boolean[]>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+    disconnect(): Promise<void>;
+    private deleteManyKeyv;
+    private setManyKeyv;
+    private hasManyKeyv;
+}
+
+export { Cacheable, CacheableEvents, CacheableHooks, type CacheableItem, type CacheableOptions };