cacheable 2.1.0 → 2.2.0

package/dist/index.cjs

@@ -1 +1,1087 @@
-"use strict";var A=Object.defineProperty;var B=Object.getOwnPropertyDescriptor;var P=Object.getOwnPropertyNames;var G=Object.prototype.hasOwnProperty;var k=(d,t)=>{for(var i in t)A(d,i,{get:t[i],enumerable:!0})},x=(d,t,i,e)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of P(t))!G.call(d,s)&&s!==i&&A(d,s,{get:()=>t[s],enumerable:!(e=B(t,s))||e.enumerable});return d};var N=d=>x(A({},"__esModule",{value:!0}),d);var Y={};k(Y,{Cacheable:()=>M,CacheableEvents:()=>R,CacheableHooks:()=>E,CacheableMemory:()=>f.CacheableMemory,CacheableStats:()=>l.Stats,CacheableSync:()=>_,CacheableSyncEvents:()=>S,HashAlgorithm:()=>l.HashAlgorithm,Keyv:()=>v.Keyv,KeyvCacheableMemory:()=>f.KeyvCacheableMemory,KeyvHooks:()=>v.KeyvHooks,calculateTtlFromExpiration:()=>l.calculateTtlFromExpiration,createKeyv:()=>f.createKeyv,getCascadingTtl:()=>l.getCascadingTtl,getOrSet:()=>m.getOrSet,hash:()=>l.hash,shorthandToMilliseconds:()=>l.shorthandToMilliseconds,shorthandToTime:()=>l.shorthandToTime,wrap:()=>m.wrap,wrapSync:()=>m.wrapSync});module.exports=N(Y);var T=require("@cacheable/memoize"),K=require("@cacheable/memory"),o=require("@cacheable/utils"),F=require("hookified"),O=require("keyv");var E=(c=>(c.BEFORE_SET="BEFORE_SET",c.AFTER_SET="AFTER_SET",c.BEFORE_SET_MANY="BEFORE_SET_MANY",c.AFTER_SET_MANY="AFTER_SET_MANY",c.BEFORE_GET="BEFORE_GET",c.AFTER_GET="AFTER_GET",c.BEFORE_GET_MANY="BEFORE_GET_MANY",c.AFTER_GET_MANY="AFTER_GET_MANY",c.BEFORE_SECONDARY_SETS_PRIMARY="BEFORE_SECONDARY_SETS_PRIMARY",c))(E||{}),R=(e=>(e.ERROR="error",e.CACHE_HIT="cache:hit",e.CACHE_MISS="cache:miss",e))(R||{});var I=require("hookified"),g=require("qified"),S=(e=>(e.ERROR="error",e.SET="cache:set",e.DELETE="cache:delete",e))(S||{}),_=class extends I.Hookified{_qified=new g.Qified;constructor(t){super(t),this._qified=this.createQified(t.qified)}get qified(){return this._qified}set qified(t){this._qified=this.createQified(t)}async publish(t,i){await this._qified.publish(t,{id:crypto.randomUUID(),data:i})}subscribe(t,i){this._qified.subscribe("cache:set",{handler:async e=>{let s=e.data;s.cacheId!==i&&await t.set(s.key,s.value,s.ttl)}}),this._qified.subscribe("cache:delete",{handler:async e=>{let s=e.data;s.cacheId!==i&&await t.delete(s.key)}})}createQified(t){if(t instanceof g.Qified)return t;let i=Array.isArray(t)?t:[t];return new g.Qified({messageProviders:i})}};var m=require("@cacheable/memoize"),f=require("@cacheable/memory"),l=require("@cacheable/utils"),v=require("keyv"),M=class extends F.Hookified{_primary=(0,K.createKeyv)();_secondary;_nonBlocking=!1;_ttl;_stats=new o.Stats({enabled:!1});_namespace;_cacheId=Math.random().toString(36).slice(2);_sync;constructor(t){super(),t?.primary&&this.setPrimary(t.primary),t?.secondary&&this.setSecondary(t.secondary),t?.nonBlocking&&(this._nonBlocking=t.nonBlocking),t?.stats&&(this._stats.enabled=t.stats),t?.ttl&&this.setTtl(t.ttl),t?.cacheId&&(this._cacheId=t.cacheId),t?.namespace&&(this._namespace=t.namespace,this._primary.namespace=this.getNameSpace(),this._secondary&&(this._secondary.namespace=this.getNameSpace())),t?.sync&&(this._sync=t.sync instanceof _?t.sync:new _(t.sync),this._sync.subscribe(this._primary,this._cacheId))}get namespace(){return this._namespace}set namespace(t){this._namespace=t,this._primary.namespace=this.getNameSpace(),this._secondary&&(this._secondary.namespace=this.getNameSpace())}get stats(){return this._stats}get primary(){return this._primary}set primary(t){this._primary=t}get secondary(){return this._secondary}set secondary(t){this._secondary=t}get nonBlocking(){return this._nonBlocking}set nonBlocking(t){this._nonBlocking=t}get ttl(){return this._ttl}set ttl(t){this.setTtl(t)}get cacheId(){return this._cacheId}set cacheId(t){this._cacheId=t}get sync(){return this._sync}set sync(t){this._sync=t,this._sync&&this._sync.subscribe(this._primary,this._cacheId)}setPrimary(t){(0,o.isKeyvInstance)(t)?this._primary=t:this._primary=new O.Keyv(t),this._primary.on("error",i=>{this.emit("error",i)})}setSecondary(t){(0,o.isKeyvInstance)(t)?this._secondary=t:this._secondary=new O.Keyv(t),this._secondary.on("error",i=>{this.emit("error",i)})}getNameSpace(){return typeof this._namespace=="function"?this._namespace():this._namespace}async get(t,i){return(await this.getRaw(t,i))?.value}async getRaw(t,i){let e;try{await this.hook("BEFORE_GET",t),e=await this._primary.getRaw(t);let s;e?this.emit("cache:hit",{key:t,value:e.value,store:"primary"}):this.emit("cache:miss",{key:t,store:"primary"});let n=i?.nonBlocking??this._nonBlocking;if(!e&&this._secondary){let a;n?a=await this.processSecondaryForGetRawNonBlocking(this._primary,this._secondary,t):a=await this.processSecondaryForGetRaw(this._primary,this._secondary,t),a&&(e=a.result,s=a.ttl)}await this.hook("AFTER_GET",{key:t,result:e,ttl:s})}catch(s){this.emit("error",s)}return this.stats.enabled&&(e?this._stats.incrementHits():this._stats.incrementMisses(),this.stats.incrementGets()),e}async getManyRaw(t,i){let e=[];try{await this.hook("BEFORE_GET_MANY",t),e=await this._primary.getManyRaw(t);for(let[n,a]of t.entries())e[n]?this.emit("cache:hit",{key:a,value:e[n].value,store:"primary"}):this.emit("cache:miss",{key:a,store:"primary"});let s=i?.nonBlocking??this._nonBlocking;this._secondary&&(s?await this.processSecondaryForGetManyRawNonBlocking(this._primary,this._secondary,t,e):await this.processSecondaryForGetManyRaw(this._primary,this._secondary,t,e)),await this.hook("AFTER_GET_MANY",{keys:t,result:e})}catch(s){this.emit("error",s)}if(this.stats.enabled){for(let s of e)s?this._stats.incrementHits():this._stats.incrementMisses();this.stats.incrementGets()}return e}async getMany(t,i){return(await this.getManyRaw(t,i)).map(s=>s?.value)}async set(t,i,e){let s=!1,n=(0,o.shorthandToMilliseconds)(e??this._ttl);try{let a={key:t,value:i,ttl:n};await this.hook("BEFORE_SET",a);let r=[];if(r.push(this._primary.set(a.key,a.value,a.ttl)),this._secondary&&r.push(this._secondary.set(a.key,a.value,a.ttl)),this._nonBlocking){s=await Promise.race(r);for(let h of r)h.catch(c=>{this.emit("error",c)})}else s=(await Promise.all(r))[0];await this.hook("AFTER_SET",a),this._sync&&s&&await this._sync.publish("cache:set",{cacheId:this._cacheId,key:a.key,value:a.value,ttl:a.ttl})}catch(a){this.emit("error",a)}return this.stats.enabled&&(this.stats.incrementKSize(t),this.stats.incrementCount(),this.stats.incrementVSize(i),this.stats.incrementSets()),s}async setMany(t){let i=!1;try{if(await this.hook("BEFORE_SET_MANY",t),i=await this.setManyKeyv(this._primary,t),this._secondary&&(this._nonBlocking?this.setManyKeyv(this._secondary,t).catch(e=>{this.emit("error",e)}):await this.setManyKeyv(this._secondary,t)),await this.hook("AFTER_SET_MANY",t),this._sync&&i)for(let e of t)await this._sync.publish("cache:set",{cacheId:this._cacheId,key:e.key,value:e.value,ttl:(0,o.shorthandToMilliseconds)(e.ttl)})}catch(e){this.emit("error",e)}if(this.stats.enabled)for(let e of t)this.stats.incrementKSize(e.key),this.stats.incrementCount(),this.stats.incrementVSize(e.value);return i}async take(t){let i=await this.get(t);return await this.delete(t),i}async takeMany(t){let i=await this.getMany(t);return await this.deleteMany(t),i}async has(t){let i=[];i.push(this._primary.has(t)),this._secondary&&i.push(this._secondary.has(t));let e=await Promise.all(i);for(let s of e)if(s)return!0;return!1}async hasMany(t){let i=await this.hasManyKeyv(this._primary,t),e=[];for(let[s,n]of t.entries())!i[s]&&this._secondary&&e.push(n);if(e.length>0&&this._secondary){let s=await this.hasManyKeyv(this._secondary,t);for(let[n,a]of t.entries())!i[n]&&s[n]&&(i[n]=s[n])}return i}async delete(t){let i=!1,e=[];if(this.stats.enabled){let s=await this._primary.get(t);s&&(this.stats.decreaseKSize(t),this.stats.decreaseVSize(s),this.stats.decreaseCount(),this.stats.incrementDeletes())}if(e.push(this._primary.delete(t)),this._secondary&&e.push(this._secondary.delete(t)),this.nonBlocking){i=await Promise.race(e);for(let s of e)s.catch(n=>{this.emit("error",n)})}else i=(await Promise.all(e))[0];return this._sync&&i&&await this._sync.publish("cache:delete",{cacheId:this._cacheId,key:t}),i}async deleteMany(t){if(this.stats.enabled){let e=await this._primary.get(t);for(let s of t)this.stats.decreaseKSize(s),this.stats.decreaseVSize(e),this.stats.decreaseCount(),this.stats.incrementDeletes()}let i=await this._primary.deleteMany(t);if(this._secondary&&(this._nonBlocking?this._secondary.deleteMany(t).catch(e=>{this.emit("error",e)}):await this._secondary.deleteMany(t)),this._sync&&i)for(let e of t)await this._sync.publish("cache:delete",{cacheId:this._cacheId,key:e});return i}async clear(){let t=[];t.push(this._primary.clear()),this._secondary&&t.push(this._secondary.clear()),await(this._nonBlocking?Promise.race(t):Promise.all(t)),this.stats.enabled&&(this._stats.resetStoreValues(),this._stats.incrementClears())}async disconnect(){let t=[];t.push(this._primary.disconnect()),this._secondary&&t.push(this._secondary.disconnect()),await(this._nonBlocking?Promise.race(t):Promise.all(t))}wrap(t,i){let e={get:async n=>this.get(n),has:async n=>this.has(n),set:async(n,a,r)=>{await this.set(n,a,r)},on:(n,a)=>{this.on(n,a)},emit:(n,...a)=>this.emit(n,...a)},s={ttl:i?.ttl??this._ttl,keyPrefix:i?.keyPrefix,createKey:i?.createKey,cacheErrors:i?.cacheErrors,cache:e,cacheId:this._cacheId,serialize:i?.serialize};return(0,T.wrap)(t,s)}async getOrSet(t,i,e){let n={cache:{get:async a=>this.get(a),has:async a=>this.has(a),set:async(a,r,h)=>{await this.set(a,r,h)},on:(a,r)=>{this.on(a,r)},emit:(a,...r)=>this.emit(a,...r)},cacheId:this._cacheId,ttl:e?.ttl??this._ttl,cacheErrors:e?.cacheErrors,throwErrors:e?.throwErrors};return(0,T.getOrSet)(t,i,n)}hash(t,i=o.HashAlgorithm.SHA256){let e=Object.values(o.HashAlgorithm).includes(i)?i:o.HashAlgorithm.SHA256;return(0,o.hash)(t,{algorithm:e})}async setManyKeyv(t,i){let e=[];for(let s of i){let n=(0,o.shorthandToMilliseconds)(s.ttl??this._ttl);e.push({key:s.key,value:s.value,ttl:n})}return await t.setMany(e),!0}async hasManyKeyv(t,i){let e=[];for(let s of i)e.push(t.has(s));return Promise.all(e)}async processSecondaryForGetRaw(t,i,e){let s=await i.getRaw(e);if(s?.value){this.emit("cache:hit",{key:e,value:s.value,store:"secondary"});let n=(0,o.getCascadingTtl)(this._ttl,this._primary.ttl),a=s.expires??void 0,r=(0,o.calculateTtlFromExpiration)(n,a),h={key:e,value:s.value,ttl:r};return await this.hook("BEFORE_SECONDARY_SETS_PRIMARY",h),await t.set(h.key,h.value,h.ttl),{result:s,ttl:r}}else{this.emit("cache:miss",{key:e,store:"secondary"});return}}async processSecondaryForGetRawNonBlocking(t,i,e){let s=await i.getRaw(e);if(s?.value){this.emit("cache:hit",{key:e,value:s.value,store:"secondary"});let n=(0,o.getCascadingTtl)(this._ttl,this._primary.ttl),a=s.expires??void 0,r=(0,o.calculateTtlFromExpiration)(n,a),h={key:e,value:s.value,ttl:r};return this.hook("BEFORE_SECONDARY_SETS_PRIMARY",h).then(async()=>{await t.set(h.key,h.value,h.ttl)}).catch(c=>{this.emit("error",c)}),{result:s,ttl:r}}else{this.emit("cache:miss",{key:e,store:"secondary"});return}}async processSecondaryForGetManyRaw(t,i,e,s){let n=[];for(let[h,c]of e.entries())s[h]||n.push(c);let a=await i.getManyRaw(n),r=0;for await(let[h,c]of e.entries())if(!s[h]){let y=a[r];if(y&&y.value!==void 0){s[h]=y,this.emit("cache:hit",{key:c,value:y.value,store:"secondary"});let b=(0,o.getCascadingTtl)(this._ttl,this._primary.ttl),{expires:u}=y;u===null&&(u=void 0);let w=(0,o.calculateTtlFromExpiration)(b,u),p={key:c,value:y.value,ttl:w};await this.hook("BEFORE_SECONDARY_SETS_PRIMARY",p),await t.set(p.key,p.value,p.ttl)}else this.emit("cache:miss",{key:c,store:"secondary"});r++}}async processSecondaryForGetManyRawNonBlocking(t,i,e,s){let n=[];for(let[h,c]of e.entries())s[h]||n.push(c);let a=await i.getManyRaw(n),r=0;for await(let[h,c]of e.entries())if(!s[h]){let y=a[r];if(y&&y.value!==void 0){s[h]=y,this.emit("cache:hit",{key:c,value:y.value,store:"secondary"});let b=(0,o.getCascadingTtl)(this._ttl,this._primary.ttl),{expires:u}=y;u===null&&(u=void 0);let w=(0,o.calculateTtlFromExpiration)(b,u),p={key:c,value:y.value,ttl:w};this.hook("BEFORE_SECONDARY_SETS_PRIMARY",p).then(async()=>{await t.set(p.key,p.value,p.ttl)}).catch(C=>{this.emit("error",C)})}else this.emit("cache:miss",{key:c,store:"secondary"});r++}}setTtl(t){typeof t=="string"||t===void 0?this._ttl=t:t>0?this._ttl=t:this._ttl=void 0}};0&&(module.exports={Cacheable,CacheableEvents,CacheableHooks,CacheableMemory,CacheableStats,CacheableSync,CacheableSyncEvents,HashAlgorithm,Keyv,KeyvCacheableMemory,KeyvHooks,calculateTtlFromExpiration,createKeyv,getCascadingTtl,getOrSet,hash,shorthandToMilliseconds,shorthandToTime,wrap,wrapSync});
+"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 index_exports = {};
+__export(index_exports, {
+  Cacheable: () => Cacheable,
+  CacheableEvents: () => CacheableEvents,
+  CacheableHooks: () => CacheableHooks,
+  CacheableMemory: () => import_memory2.CacheableMemory,
+  CacheableStats: () => import_utils2.Stats,
+  CacheableSync: () => CacheableSync,
+  CacheableSyncEvents: () => CacheableSyncEvents,
+  HashAlgorithm: () => import_utils2.HashAlgorithm,
+  Keyv: () => import_keyv2.Keyv,
+  KeyvCacheableMemory: () => import_memory2.KeyvCacheableMemory,
+  KeyvHooks: () => import_keyv2.KeyvHooks,
+  calculateTtlFromExpiration: () => import_utils2.calculateTtlFromExpiration,
+  createKeyv: () => import_memory2.createKeyv,
+  getCascadingTtl: () => import_utils2.getCascadingTtl,
+  getOrSet: () => import_utils2.getOrSet,
+  hash: () => import_utils2.hash,
+  shorthandToMilliseconds: () => import_utils2.shorthandToMilliseconds,
+  shorthandToTime: () => import_utils2.shorthandToTime,
+  wrap: () => import_utils2.wrap,
+  wrapSync: () => import_utils2.wrapSync
+});
+module.exports = __toCommonJS(index_exports);
+var import_memory = require("@cacheable/memory");
+var import_utils = require("@cacheable/utils");
+var import_hookified2 = require("hookified");
+var import_keyv = require("keyv");
+
+// src/enums.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";
+  CacheableHooks2["BEFORE_SECONDARY_SETS_PRIMARY"] = "BEFORE_SECONDARY_SETS_PRIMARY";
+  return CacheableHooks2;
+})(CacheableHooks || {});
+var CacheableEvents = /* @__PURE__ */ ((CacheableEvents2) => {
+  CacheableEvents2["ERROR"] = "error";
+  CacheableEvents2["CACHE_HIT"] = "cache:hit";
+  CacheableEvents2["CACHE_MISS"] = "cache:miss";
+  return CacheableEvents2;
+})(CacheableEvents || {});
+
+// src/sync.ts
+var import_hookified = require("hookified");
+var import_qified = require("qified");
+var CacheableSyncEvents = /* @__PURE__ */ ((CacheableSyncEvents2) => {
+  CacheableSyncEvents2["ERROR"] = "error";
+  CacheableSyncEvents2["SET"] = "cache:set";
+  CacheableSyncEvents2["DELETE"] = "cache:delete";
+  return CacheableSyncEvents2;
+})(CacheableSyncEvents || {});
+var CacheableSync = class extends import_hookified.Hookified {
+  _qified = new import_qified.Qified();
+  /**
+   * Creates an instance of CacheableSync
+   * @param options - Configuration options for CacheableSync
+   */
+  constructor(options) {
+    super(options);
+    this._qified = this.createQified(options.qified);
+  }
+  /**
+   * Gets the Qified instance used for synchronization
+   * @returns The Qified instance
+   */
+  get qified() {
+    return this._qified;
+  }
+  /**
+   * Sets the Qified instance used for synchronization
+   * @param value - Either an existing Qified instance or MessageProvider(s)
+   */
+  set qified(value) {
+    this._qified = this.createQified(value);
+  }
+  /**
+   * Publishes a cache event to all the cache instances
+   * @param data - The cache item data containing cacheId, key, value, and optional ttl
+   */
+  async publish(event, data) {
+    await this._qified.publish(event, {
+      id: crypto.randomUUID(),
+      data
+    });
+  }
+  /**
+   * Subscribes to sync events and updates the provided storage
+   * @param storage - The Keyv storage instance to update
+   * @param cacheId - The cache ID to identify this instance
+   */
+  subscribe(storage, cacheId) {
+    this._qified.subscribe("cache:set" /* SET */, {
+      handler: async (message) => {
+        const data = message.data;
+        if (data.cacheId !== cacheId) {
+          await storage.set(data.key, data.value, data.ttl);
+        }
+      }
+    });
+    this._qified.subscribe("cache:delete" /* DELETE */, {
+      handler: async (message) => {
+        const data = message.data;
+        if (data.cacheId !== cacheId) {
+          await storage.delete(data.key);
+        }
+      }
+    });
+  }
+  /**
+   * Creates or returns a Qified instance from the provided value
+   * @param value - Either an existing Qified instance or MessageProvider(s)
+   * @returns A Qified instance configured with the provided message provider(s)
+   */
+  createQified(value) {
+    if (value instanceof import_qified.Qified) {
+      return value;
+    }
+    const providers = Array.isArray(value) ? value : [value];
+    return new import_qified.Qified({ messageProviders: providers });
+  }
+};
+
+// src/index.ts
+var import_memory2 = require("@cacheable/memory");
+var import_utils2 = require("@cacheable/utils");
+var import_keyv2 = require("keyv");
+var Cacheable = class extends import_hookified2.Hookified {
+  _primary = (0, import_memory.createKeyv)();
+  _secondary;
+  _nonBlocking = false;
+  _ttl;
+  _stats = new import_utils.Stats({ enabled: false });
+  _namespace;
+  _cacheId = Math.random().toString(36).slice(2);
+  _sync;
+  /**
+   * Creates a new cacheable instance
+   * @param {CacheableOptions} [options] The options for the cacheable instance
+   */
+  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;
+    }
+    if (options?.ttl) {
+      this.setTtl(options.ttl);
+    }
+    if (options?.cacheId) {
+      this._cacheId = options.cacheId;
+    }
+    if (options?.namespace) {
+      this._namespace = options.namespace;
+      this._primary.namespace = this.getNameSpace();
+      if (this._secondary) {
+        this._secondary.namespace = this.getNameSpace();
+      }
+    }
+    if (options?.sync) {
+      this._sync = options.sync instanceof CacheableSync ? options.sync : new CacheableSync(options.sync);
+      this._sync.subscribe(this._primary, this._cacheId);
+    }
+  }
+  /**
+   * The namespace for the cacheable instance
+   * @returns {string | (() => string) | undefined} The namespace for the cacheable instance
+   */
+  get namespace() {
+    return this._namespace;
+  }
+  /**
+   * Sets the namespace for the cacheable instance
+   * @param {string | (() => string) | undefined} namespace The namespace for the cacheable instance
+   * @returns {void}
+   */
+  set namespace(namespace) {
+    this._namespace = namespace;
+    this._primary.namespace = this.getNameSpace();
+    if (this._secondary) {
+      this._secondary.namespace = this.getNameSpace();
+    }
+  }
+  /**
+   * The statistics for the cacheable instance
+   * @returns {CacheableStats} The statistics for the cacheable instance
+   */
+  get stats() {
+    return this._stats;
+  }
+  /**
+   * The primary store for the cacheable instance
+   * @returns {Keyv} The primary store for the cacheable instance
+   */
+  get primary() {
+    return this._primary;
+  }
+  /**
+   * Sets the primary store for the cacheable instance
+   * @param {Keyv} primary The primary store for the cacheable instance
+   */
+  set primary(primary) {
+    this._primary = primary;
+  }
+  /**
+   * The secondary store for the cacheable instance
+   * @returns {Keyv | undefined} The secondary store for the cacheable instance
+   */
+  get secondary() {
+    return this._secondary;
+  }
+  /**
+   * Sets the secondary store for the cacheable instance. If it is set to undefined then the secondary store is disabled.
+   * @param {Keyv | undefined} secondary The secondary store for the cacheable instance
+   * @returns {void}
+   */
+  set secondary(secondary) {
+    this._secondary = secondary;
+  }
+  /**
+   * Gets whether the secondary store is non-blocking mode. It is set to false by default.
+   * If it is set to true then the secondary store will not block the primary store.
+   *
+   * [Learn more about non-blocking mode](https://cacheable.org/docs/cacheable/#non-blocking-operations).
+   *
+   * @returns {boolean} Whether the cacheable instance is non-blocking
+   */
+  get nonBlocking() {
+    return this._nonBlocking;
+  }
+  /**
+   * Sets whether the secondary store is non-blocking mode. It is set to false by default.
+   * If it is set to true then the secondary store will not block the primary store.
+   *
+   * [Learn more about non-blocking mode](https://cacheable.org/docs/cacheable/#non-blocking-operations).
+   *
+   * @param {boolean} nonBlocking Whether the cacheable instance is non-blocking
+   * @returns {void}
+   */
+  set nonBlocking(nonBlocking) {
+    this._nonBlocking = nonBlocking;
+  }
+  /**
+   * The time-to-live for the cacheable instance and will be used as the default value.
+   * can be a number in milliseconds or a human-readable format such as `1s` for 1 second or `1h` for 1 hour
+   * or undefined if there is no time-to-live.
+   *
+   * [Learn more about time-to-live](https://cacheable.org/docs/cacheable/#shorthand-for-time-to-live-ttl).
+   *
+   * @returns {number | string | undefined} The time-to-live for the cacheable instance in milliseconds, human-readable format or undefined
+   * @example
+   * ```typescript
+   * const cacheable = new Cacheable({ ttl: '1h' });
+   * console.log(cacheable.ttl); // 1h
+   * ```
+   */
+  get ttl() {
+    return this._ttl;
+  }
+  /**
+   * Sets the time-to-live for the cacheable instance and will be used as the default value.
+   * If you set a number it is miliseconds, if you set a string it is a human-readable
+   * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that
+   * there is no time-to-live.
+   *
+   * [Learn more about time-to-live](https://cacheable.org/docs/cacheable/#shorthand-for-time-to-live-ttl).
+   *
+   * @param {number | string | undefined} ttl The time-to-live for the cacheable instance
+   * @example
+   * ```typescript
+   * const cacheable = new Cacheable();
+   * cacheable.ttl = '1h'; // Set the time-to-live to 1 hour
+   * ```
+   * or setting the time-to-live in milliseconds
+   * ```typescript
+   * const cacheable = new Cacheable();
+   * cacheable.ttl = 3600000; // Set the time-to-live to 1 hour
+   * ```
+   */
+  set ttl(ttl) {
+    this.setTtl(ttl);
+  }
+  /**
+   * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+   * If it is not set then it will be a random string that is generated
+   * @returns {string} The cacheId for the cacheable instance
+   */
+  get cacheId() {
+    return this._cacheId;
+  }
+  /**
+   * Sets the cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+   * If it is not set then it will be a random string that is generated
+   * @param {string} cacheId The cacheId for the cacheable instance
+   */
+  set cacheId(cacheId) {
+    this._cacheId = cacheId;
+  }
+  /**
+   * Gets the sync instance for the cacheable instance
+   * @returns {CacheableSync | undefined} The sync instance for the cacheable instance
+   */
+  get sync() {
+    return this._sync;
+  }
+  /**
+   * Sets the sync instance for the cacheable instance
+   * @param {CacheableSync | undefined} sync The sync instance for the cacheable instance
+   */
+  set sync(sync) {
+    this._sync = sync;
+    if (this._sync) {
+      this._sync.subscribe(this._primary, this._cacheId);
+    }
+  }
+  /**
+   * Sets the primary store for the cacheable instance
+   * @param {Keyv | KeyvStoreAdapter} primary The primary store for the cacheable instance
+   * @returns {void}
+   */
+  setPrimary(primary) {
+    if ((0, import_utils.isKeyvInstance)(primary)) {
+      this._primary = primary;
+    } else {
+      this._primary = new import_keyv.Keyv(primary);
+    }
+    this._primary.on("error", (error) => {
+      this.emit("error" /* ERROR */, error);
+    });
+  }
+  /**
+   * Sets the secondary store for the cacheable instance. If it is set to undefined then the secondary store is disabled.
+   * @param {Keyv | KeyvStoreAdapter} secondary The secondary store for the cacheable instance
+   * @returns {void}
+   */
+  setSecondary(secondary) {
+    if ((0, import_utils.isKeyvInstance)(secondary)) {
+      this._secondary = secondary;
+    } else {
+      this._secondary = new import_keyv.Keyv(secondary);
+    }
+    this._secondary.on("error", (error) => {
+      this.emit("error" /* ERROR */, error);
+    });
+  }
+  getNameSpace() {
+    if (typeof this._namespace === "function") {
+      return this._namespace();
+    }
+    return this._namespace;
+  }
+  /**
+   * Retrieves an entry from the cache.
+   *
+   * Checks the primary store first; if not found and a secondary store is configured,
+   * it will fetch from the secondary, repopulate the primary, and return the result.
+   *
+   * @typeParam T - The expected type of the stored value.
+   * @param {string} key - The cache key to retrieve.
+   * @param {GetOptions} - options such as to bypass `nonBlocking` for this call
+   * @returns {Promise<T | undefined>}
+   *   A promise that resolves to the cached value if found, or `undefined`.
+   */
+  async get(key, options) {
+    const result = await this.getRaw(key, options);
+    return result?.value;
+  }
+  /**
+   * Retrieves the raw entry from the cache including metadata like expiration.
+   *
+   * Checks the primary store first; if not found and a secondary store is configured,
+   * it will fetch from the secondary, repopulate the primary, and return the result.
+   *
+   * @typeParam T - The expected type of the stored value.
+   * @param {string} key - The cache key to retrieve.
+   * @param {GetOptions} - options such as to bypass `nonBlocking` for this call
+   * @returns {Promise<StoredDataRaw<T>>}
+   *   A promise that resolves to the full raw data object if found, or undefined.
+   */
+  async getRaw(key, options) {
+    let result;
+    try {
+      await this.hook("BEFORE_GET" /* BEFORE_GET */, key);
+      result = await this._primary.getRaw(key);
+      let ttl;
+      if (result) {
+        this.emit("cache:hit" /* CACHE_HIT */, {
+          key,
+          value: result.value,
+          store: "primary"
+        });
+      } else {
+        this.emit("cache:miss" /* CACHE_MISS */, { key, store: "primary" });
+      }
+      const nonBlocking = options?.nonBlocking ?? this._nonBlocking;
+      if (!result && this._secondary) {
+        let secondaryProcessResult;
+        if (nonBlocking) {
+          secondaryProcessResult = await this.processSecondaryForGetRawNonBlocking(
+            this._primary,
+            this._secondary,
+            key
+          );
+        } else {
+          secondaryProcessResult = await this.processSecondaryForGetRaw(
+            this._primary,
+            this._secondary,
+            key
+          );
+        }
+        if (secondaryProcessResult) {
+          result = secondaryProcessResult.result;
+          ttl = secondaryProcessResult.ttl;
+        }
+      }
+      await this.hook("AFTER_GET" /* AFTER_GET */, { key, result, ttl });
+    } catch (error) {
+      this.emit("error" /* ERROR */, error);
+    }
+    if (this.stats.enabled) {
+      if (result) {
+        this._stats.incrementHits();
+      } else {
+        this._stats.incrementMisses();
+      }
+      this.stats.incrementGets();
+    }
+    return result;
+  }
+  /**
+   * Retrieves multiple raw entries from the cache including metadata like expiration.
+   *
+   * Checks the primary store for each key; if a key is missing and a secondary store is configured,
+   * it will fetch from the secondary store, repopulate the primary store, and return the results.
+   *
+   * @typeParam T - The expected type of the stored values.
+   * @param {string[]} keys - The cache keys to retrieve.
+   * @param {GetOptions} - options such as to bypass `nonBlocking` on this call
+   * @returns {Promise<Array<StoredDataRaw<T>>>}
+   *   A promise that resolves to an array of raw data objects.
+   */
+  async getManyRaw(keys, options) {
+    let result = [];
+    try {
+      await this.hook("BEFORE_GET_MANY" /* BEFORE_GET_MANY */, keys);
+      result = await this._primary.getManyRaw(keys);
+      for (const [i, key] of keys.entries()) {
+        if (result[i]) {
+          this.emit("cache:hit" /* CACHE_HIT */, {
+            key,
+            value: result[i].value,
+            store: "primary"
+          });
+        } else {
+          this.emit("cache:miss" /* CACHE_MISS */, { key, store: "primary" });
+        }
+      }
+      const nonBlocking = options?.nonBlocking ?? this._nonBlocking;
+      if (this._secondary) {
+        if (nonBlocking) {
+          await this.processSecondaryForGetManyRawNonBlocking(
+            this._primary,
+            this._secondary,
+            keys,
+            result
+          );
+        } else {
+          await this.processSecondaryForGetManyRaw(
+            this._primary,
+            this._secondary,
+            keys,
+            result
+          );
+        }
+      }
+      await this.hook("AFTER_GET_MANY" /* AFTER_GET_MANY */, { keys, result });
+    } catch (error) {
+      this.emit("error" /* ERROR */, error);
+    }
+    if (this.stats.enabled) {
+      for (const item of result) {
+        if (item) {
+          this._stats.incrementHits();
+        } else {
+          this._stats.incrementMisses();
+        }
+      }
+      this.stats.incrementGets();
+    }
+    return result;
+  }
+  /**
+   * Retrieves multiple entries from the cache.
+   * Checks the primary store for each key; if a key is missing and a secondary store is configured,
+   * it will fetch from the secondary store, repopulate the primary store, and return the results.
+   *
+   * @typeParam T - The expected type of the stored values.
+   * @param {string[]} keys - The cache keys to retrieve.
+   * @param {GetOptions} - options such as to bypass `nonBlocking` on this call
+   * @returns {Promise<Array<T | undefined>>}
+   *   A promise that resolves to an array of cached values or `undefined` for misses.
+   */
+  async getMany(keys, options) {
+    const result = await this.getManyRaw(keys, options);
+    return result.map((item) => item?.value);
+  }
+  /**
+   * Sets the value of the key. If the secondary store is set then it will also set the value in the secondary store.
+   * @param {string} key the key to set the value of
+   * @param {T} value The value to set
+   * @param {number | string} [ttl] set a number it is miliseconds, set a string it is a human-readable
+   * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live.
+   * @returns {boolean} Whether the value was set
+   */
+  async set(key, value, ttl) {
+    let result = false;
+    const finalTtl = (0, import_utils.shorthandToMilliseconds)(ttl ?? this._ttl);
+    try {
+      const item = { key, value, ttl: finalTtl };
+      await this.hook("BEFORE_SET" /* BEFORE_SET */, item);
+      const promises = [];
+      promises.push(this._primary.set(item.key, item.value, item.ttl));
+      if (this._secondary) {
+        promises.push(this._secondary.set(item.key, item.value, item.ttl));
+      }
+      if (this._nonBlocking) {
+        result = await Promise.race(promises);
+        for (const promise of promises) {
+          promise.catch((error) => {
+            this.emit("error" /* ERROR */, error);
+          });
+        }
+      } else {
+        const results = await Promise.all(promises);
+        result = results[0];
+      }
+      await this.hook("AFTER_SET" /* AFTER_SET */, item);
+      if (this._sync && result) {
+        await this._sync.publish("cache:set" /* SET */, {
+          cacheId: this._cacheId,
+          key: item.key,
+          value: item.value,
+          ttl: item.ttl
+        });
+      }
+    } catch (error) {
+      this.emit("error" /* ERROR */, error);
+    }
+    if (this.stats.enabled) {
+      this.stats.incrementKSize(key);
+      this.stats.incrementCount();
+      this.stats.incrementVSize(value);
+      this.stats.incrementSets();
+    }
+    return result;
+  }
+  /**
+   * Sets the values of the keys. If the secondary store is set then it will also set the values in the secondary store.
+   * @param {CacheableItem[]} items The items to set
+   * @returns {boolean} Whether the values were set
+   */
+  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).catch((error) => {
+            this.emit("error" /* ERROR */, error);
+          });
+        } else {
+          await this.setManyKeyv(this._secondary, items);
+        }
+      }
+      await this.hook("AFTER_SET_MANY" /* AFTER_SET_MANY */, items);
+      if (this._sync && result) {
+        for (const item of items) {
+          await this._sync.publish("cache:set" /* SET */, {
+            cacheId: this._cacheId,
+            key: item.key,
+            value: item.value,
+            ttl: (0, import_utils.shorthandToMilliseconds)(item.ttl)
+          });
+        }
+      }
+    } catch (error) {
+      this.emit("error" /* ERROR */, error);
+    }
+    if (this.stats.enabled) {
+      for (const item of items) {
+        this.stats.incrementKSize(item.key);
+        this.stats.incrementCount();
+        this.stats.incrementVSize(item.value);
+      }
+    }
+    return result;
+  }
+  /**
+   * Takes the value of the key and deletes the key. If the key does not exist then it will return undefined.
+   * @param {string} key The key to take the value of
+   * @returns {Promise<T | undefined>} The value of the key or undefined if the key does not exist
+   */
+  async take(key) {
+    const result = await this.get(key);
+    await this.delete(key);
+    return result;
+  }
+  /**
+   * Takes the values of the keys and deletes the keys. If the key does not exist then it will return undefined.
+   * @param {string[]} keys The keys to take the values of
+   * @returns {Promise<Array<T | undefined>>} The values of the keys or undefined if the key does not exist
+   */
+  async takeMany(keys) {
+    const result = await this.getMany(keys);
+    await this.deleteMany(keys);
+    return result;
+  }
+  /**
+   * Checks if the key exists in the primary store. If it does not exist then it will check the secondary store.
+   * @param {string} key The key to check
+   * @returns {Promise<boolean>} Whether the key exists
+   */
+  async has(key) {
+    const promises = [];
+    promises.push(this._primary.has(key));
+    if (this._secondary) {
+      promises.push(this._secondary.has(key));
+    }
+    const resultAll = await Promise.all(promises);
+    for (const result of resultAll) {
+      if (result) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Checks if the keys exist in the primary store. If it does not exist then it will check the secondary store.
+   * @param {string[]} keys The keys to check
+   * @returns {Promise<boolean[]>} Whether the keys exist
+   */
+  async hasMany(keys) {
+    const result = await this._primary.hasMany(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._secondary.hasMany(keys);
+      for (const [i, _key] of keys.entries()) {
+        if (!result[i] && secondary[i]) {
+          result[i] = secondary[i];
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Deletes the key from the primary store. If the secondary store is set then it will also delete the key from the secondary store.
+   * @param {string} key The key to delete
+   * @returns {Promise<boolean>} Whether the key was deleted
+   */
+  async delete(key) {
+    let result = false;
+    const promises = [];
+    if (this.stats.enabled) {
+      const statResult = await this._primary.get(key);
+      if (statResult) {
+        this.stats.decreaseKSize(key);
+        this.stats.decreaseVSize(statResult);
+        this.stats.decreaseCount();
+        this.stats.incrementDeletes();
+      }
+    }
+    promises.push(this._primary.delete(key));
+    if (this._secondary) {
+      promises.push(this._secondary.delete(key));
+    }
+    if (this.nonBlocking) {
+      result = await Promise.race(promises);
+      for (const promise of promises) {
+        promise.catch((error) => {
+          this.emit("error" /* ERROR */, error);
+        });
+      }
+    } else {
+      const resultAll = await Promise.all(promises);
+      result = resultAll[0];
+    }
+    if (this._sync && result) {
+      await this._sync.publish("cache:delete" /* DELETE */, {
+        cacheId: this._cacheId,
+        key
+      });
+    }
+    return result;
+  }
+  /**
+   * Deletes the keys from the primary store. If the secondary store is set then it will also delete the keys from the secondary store.
+   * @param {string[]} keys The keys to delete
+   * @returns {Promise<boolean>} Whether the keys were deleted
+   */
+  async deleteMany(keys) {
+    if (this.stats.enabled) {
+      const statResult = await this._primary.get(keys);
+      for (const key of keys) {
+        this.stats.decreaseKSize(key);
+        this.stats.decreaseVSize(statResult);
+        this.stats.decreaseCount();
+        this.stats.incrementDeletes();
+      }
+    }
+    const result = await this._primary.deleteMany(keys);
+    if (this._secondary) {
+      if (this._nonBlocking) {
+        this._secondary.deleteMany(keys).catch((error) => {
+          this.emit("error" /* ERROR */, error);
+        });
+      } else {
+        await this._secondary.deleteMany(keys);
+      }
+    }
+    if (this._sync && result) {
+      for (const key of keys) {
+        await this._sync.publish("cache:delete" /* DELETE */, {
+          cacheId: this._cacheId,
+          key
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * Clears the primary store. If the secondary store is set then it will also clear the secondary store.
+   * @returns {Promise<void>}
+   */
+  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));
+    if (this.stats.enabled) {
+      this._stats.resetStoreValues();
+      this._stats.incrementClears();
+    }
+  }
+  /**
+   * Disconnects the primary store. If the secondary store is set then it will also disconnect the secondary store.
+   * @returns {Promise<void>}
+   */
+  async disconnect() {
+    const promises = [];
+    promises.push(this._primary.disconnect());
+    if (this._secondary) {
+      promises.push(this._secondary.disconnect());
+    }
+    promises.push(this._sync?.qified.disconnect());
+    await (this._nonBlocking ? Promise.race(promises) : Promise.all(promises));
+  }
+  /**
+   * Wraps a function with caching
+   *
+   * [Learn more about wrapping functions](https://cacheable.org/docs/cacheable/#wrap--memoization-for-sync-and-async-functions).
+   * @param {Function} function_ The function to wrap
+   * @param {WrapOptions} [options] The options for the wrap function
+   * @returns {Function} The wrapped function
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: type format
+  wrap(function_, options) {
+    const cacheAdapter = {
+      get: async (key) => this.get(key),
+      /* v8 ignore next -- @preserve */
+      has: async (key) => this.has(key),
+      set: async (key, value, ttl) => {
+        await this.set(key, value, ttl);
+      },
+      /* v8 ignore next -- @preserve */
+      on: (event, listener) => {
+        this.on(event, listener);
+      },
+      /* v8 ignore next -- @preserve */
+      emit: (event, ...args) => this.emit(event, ...args)
+    };
+    const wrapOptions = {
+      ttl: options?.ttl ?? this._ttl,
+      keyPrefix: options?.keyPrefix,
+      createKey: options?.createKey,
+      cacheErrors: options?.cacheErrors,
+      cache: cacheAdapter,
+      cacheId: this._cacheId,
+      serialize: options?.serialize
+    };
+    return (0, import_utils.wrap)(function_, wrapOptions);
+  }
+  /**
+   * Retrieves the value associated with the given key from the cache. If the key is not found,
+   * invokes the provided function to calculate the value, stores it in the cache, and then returns it.
+   *
+   * @param {GetOrSetKey} key - The key to retrieve or set in the cache. This can also be a function that returns a string key.
+   * If a function is provided, it will be called with the cache options to generate the key.
+   * @param {() => Promise<T>} function_ - The asynchronous function that computes the value to be cached if the key does not exist.
+   * @param {GetOrSetFunctionOptions} [options] - Optional settings for caching, such as the time to live (TTL) or whether to cache errors.
+   * @return {Promise<T | undefined>} - A promise that resolves to the cached or newly computed value, or undefined if an error occurs and caching is not configured for errors.
+   */
+  async getOrSet(key, function_, options) {
+    const cacheAdapter = {
+      get: async (key2) => this.get(key2),
+      /* v8 ignore next -- @preserve */
+      has: async (key2) => this.has(key2),
+      set: async (key2, value, ttl) => {
+        await this.set(key2, value, ttl);
+      },
+      /* v8 ignore next -- @preserve */
+      on: (event, listener) => {
+        this.on(event, listener);
+      },
+      emit: (event, ...args) => this.emit(event, ...args)
+    };
+    const getOrSetOptions = {
+      cache: cacheAdapter,
+      cacheId: this._cacheId,
+      ttl: options?.ttl ?? this._ttl,
+      cacheErrors: options?.cacheErrors,
+      throwErrors: options?.throwErrors
+    };
+    return (0, import_utils.getOrSet)(key, function_, getOrSetOptions);
+  }
+  /**
+   * Will hash an object asynchronously using the specified cryptographic algorithm.
+   * Use this for cryptographic algorithms (SHA-256, SHA-384, SHA-512).
+   * For non-cryptographic algorithms, use hashSync() for better performance.
+   * @param {any} object the object to hash
+   * @param {string} algorithm the hash algorithm to use. The default is 'SHA-256'
+   * @returns {Promise<string>} the hash of the object
+   */
+  async hash(object, algorithm = import_utils.HashAlgorithm.SHA256) {
+    return (0, import_utils.hash)(object, { algorithm });
+  }
+  /**
+   * Will hash an object synchronously using the specified non-cryptographic algorithm.
+   * Use this for non-cryptographic algorithms (DJB2, FNV1, MURMER, CRC32).
+   * For cryptographic algorithms, use hash() instead.
+   * @param {any} object the object to hash
+   * @param {string} algorithm the hash algorithm to use. The default is 'djb2'
+   * @returns {string} the hash of the object
+   */
+  hashSync(object, algorithm = import_utils.HashAlgorithm.DJB2) {
+    return (0, import_utils.hashSync)(object, { algorithm });
+  }
+  async setManyKeyv(keyv, items) {
+    const entries = [];
+    for (const item of items) {
+      const finalTtl = (0, import_utils.shorthandToMilliseconds)(item.ttl ?? this._ttl);
+      entries.push({ key: item.key, value: item.value, ttl: finalTtl });
+    }
+    await keyv.setMany(entries);
+    return true;
+  }
+  /**
+   * Processes a single key from secondary store for getRaw operation
+   * @param primary - the primary store to use
+   * @param secondary - the secondary store to use
+   * @param key - The key to retrieve from secondary store
+   * @returns Promise containing the result and TTL information
+   */
+  async processSecondaryForGetRaw(primary, secondary, key) {
+    const secondaryResult = await secondary.getRaw(key);
+    if (secondaryResult?.value) {
+      this.emit("cache:hit" /* CACHE_HIT */, {
+        key,
+        value: secondaryResult.value,
+        store: "secondary"
+      });
+      const cascadeTtl = (0, import_utils.getCascadingTtl)(this._ttl, this._primary.ttl);
+      const expires = secondaryResult.expires ?? void 0;
+      const ttl = (0, import_utils.calculateTtlFromExpiration)(cascadeTtl, expires);
+      const setItem = { key, value: secondaryResult.value, ttl };
+      await this.hook("BEFORE_SECONDARY_SETS_PRIMARY" /* BEFORE_SECONDARY_SETS_PRIMARY */, setItem);
+      await primary.set(setItem.key, setItem.value, setItem.ttl);
+      return { result: secondaryResult, ttl };
+    } else {
+      this.emit("cache:miss" /* CACHE_MISS */, { key, store: "secondary" });
+      return void 0;
+    }
+  }
+  /**
+   * Processes a single key from secondary store for getRaw operation in non-blocking mode
+   * Non-blocking mode means we don't wait for secondary operations that update primary store
+   * @param primary - the primary store to use
+   * @param secondary - the secondary store to use
+   * @param key - The key to retrieve from secondary store
+   * @returns Promise containing the result and TTL information
+   */
+  async processSecondaryForGetRawNonBlocking(primary, secondary, key) {
+    const secondaryResult = await secondary.getRaw(key);
+    if (secondaryResult?.value) {
+      this.emit("cache:hit" /* CACHE_HIT */, {
+        key,
+        value: secondaryResult.value,
+        store: "secondary"
+      });
+      const cascadeTtl = (0, import_utils.getCascadingTtl)(this._ttl, this._primary.ttl);
+      const expires = secondaryResult.expires ?? void 0;
+      const ttl = (0, import_utils.calculateTtlFromExpiration)(cascadeTtl, expires);
+      const setItem = { key, value: secondaryResult.value, ttl };
+      this.hook("BEFORE_SECONDARY_SETS_PRIMARY" /* BEFORE_SECONDARY_SETS_PRIMARY */, setItem).then(async () => {
+        await primary.set(setItem.key, setItem.value, setItem.ttl);
+      }).catch((error) => {
+        this.emit("error" /* ERROR */, error);
+      });
+      return { result: secondaryResult, ttl };
+    } else {
+      this.emit("cache:miss" /* CACHE_MISS */, { key, store: "secondary" });
+      return void 0;
+    }
+  }
+  /**
+   * Processes missing keys from secondary store for getManyRaw operation
+   * @param primary - the primary store to use
+   * @param secondary - the secondary store to use
+   * @param keys - The original array of keys requested
+   * @param result - The result array from primary store (will be modified)
+   * @returns Promise<void>
+   */
+  async processSecondaryForGetManyRaw(primary, secondary, keys, result) {
+    const missingKeys = [];
+    for (const [i, key] of keys.entries()) {
+      if (!result[i]) {
+        missingKeys.push(key);
+      }
+    }
+    const secondaryResults = await secondary.getManyRaw(missingKeys);
+    let secondaryIndex = 0;
+    for await (const [i, key] of keys.entries()) {
+      if (!result[i]) {
+        const secondaryResult = secondaryResults[secondaryIndex];
+        if (secondaryResult && secondaryResult.value !== void 0) {
+          result[i] = secondaryResult;
+          this.emit("cache:hit" /* CACHE_HIT */, {
+            key,
+            value: secondaryResult.value,
+            store: "secondary"
+          });
+          const cascadeTtl = (0, import_utils.getCascadingTtl)(this._ttl, this._primary.ttl);
+          let { expires } = secondaryResult;
+          if (expires === null) {
+            expires = void 0;
+          }
+          const ttl = (0, import_utils.calculateTtlFromExpiration)(cascadeTtl, expires);
+          const setItem = { key, value: secondaryResult.value, ttl };
+          await this.hook(
+            "BEFORE_SECONDARY_SETS_PRIMARY" /* BEFORE_SECONDARY_SETS_PRIMARY */,
+            setItem
+          );
+          await primary.set(setItem.key, setItem.value, setItem.ttl);
+        } else {
+          this.emit("cache:miss" /* CACHE_MISS */, {
+            key,
+            store: "secondary"
+          });
+        }
+        secondaryIndex++;
+      }
+    }
+  }
+  /**
+   * Processes missing keys from secondary store for getManyRaw operation in non-blocking mode
+   * Non-blocking mode means we don't wait for secondary operations that update primary store
+   * @param secondary - the secondary store to use
+   * @param keys - The original array of keys requested
+   * @param result - The result array from primary store (will be modified)
+   * @returns Promise<void>
+   */
+  async processSecondaryForGetManyRawNonBlocking(primary, secondary, keys, result) {
+    const missingKeys = [];
+    for (const [i, key] of keys.entries()) {
+      if (!result[i]) {
+        missingKeys.push(key);
+      }
+    }
+    const secondaryResults = await secondary.getManyRaw(missingKeys);
+    let secondaryIndex = 0;
+    for await (const [i, key] of keys.entries()) {
+      if (!result[i]) {
+        const secondaryResult = secondaryResults[secondaryIndex];
+        if (secondaryResult && secondaryResult.value !== void 0) {
+          result[i] = secondaryResult;
+          this.emit("cache:hit" /* CACHE_HIT */, {
+            key,
+            value: secondaryResult.value,
+            store: "secondary"
+          });
+          const cascadeTtl = (0, import_utils.getCascadingTtl)(this._ttl, this._primary.ttl);
+          let { expires } = secondaryResult;
+          if (expires === null) {
+            expires = void 0;
+          }
+          const ttl = (0, import_utils.calculateTtlFromExpiration)(cascadeTtl, expires);
+          const setItem = { key, value: secondaryResult.value, ttl };
+          this.hook("BEFORE_SECONDARY_SETS_PRIMARY" /* BEFORE_SECONDARY_SETS_PRIMARY */, setItem).then(async () => {
+            await primary.set(setItem.key, setItem.value, setItem.ttl);
+          }).catch((error) => {
+            this.emit("error" /* ERROR */, error);
+          });
+        } else {
+          this.emit("cache:miss" /* CACHE_MISS */, {
+            key,
+            store: "secondary"
+          });
+        }
+        secondaryIndex++;
+      }
+    }
+  }
+  setTtl(ttl) {
+    if (typeof ttl === "string" || ttl === void 0) {
+      this._ttl = ttl;
+    } else if (ttl > 0) {
+      this._ttl = ttl;
+    } else {
+      this._ttl = void 0;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cacheable,
+  CacheableEvents,
+  CacheableHooks,
+  CacheableMemory,
+  CacheableStats,
+  CacheableSync,
+  CacheableSyncEvents,
+  HashAlgorithm,
+  Keyv,
+  KeyvCacheableMemory,
+  KeyvHooks,
+  calculateTtlFromExpiration,
+  createKeyv,
+  getCascadingTtl,
+  getOrSet,
+  hash,
+  shorthandToMilliseconds,
+  shorthandToTime,
+  wrap,
+  wrapSync
+});
+/* v8 ignore next -- @preserve */