@warlock.js/cache 4.0.39 → 4.0.42

package/esm/index.js

@@ -1,3 +1,1681 @@
-import {log}from'@warlock.js/logger';import {rtrim,unset,get,set}from'@mongez/reinforcements';import {removeDirectoryAsync,ensureDirectoryAsync,putJsonFileAsync,getJsonFileAsync}from'@mongez/fs';import p from'path';var d=class extends Error{constructor(e){super(e),this.name="CacheError";}},x=class extends d{constructor(e){super(e),this.name="CacheConnectionError";}},u=class extends d{constructor(e){super(e),this.name="CacheConfigurationError";}},v=class extends d{constructor(e="No cache driver initialized. Call cache.init() or cache.use() first."){super(e),this.name="CacheDriverNotInitializedError";}};var C=class{currentDriver;loadedDrivers={};configurations={drivers:{},options:{}};globalEventListeners=new Map;name="cacheManager";get client(){return this.currentDriver?.client}setCacheConfigurations(e){this.configurations.default=e.default,this.configurations.drivers=e.drivers,this.configurations.options=e.options;}async use(e){if(typeof e=="string"){let t=await this.load(e);if(!t)throw new u(`Cache driver ${e} is not found, please declare it in the cache drivers in the configurations list.`);e=t;}return this.attachGlobalListeners(e),this.currentDriver=e,this}ensureDriverInitialized(){if(!this.currentDriver)throw new v}async get(e){return this.ensureDriverInitialized(),this.currentDriver.get(e)}async set(e,t,i){return this.ensureDriverInitialized(),this.currentDriver.set(e,t,i)}async remove(e){return this.ensureDriverInitialized(),this.currentDriver.remove(e)}async removeNamespace(e){return this.ensureDriverInitialized(),this.currentDriver.removeNamespace(e)}async flush(){return this.ensureDriverInitialized(),this.currentDriver.flush()}async connect(){return this.ensureDriverInitialized(),this.currentDriver.connect()}parseKey(e){return this.ensureDriverInitialized(),this.currentDriver.parseKey(e)}get options(){return this.ensureDriverInitialized(),this.currentDriver.options}setOptions(e){return this.ensureDriverInitialized(),this.currentDriver.setOptions(e||{})}async driver(e){return this.loadedDrivers[e]||await this.load(e)}async init(){let e=this.configurations.default;if(!e)return;let t=await this.driver(e);await this.use(t);}async load(e){if(this.loadedDrivers[e])return this.loadedDrivers[e];let t=this.configurations.drivers[e];if(!t)throw new u(`Cache driver ${e} is not found, please declare it in the cache drivers in the configurations list.`);let i=new t;return i.setOptions(this.configurations.options[e]||{}),await i.connect(),this.attachGlobalListeners(i),this.loadedDrivers[e]=i,i}registerDriver(e,t){this.configurations.drivers[e]=t;}async disconnect(){this.currentDriver&&await this.currentDriver.disconnect();}async has(e){return this.ensureDriverInitialized(),this.currentDriver.has(e)}async remember(e,t,i){return this.ensureDriverInitialized(),this.currentDriver.remember(e,t,i)}async pull(e){return this.ensureDriverInitialized(),this.currentDriver.pull(e)}async forever(e,t){return this.ensureDriverInitialized(),this.currentDriver.forever(e,t)}async increment(e,t){return this.ensureDriverInitialized(),this.currentDriver.increment(e,t)}async decrement(e,t){return this.ensureDriverInitialized(),this.currentDriver.decrement(e,t)}async many(e){return this.ensureDriverInitialized(),this.currentDriver.many(e)}async setMany(e,t){return this.ensureDriverInitialized(),this.currentDriver.setMany(e,t)}on(e,t){this.globalEventListeners.has(e)||this.globalEventListeners.set(e,new Set),this.globalEventListeners.get(e).add(t),this.currentDriver&&this.currentDriver.on(e,t);for(let i of Object.values(this.loadedDrivers))i.on(e,t);return this}off(e,t){let i=this.globalEventListeners.get(e);i&&i.delete(t),this.currentDriver&&this.currentDriver.off(e,t);for(let r of Object.values(this.loadedDrivers))r.off(e,t);return this}once(e,t){let i=async r=>{await t(r),this.off(e,i);};return this.on(e,i)}attachGlobalListeners(e){for(let[t,i]of this.globalEventListeners)for(let r of i)e.on(t,r);}async setNX(e,t,i){if(this.ensureDriverInitialized(),!this.currentDriver.setNX)throw new Error(`setNX is not supported by the current cache driver: ${this.currentDriver.name}`);return this.currentDriver.setNX(e,t,i)}tags(e){return this.ensureDriverInitialized(),this.currentDriver.tags(e)}},J=new C;var f=class{cacheTags;driver;constructor(e,t){this.cacheTags=e,this.driver=t;}tagKey(e){return `cache:tags:${e}`}async storeTaggedKey(e){for(let t of this.cacheTags){let i=this.tagKey(t),r=await this.driver.get(i)||[];r.includes(e)||(r.push(e),await this.driver.set(i,r,1/0));}}async getTaggedKeys(){let e=new Set;for(let t of this.cacheTags){let i=this.tagKey(t),r=await this.driver.get(i)||[];for(let s of r)e.add(s);}return e}async set(e,t,i){let r=this.driver.parseKey(e);return await this.driver.set(e,t,i),await this.storeTaggedKey(r),t}async get(e){return this.driver.get(e)}async remove(e){let t=this.driver.parseKey(e);await this.driver.remove(e);for(let i of this.cacheTags){let r=this.tagKey(i),c=(await this.driver.get(r)||[]).filter(h=>h!==t);await this.driver.set(r,c,1/0);}}async invalidate(){let e=await this.getTaggedKeys();for(let t of e)await this.driver.remove(t);for(let t of this.cacheTags)await this.driver.remove(this.tagKey(t));}async flush(){return this.invalidate()}async has(e){return this.driver.has(e)}async remember(e,t,i){let r=await this.get(e);if(r!==null)return r;let s=await i();return await this.set(e,s,t),s}async pull(e){let t=await this.get(e);return t!==null&&await this.remove(e),t}async forever(e,t){return this.set(e,t,1/0)}async increment(e,t=1){let i=await this.get(e)||0;if(typeof i!="number")throw new Error(`Cannot increment non-numeric value for key: ${this.driver.parseKey(e)}`);let r=i+t;return await this.set(e,r),r}async decrement(e,t=1){return this.increment(e,-t)}};function O(n,e={}){typeof n=="object"&&(n=JSON.stringify(n)),n=n.replace(/[{}"[\]]/g,"").replaceAll(/[:,]/g,".");let t=typeof e.globalPrefix=="function"?e.globalPrefix():e.globalPrefix;return rtrim(String(t?rtrim(t,".")+"."+n:n),".")}var L=(a=>(a[a.HALF_HOUR=1800]="HALF_HOUR",a[a.ONE_HOUR=3600]="ONE_HOUR",a[a.HALF_DAY=43200]="HALF_DAY",a[a.ONE_DAY=86400]="ONE_DAY",a[a.ONE_WEEK=604800]="ONE_WEEK",a[a.HALF_MONTH=1296e3]="HALF_MONTH",a[a.ONE_MONTH=2592e3]="ONE_MONTH",a[a.TWO_MONTHS=5184e3]="TWO_MONTHS",a[a.SIX_MONTHS=15768e3]="SIX_MONTHS",a[a.ONE_YEAR=31536e3]="ONE_YEAR",a))(L||{});var D={clearing:"Clearing namespace",cleared:"Namespace cleared",fetching:"Fetching key",fetched:"Key fetched",caching:"Caching key",cached:"Key cached",flushing:"Flushing cache",flushed:"Cache flushed",removing:"Removing key",removed:"Key removed",expired:"Key expired",notFound:"Key not found",connecting:"Connecting to the cache engine.",connected:"Connected to the cache engine.",disconnecting:"Disconnecting from the cache engine.",disconnected:"Disconnected from the cache engine.",error:"Error occurred"},o=class{clientDriver;get client(){return this.clientDriver||this}set client(e){this.clientDriver=e;}options;eventListeners=new Map;parseKey(e){return O(e,this.options)}setOptions(e){return this.options=e||{},this}on(e,t){return this.eventListeners.has(e)||this.eventListeners.set(e,new Set),this.eventListeners.get(e).add(t),this}off(e,t){let i=this.eventListeners.get(e);return i&&i.delete(t),this}once(e,t){let i=async r=>{await t(r),this.off(e,i);};return this.on(e,i)}async emit(e,t={}){let i=this.eventListeners.get(e);if(!i||i.size===0)return;let r={driver:this.name,...t},s=[];for(let c of i)try{let h=c(r);h instanceof Promise&&s.push(h);}catch(h){this.logError(`Error in event handler for '${e}'`,h);}s.length>0&&await Promise.allSettled(s);}async has(e){return await this.get(e)!==null}locks=new Map;async remember(e,t,i){let r=this.parseKey(e),s=await this.get(e);if(s!==null)return s;let c=this.locks.get(r);if(c)return c;let h=i().then(async m=>(await this.set(e,m,t),this.locks.delete(r),m)).catch(m=>{throw this.locks.delete(r),m});return this.locks.set(r,h),h}async pull(e){let t=await this.get(e);return t!==null&&await this.remove(e),t}async forever(e,t){return this.set(e,t,1/0)}async increment(e,t=1){let i=await this.get(e)||0;if(typeof i!="number")throw new Error(`Cannot increment non-numeric value for key: ${this.parseKey(e)}`);let r=i+t;return await this.set(e,r),r}async decrement(e,t=1){return this.increment(e,-t)}async many(e){return Promise.all(e.map(t=>this.get(t)))}async setMany(e,t){await Promise.all(Object.entries(e).map(([i,r])=>this.set(i,r,t)));}log(e,t){if(t&&(t=t.replaceAll("/",".")),e=="notFound"||e=="expired")return log.warn("cache:"+this.name,e,(t?t+" ":"")+D[e]);if(e.endsWith("ed"))return log.success("cache:"+this.name,e,(t?t+" ":"")+D[e]);log.info("cache:"+this.name,e,(t?t+" ":"")+D[e]);}logError(e,t){log.error("cache:"+this.name,"error",e),t&&console.log(t);}get ttl(){return this.options.ttl!==void 0?this.options.ttl:1/0}getExpiresAt(e=this.ttl){if(e)return new Date().getTime()+e*1e3}prepareDataForStorage(e,t){let i={data:e};return t&&(i.ttl=t,i.expiresAt=this.getExpiresAt(t)),i}async parseCachedData(e,t){if(this.log("fetched",e),t.expiresAt&&t.expiresAt<Date.now())return this.remove(e),null;let i=t.data;if(i==null)return i;let r=typeof i;if(r==="string"||r==="number"||r==="boolean")return i;try{return structuredClone(i)}catch(s){throw console.log(i),this.logError(`Failed to clone cached value for ${e}, typeof value: ${typeof i}`,s),s}}async connect(){this.log("connecting"),this.log("connected"),await this.emit("connected");}async disconnect(){this.log("disconnected"),await this.emit("disconnected");}tags(e){return new f(e,this)}};var E=class extends o{name="file";setOptions(e){if(!e.directory)throw new u("File driver requires 'directory' option to be configured.");return super.setOptions(e)}get directory(){let e=this.options.directory;if(typeof e=="function")return e();throw new u("Cache directory is not defined, please define it in the file driver options")}get fileName(){let e=this.options.fileName;return typeof e=="function"?e():"cache.json"}async removeNamespace(e){this.log("clearing",e);try{await removeDirectoryAsync(p.resolve(this.directory,e)),this.log("cleared",e);}catch{}return this}async set(e,t,i){e=this.parseKey(e),this.log("caching",e);let r=this.prepareDataForStorage(t,i),s=p.resolve(this.directory,e);return await ensureDirectoryAsync(s),await putJsonFileAsync(p.resolve(s,this.fileName),r),this.log("cached",e),await this.emit("set",{key:e,value:t,ttl:i}),this}async get(e){let t=this.parseKey(e);this.log("fetching",t);let i=p.resolve(this.directory,t);try{let r=await getJsonFileAsync(p.resolve(i,this.fileName)),s=await this.parseCachedData(t,r);return s===null?await this.emit("miss",{key:t}):await this.emit("hit",{key:t,value:s}),s}catch{return this.log("notFound",t),await this.emit("miss",{key:t}),this.remove(e),null}}async remove(e){let t=this.parseKey(e);this.log("removing",t);let i=p.resolve(this.directory,t);try{await removeDirectoryAsync(i),this.log("removed",t),await this.emit("removed",{key:t});}catch{}}async flush(){this.log("flushing"),this.options.globalPrefix?await this.removeNamespace(""):await removeDirectoryAsync(this.directory),this.log("flushed"),await this.emit("flushed");}async connect(){this.log("connecting"),await ensureDirectoryAsync(this.directory),this.log("connected"),await this.emit("connected");}};var y=class{constructor(e,t,i){this.key=e;this.value=t;i&&i!==1/0&&(this.expiresAt=Date.now()+i*1e3);}next=null;prev=null;expiresAt;get isExpired(){return this.expiresAt!==void 0&&this.expiresAt<Date.now()}},T=class extends o{name="lru";cache=new Map;head=new y("",null);tail=new y("",null);cleanupInterval;constructor(){super(),this.init(),this.startCleanup();}init(){this.head.next=this.tail,this.tail.prev=this.head;}startCleanup(){this.cleanupInterval&&clearInterval(this.cleanupInterval),this.cleanupInterval=setInterval(async()=>{let e=Date.now(),t=[];for(let[i,r]of this.cache)r.expiresAt&&r.expiresAt<=e&&t.push(i);for(let i of t){let r=this.cache.get(i);r&&(this.removeNode(r),this.cache.delete(i),this.log("expired",i),await this.emit("expired",{key:i}));}},1e3),this.cleanupInterval.unref();}async removeNamespace(e){throw new Error("Namespace is not supported in LRU cache driver.")}async set(e,t,i){e=this.parseKey(e),this.log("caching",e),i===void 0&&(i=this.ttl);let r=this.cache.get(e);if(r)r.value=t,i&&i!==1/0?r.expiresAt=Date.now()+i*1e3:r.expiresAt=void 0,this.moveHead(r);else {let s=new y(e,t,i);this.cache.set(e,s),this.addNode(s),this.cache.size>this.capacity&&this.removeTail();}return this.log("cached",e),await this.emit("set",{key:e,value:t,ttl:i}),this}moveHead(e){this.removeNode(e),this.addNode(e);}removeNode(e){e.prev.next=e.next,e.next.prev=e.prev;}addNode(e){e.next=this.head.next,e.prev=this.head,this.head.next.prev=e,this.head.next=e;}removeTail(){let e=this.tail.prev;this.removeNode(e),this.cache.delete(e.key);}async get(e){let t=this.parseKey(e);this.log("fetching",t);let i=this.cache.get(t);if(!i)return this.log("notFound",t),await this.emit("miss",{key:t}),null;if(i.isExpired)return this.removeNode(i),this.cache.delete(t),this.log("expired",t),await this.emit("expired",{key:t}),await this.emit("miss",{key:t}),null;this.moveHead(i),this.log("fetched",t);let r=i.value;if(r==null)return r;let s=typeof r;if(s==="string"||s==="number"||s==="boolean")return await this.emit("hit",{key:t,value:r}),r;try{let c=structuredClone(r);return await this.emit("hit",{key:t,value:c}),c}catch(c){throw this.logError(`Failed to clone cached value for ${t}`,c),c}}async remove(e){let t=this.parseKey(e);this.log("removing",t);let i=this.cache.get(t);i&&(this.removeNode(i),this.cache.delete(t)),this.log("removed",t),await this.emit("removed",{key:t});}async flush(){this.log("flushing"),this.cache.clear(),this.init(),this.log("flushed"),await this.emit("flushed");}get capacity(){return this.options.capacity||1e3}async disconnect(){this.cleanupInterval&&(clearInterval(this.cleanupInterval),this.cleanupInterval=void 0),await super.disconnect();}};var b=class extends o{name="memory";data={};temporaryData={};cleanupInterval;accessOrder=[];constructor(){super(),this.startCleanup();}startCleanup(){this.cleanupInterval&&clearInterval(this.cleanupInterval),this.cleanupInterval=setInterval(async()=>{let e=Date.now();for(let t in this.temporaryData)this.temporaryData[t].expiresAt<=e&&(await this.remove(this.temporaryData[t].key),delete this.temporaryData[t],this.log("expired",t),await this.emit("expired",{key:t}));},1e3),this.cleanupInterval.unref();}async removeNamespace(e){return this.log("clearing",e),e=this.parseKey(e),unset(this.data,[e]),this.log("cleared",e),this}async set(e,t,i){let r=this.parseKey(e);this.log("caching",r),i===void 0&&(i=this.ttl);let s=this.prepareDataForStorage(t,i);i&&this.setTemporaryData(e,r,i);let h=!get(this.data,r);return set(this.data,r,s),this.trackAccess(r),h&&this.options.maxSize&&await this.enforceMaxSize(),this.log("cached",r),await this.emit("set",{key:r,value:t,ttl:i}),this}async get(e){let t=this.parseKey(e);this.log("fetching",t);let i=get(this.data,t);if(!i)return this.log("notFound",t),await this.emit("miss",{key:t}),null;let r=await this.parseCachedData(t,i);return r===null?await this.emit("miss",{key:t}):(this.trackAccess(t),await this.emit("hit",{key:t,value:r})),r}async remove(e){let t=this.parseKey(e);this.log("removing",t),unset(this.data,[t]),delete this.temporaryData[t],this.removeFromAccessOrder(t),this.log("removed",t),await this.emit("removed",{key:t});}async flush(){this.log("flushing"),this.options.globalPrefix?this.removeNamespace(""):(this.data={},this.accessOrder=[]),this.log("flushed"),await this.emit("flushed");}setTemporaryData(e,t,i){this.temporaryData[t]={key:JSON.stringify(e),expiresAt:Date.now()+i*1e3};}trackAccess(e){if(!this.options.maxSize)return;let t=this.accessOrder.indexOf(e);t>-1&&this.accessOrder.splice(t,1),this.accessOrder.push(e);}removeFromAccessOrder(e){let t=this.accessOrder.indexOf(e);t>-1&&this.accessOrder.splice(t,1);}async enforceMaxSize(){if(!this.options.maxSize)return;let e=this.getCacheSize();for(;e>this.options.maxSize&&this.accessOrder.length>0;){let t=this.accessOrder.shift();t&&(this.log("removing",t),unset(this.data,[t]),delete this.temporaryData[t],this.log("removed",t));}}getCacheSize(){return Object.keys(this.data).length}async disconnect(){this.cleanupInterval&&(clearInterval(this.cleanupInterval),this.cleanupInterval=void 0),await super.disconnect();}};var M=class extends b{name="memoryExtended";async get(e){let t=this.parseKey(e);this.log("fetching",t);let i=get(this.data,t);if(!i)return this.log("notFound",t),null;let r=i.ttl||this.options.ttl;return r&&(this.setTemporaryData(e,t,r),i.expiresAt=this.getExpiresAt(r)),this.parseCachedData(t,i)}};var z=class extends o{options={};name="null";data={};get client(){return this}constructor(e={}){super(),this.setOptions(e);}setOptions(e){return this.options=e,this}parseKey(e){return ""}async removeNamespace(e){return log.info("cache","clearing namespace",e),log.success("cache","namespace cleared",e),this}async set(e,t){return log.info("cache","setting key",e),log.success("cache","key set",e),this}async get(e){return log.info("cache","fetching",e),log.success("cache","fetched",e),null}async remove(e){log.info("cache","removing",e),log.success("cache","removed",e);}async flush(){log.info("cache","flushing","all"),log.success("cache","flushed","all");}async connect(){log.success("cache","connected","Connected to null cache driver");}};var S=class extends o{name="redis";setOptions(e){if(!e.url&&!e.host)throw new u("Redis driver requires either 'url' or 'host' option to be configured.");return super.setOptions(e)}async removeNamespace(e){e=this.parseKey(e),this.log("clearing",e);let t=await this.client?.keys(`${e}*`);if(!t||t.length===0){this.log("notFound",e);return}return await this.client?.del(t),this.log("cleared",e),t}async set(e,t,i){return e=this.parseKey(e),this.log("caching",e),i===void 0&&(i=this.ttl),i&&i!==1/0?await this.client?.set(e,JSON.stringify(t),{EX:i}):await this.client?.set(e,JSON.stringify(t)),this.log("cached",e),await this.emit("set",{key:e,value:t,ttl:i}),t}async get(e){e=this.parseKey(e),this.log("fetching",e);let t=await this.client?.get(e);if(!t)return this.log("notFound",e),await this.emit("miss",{key:e}),null;this.log("fetched",e);let i=JSON.parse(t);if(i==null)return await this.emit("hit",{key:e,value:i}),i;let r=typeof i;if(r==="string"||r==="number"||r==="boolean")return await this.emit("hit",{key:e,value:i}),i;try{let s=structuredClone(i);return await this.emit("hit",{key:e,value:s}),s}catch(s){throw this.logError(`Failed to clone cached value for ${e}`,s),s}}async remove(e){e=this.parseKey(e),this.log("removing",e),await this.client?.del(e),this.log("removed",e),await this.emit("removed",{key:e});}async flush(){this.log("flushing"),this.options.globalPrefix?await this.removeNamespace(""):await this.client?.flushAll(),this.log("flushed"),await this.emit("flushed");}async connect(){if(this.clientDriver)return;let e=this.options;if(e&&!e.url&&e.host){let r=e.password||e.username?`${e.username}:${e.password}@`:"";if(!e.url){let s=e.host||"localhost",c=e.port||6379;e.url=`redis://${r}${s}:${c}`;}}let t={...e,...this.options.clientOptions||{}};this.log("connecting");let{createClient:i}=await import('redis');this.client=i(t),this.client.on("error",r=>{this.log("error",r.message);});try{await this.client.connect(),this.log("connected"),await this.emit("connected");}catch(r){log.error("cache","redis",r),await this.emit("error",{error:r});}}async disconnect(){this.client&&(this.log("disconnecting"),await this.client.quit(),this.log("disconnected"),await this.emit("disconnected"));}async increment(e,t=1){let i=this.parseKey(e);this.log("caching",i);let r=await this.client?.incrBy(i,t);return this.log("cached",i),await this.emit("set",{key:i,value:r,ttl:void 0}),r||0}async decrement(e,t=1){let i=this.parseKey(e);this.log("caching",i);let r=await this.client?.decrBy(i,t);return this.log("cached",i),await this.emit("set",{key:i,value:r,ttl:void 0}),r||0}async setNX(e,t,i){let r=this.parseKey(e);this.log("caching",r),i===void 0&&(i=this.ttl);let s;i&&i!==1/0?s=await this.client?.set(r,JSON.stringify(t),{NX:true,EX:i}):s=await this.client?.set(r,JSON.stringify(t),{NX:true});let c=s==="OK";return c?(this.log("cached",r),await this.emit("set",{key:r,value:t,ttl:i})):this.log("notFound",r),c}};
-export{o as BaseCacheDriver,L as CACHE_FOR,u as CacheConfigurationError,x as CacheConnectionError,v as CacheDriverNotInitializedError,d as CacheError,C as CacheManager,E as FileCacheDriver,T as LRUMemoryCacheDriver,b as MemoryCacheDriver,M as MemoryExtendedCacheDriver,z as NullCacheDriver,S as RedisCacheDriver,f as TaggedCache,J as cache,O as parseCacheKey};//# sourceMappingURL=index.js.map
+import { log } from '@warlock.js/logger';
+import { rtrim, unset, get, set } from '@mongez/reinforcements';
+import { removeDirectoryAsync, ensureDirectoryAsync, putJsonFileAsync, getJsonFileAsync } from '@mongez/fs';
+import path from 'path';
+
+// ../../warlock.js/cache/src/types.ts
+var CacheError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CacheError";
+  }
+};
+var CacheConnectionError = class extends CacheError {
+  constructor(message) {
+    super(message);
+    this.name = "CacheConnectionError";
+  }
+};
+var CacheConfigurationError = class extends CacheError {
+  constructor(message) {
+    super(message);
+    this.name = "CacheConfigurationError";
+  }
+};
+var CacheDriverNotInitializedError = class extends CacheError {
+  constructor(message = "No cache driver initialized. Call cache.init() or cache.use() first.") {
+    super(message);
+    this.name = "CacheDriverNotInitializedError";
+  }
+};
+
+// ../../warlock.js/cache/src/cache-manager.ts
+var CacheManager = class {
+  /**
+   * Cache Driver
+   */
+  currentDriver;
+  /**
+   * Loaded drivers
+   */
+  loadedDrivers = {};
+  /**
+   * Configurations list
+   */
+  configurations = {
+    drivers: {},
+    options: {}
+  };
+  /**
+   * Global event listeners
+   */
+  globalEventListeners = /* @__PURE__ */ new Map();
+  /**
+   * {@inheritdoc}
+   */
+  name = "cacheManager";
+  /**
+   * {@inheritdoc}
+   */
+  get client() {
+    return this.currentDriver?.client;
+  }
+  /**
+   * Set the cache configurations
+   */
+  setCacheConfigurations(configurations) {
+    this.configurations.default = configurations.default;
+    this.configurations.drivers = configurations.drivers;
+    this.configurations.options = configurations.options;
+  }
+  /**
+   * Use the given driver
+   */
+  async use(driver) {
+    if (typeof driver === "string") {
+      const driverInstance = await this.load(driver);
+      if (!driverInstance) {
+        throw new CacheConfigurationError(
+          `Cache driver ${driver} is not found, please declare it in the cache drivers in the configurations list.`
+        );
+      }
+      driver = driverInstance;
+    }
+    this.attachGlobalListeners(driver);
+    this.currentDriver = driver;
+    return this;
+  }
+  /**
+   * Ensure driver is initialized before operations
+   */
+  ensureDriverInitialized() {
+    if (!this.currentDriver) {
+      throw new CacheDriverNotInitializedError();
+    }
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async get(key) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.get(key);
+  }
+  /**
+   * Set a value in the cache
+   *
+   * @param key The cache key, could be an object or string
+   * @param value The value to be stored in the cache
+   * @param ttl The time to live in seconds
+   */
+  async set(key, value, ttl) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.set(key, value, ttl);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async remove(key) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.remove(key);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async removeNamespace(namespace) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.removeNamespace(namespace);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async flush() {
+    this.ensureDriverInitialized();
+    return this.currentDriver.flush();
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async connect() {
+    this.ensureDriverInitialized();
+    return this.currentDriver.connect();
+  }
+  /**
+   * {@inheritdoc}
+   */
+  parseKey(key) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.parseKey(key);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  get options() {
+    this.ensureDriverInitialized();
+    return this.currentDriver.options;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  setOptions(options) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.setOptions(options || {});
+  }
+  /**
+   * Get an instance of the cache driver
+   */
+  async driver(driverName) {
+    return this.loadedDrivers[driverName] || await this.load(driverName);
+  }
+  /**
+   * Initialize the cache manager and pick the default driver
+   */
+  async init() {
+    const defaultCacheDriverName = this.configurations.default;
+    if (!defaultCacheDriverName) {
+      return;
+    }
+    const driver = await this.driver(defaultCacheDriverName);
+    await this.use(driver);
+  }
+  /**
+   * Load the given cache driver name
+   */
+  async load(driver) {
+    if (this.loadedDrivers[driver]) return this.loadedDrivers[driver];
+    const Driver = this.configurations.drivers[driver];
+    if (!Driver) {
+      throw new CacheConfigurationError(
+        `Cache driver ${driver} is not found, please declare it in the cache drivers in the configurations list.`
+      );
+    }
+    const driverInstance = new Driver();
+    driverInstance.setOptions(
+      this.configurations.options[driver] || {}
+    );
+    await driverInstance.connect();
+    this.attachGlobalListeners(driverInstance);
+    this.loadedDrivers[driver] = driverInstance;
+    return driverInstance;
+  }
+  /**
+   * Register and bind a driver
+   */
+  registerDriver(driverName, driverClass) {
+    this.configurations.drivers[driverName] = driverClass;
+  }
+  /**
+   * Disconnect the cache manager
+   */
+  async disconnect() {
+    if (this.currentDriver) {
+      await this.currentDriver.disconnect();
+    }
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async has(key) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.has(key);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async remember(key, ttl, callback) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.remember(key, ttl, callback);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async pull(key) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.pull(key);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async forever(key, value) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.forever(key, value);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async increment(key, value) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.increment(key, value);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async decrement(key, value) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.decrement(key, value);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async many(keys) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.many(keys);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async setMany(items, ttl) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.setMany(items, ttl);
+  }
+  /**
+   * Register a global event listener (applies to all drivers)
+   */
+  on(event, handler) {
+    if (!this.globalEventListeners.has(event)) {
+      this.globalEventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.globalEventListeners.get(event).add(handler);
+    if (this.currentDriver) {
+      this.currentDriver.on(event, handler);
+    }
+    for (const driver of Object.values(this.loadedDrivers)) {
+      driver.on(event, handler);
+    }
+    return this;
+  }
+  /**
+   * Remove a global event listener
+   */
+  off(event, handler) {
+    const handlers = this.globalEventListeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+    if (this.currentDriver) {
+      this.currentDriver.off(event, handler);
+    }
+    for (const driver of Object.values(this.loadedDrivers)) {
+      driver.off(event, handler);
+    }
+    return this;
+  }
+  /**
+   * Register a one-time global event listener
+   */
+  once(event, handler) {
+    const onceHandler = async (data) => {
+      await handler(data);
+      this.off(event, onceHandler);
+    };
+    return this.on(event, onceHandler);
+  }
+  /**
+   * Attach global listeners to a driver
+   */
+  attachGlobalListeners(driver) {
+    for (const [event, handlers] of this.globalEventListeners) {
+      for (const handler of handlers) {
+        driver.on(event, handler);
+      }
+    }
+  }
+  /**
+   * Set if not exists (atomic operation)
+   * Returns true if key was set, false if key already existed
+   * Note: Only supported by drivers that implement setNX (e.g., Redis)
+   */
+  async setNX(key, value, ttl) {
+    this.ensureDriverInitialized();
+    if (!this.currentDriver.setNX) {
+      throw new Error(
+        `setNX is not supported by the current cache driver: ${this.currentDriver.name}`
+      );
+    }
+    return this.currentDriver.setNX(key, value, ttl);
+  }
+  /**
+   * Create a tagged cache instance for the given tags
+   */
+  tags(tags) {
+    this.ensureDriverInitialized();
+    return this.currentDriver.tags(tags);
+  }
+};
+var cache = new CacheManager();
+
+// ../../warlock.js/cache/src/tagged-cache.ts
+var TaggedCache = class {
+  /**
+   * The tags associated with this tagged cache instance
+   */
+  cacheTags;
+  /**
+   * The underlying cache driver
+   */
+  driver;
+  /**
+   * Constructor
+   */
+  constructor(tags, driver) {
+    this.cacheTags = tags;
+    this.driver = driver;
+  }
+  /**
+   * Get the tag key prefix for storing tag-key relationships
+   */
+  tagKey(tag) {
+    return `cache:tags:${tag}`;
+  }
+  /**
+   * Store tag-key relationship
+   */
+  async storeTaggedKey(key) {
+    for (const tag of this.cacheTags) {
+      const tagKey = this.tagKey(tag);
+      const keys = await this.driver.get(tagKey) || [];
+      if (!keys.includes(key)) {
+        keys.push(key);
+        await this.driver.set(tagKey, keys, Infinity);
+      }
+    }
+  }
+  /**
+   * Get all keys associated with tags
+   */
+  async getTaggedKeys() {
+    const allKeys = /* @__PURE__ */ new Set();
+    for (const tag of this.cacheTags) {
+      const tagKey = this.tagKey(tag);
+      const keys = await this.driver.get(tagKey) || [];
+      for (const key of keys) {
+        allKeys.add(key);
+      }
+    }
+    return allKeys;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async set(key, value, ttl) {
+    const parsedKey = this.driver.parseKey(key);
+    await this.driver.set(key, value, ttl);
+    await this.storeTaggedKey(parsedKey);
+    return value;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async get(key) {
+    return this.driver.get(key);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async remove(key) {
+    const parsedKey = this.driver.parseKey(key);
+    await this.driver.remove(key);
+    for (const tag of this.cacheTags) {
+      const tagKey = this.tagKey(tag);
+      const keys = await this.driver.get(tagKey) || [];
+      const updatedKeys = keys.filter((k) => k !== parsedKey);
+      await this.driver.set(tagKey, updatedKeys, Infinity);
+    }
+  }
+  /**
+   * Invalidate (clear) all keys associated with the current tags
+   */
+  async invalidate() {
+    const keysToRemove = await this.getTaggedKeys();
+    for (const key of keysToRemove) {
+      await this.driver.remove(key);
+    }
+    for (const tag of this.cacheTags) {
+      await this.driver.remove(this.tagKey(tag));
+    }
+  }
+  /**
+   * Flush all keys associated with the current tags
+   * @deprecated Use invalidate() instead for better semantics
+   */
+  async flush() {
+    return this.invalidate();
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async has(key) {
+    return this.driver.has(key);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async remember(key, ttl, callback) {
+    const value = await this.get(key);
+    if (value !== null) {
+      return value;
+    }
+    const result = await callback();
+    await this.set(key, result, ttl);
+    return result;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async pull(key) {
+    const value = await this.get(key);
+    if (value !== null) {
+      await this.remove(key);
+    }
+    return value;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async forever(key, value) {
+    return this.set(key, value, Infinity);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async increment(key, value = 1) {
+    const current = await this.get(key) || 0;
+    if (typeof current !== "number") {
+      throw new Error(
+        `Cannot increment non-numeric value for key: ${this.driver.parseKey(key)}`
+      );
+    }
+    const newValue = current + value;
+    await this.set(key, newValue);
+    return newValue;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async decrement(key, value = 1) {
+    return this.increment(key, -value);
+  }
+};
+function parseCacheKey(key, options = {}) {
+  if (typeof key === "object") {
+    key = JSON.stringify(key);
+  }
+  key = key.replace(/[{}"[\]]/g, "").replaceAll(/[:,]/g, ".");
+  const cachePrefix = typeof options.globalPrefix === "function" ? options.globalPrefix() : options.globalPrefix;
+  return rtrim(String(cachePrefix ? rtrim(cachePrefix, ".") + "." + key : key), ".");
+}
+var CACHE_FOR = /* @__PURE__ */ ((CACHE_FOR2) => {
+  CACHE_FOR2[CACHE_FOR2["HALF_HOUR"] = 1800] = "HALF_HOUR";
+  CACHE_FOR2[CACHE_FOR2["ONE_HOUR"] = 3600] = "ONE_HOUR";
+  CACHE_FOR2[CACHE_FOR2["HALF_DAY"] = 43200] = "HALF_DAY";
+  CACHE_FOR2[CACHE_FOR2["ONE_DAY"] = 86400] = "ONE_DAY";
+  CACHE_FOR2[CACHE_FOR2["ONE_WEEK"] = 604800] = "ONE_WEEK";
+  CACHE_FOR2[CACHE_FOR2["HALF_MONTH"] = 1296e3] = "HALF_MONTH";
+  CACHE_FOR2[CACHE_FOR2["ONE_MONTH"] = 2592e3] = "ONE_MONTH";
+  CACHE_FOR2[CACHE_FOR2["TWO_MONTHS"] = 5184e3] = "TWO_MONTHS";
+  CACHE_FOR2[CACHE_FOR2["SIX_MONTHS"] = 15768e3] = "SIX_MONTHS";
+  CACHE_FOR2[CACHE_FOR2["ONE_YEAR"] = 31536e3] = "ONE_YEAR";
+  return CACHE_FOR2;
+})(CACHE_FOR || {});
+
+// ../../warlock.js/cache/src/drivers/base-cache-driver.ts
+var messages = {
+  clearing: "Clearing namespace",
+  cleared: "Namespace cleared",
+  fetching: "Fetching key",
+  fetched: "Key fetched",
+  caching: "Caching key",
+  cached: "Key cached",
+  flushing: "Flushing cache",
+  flushed: "Cache flushed",
+  removing: "Removing key",
+  removed: "Key removed",
+  expired: "Key expired",
+  notFound: "Key not found",
+  connecting: "Connecting to the cache engine.",
+  connected: "Connected to the cache engine.",
+  disconnecting: "Disconnecting from the cache engine.",
+  disconnected: "Disconnected from the cache engine.",
+  error: "Error occurred"
+};
+var BaseCacheDriver = class {
+  /**
+   * CLient driver
+   */
+  clientDriver;
+  /**
+   * {@inheritdoc}
+   */
+  get client() {
+    return this.clientDriver || this;
+  }
+  /**
+   * Set client driver
+   */
+  set client(client) {
+    this.clientDriver = client;
+  }
+  /**
+   * Options list
+   */
+  options;
+  /**
+   * Event listeners storage
+   */
+  eventListeners = /* @__PURE__ */ new Map();
+  /**
+   * {@inheritdoc}
+   */
+  parseKey(key) {
+    return parseCacheKey(key, this.options);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  setOptions(options) {
+    this.options = options || {};
+    return this;
+  }
+  /**
+   * Register an event listener
+   */
+  on(event, handler) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(handler);
+    return this;
+  }
+  /**
+   * Remove an event listener
+   */
+  off(event, handler) {
+    const handlers = this.eventListeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+    return this;
+  }
+  /**
+   * Register a one-time event listener
+   */
+  once(event, handler) {
+    const onceHandler = async (data) => {
+      await handler(data);
+      this.off(event, onceHandler);
+    };
+    return this.on(event, onceHandler);
+  }
+  /**
+   * Emit an event to all registered listeners
+   */
+  async emit(event, data = {}) {
+    const handlers = this.eventListeners.get(event);
+    if (!handlers || handlers.size === 0) return;
+    const eventData = {
+      driver: this.name,
+      ...data
+    };
+    const promises = [];
+    for (const handler of handlers) {
+      try {
+        const result = handler(eventData);
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      } catch (error) {
+        this.logError(`Error in event handler for '${event}'`, error);
+      }
+    }
+    if (promises.length > 0) {
+      await Promise.allSettled(promises);
+    }
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async has(key) {
+    const value = await this.get(key);
+    return value !== null;
+  }
+  /**
+   * Lock storage for preventing cache stampede
+   */
+  locks = /* @__PURE__ */ new Map();
+  /**
+   * {@inheritdoc}
+   */
+  async remember(key, ttl, callback) {
+    const parsedKey = this.parseKey(key);
+    const cachedValue = await this.get(key);
+    if (cachedValue !== null) {
+      return cachedValue;
+    }
+    const existingLock = this.locks.get(parsedKey);
+    if (existingLock) {
+      return existingLock;
+    }
+    const promise = callback().then(async (result) => {
+      await this.set(key, result, ttl);
+      this.locks.delete(parsedKey);
+      return result;
+    }).catch((err) => {
+      this.locks.delete(parsedKey);
+      throw err;
+    });
+    this.locks.set(parsedKey, promise);
+    return promise;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async pull(key) {
+    const value = await this.get(key);
+    if (value !== null) {
+      await this.remove(key);
+    }
+    return value;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async forever(key, value) {
+    return this.set(key, value, Infinity);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async increment(key, value = 1) {
+    const current = await this.get(key) || 0;
+    if (typeof current !== "number") {
+      throw new Error(`Cannot increment non-numeric value for key: ${this.parseKey(key)}`);
+    }
+    const newValue = current + value;
+    await this.set(key, newValue);
+    return newValue;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async decrement(key, value = 1) {
+    return this.increment(key, -value);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async many(keys) {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async setMany(items, ttl) {
+    await Promise.all(Object.entries(items).map(([key, value]) => this.set(key, value, ttl)));
+  }
+  /**
+   * Log the operation
+   */
+  log(operation, key) {
+    if (key) {
+      key = key.replaceAll("/", ".");
+    }
+    if (operation == "notFound" || operation == "expired") {
+      return log.warn(
+        "cache:" + this.name,
+        operation,
+        (key ? key + " " : "") + messages[operation]
+      );
+    }
+    if (operation.endsWith("ed")) {
+      return log.success(
+        "cache:" + this.name,
+        operation,
+        (key ? key + " " : "") + messages[operation]
+      );
+    }
+    log.info("cache:" + this.name, operation, (key ? key + " " : "") + messages[operation]);
+  }
+  /**
+   * Log error message
+   */
+  logError(message, error) {
+    log.error("cache:" + this.name, "error", message);
+    if (error) {
+      console.log(error);
+    }
+  }
+  /**
+   * Get time to live value
+   */
+  get ttl() {
+    return this.options.ttl !== void 0 ? this.options.ttl : Infinity;
+  }
+  /**
+   * Get time to live value in milliseconds
+   */
+  getExpiresAt(ttl = this.ttl) {
+    if (ttl) {
+      return (/* @__PURE__ */ new Date()).getTime() + ttl * 1e3;
+    }
+  }
+  /**
+   * Prepare data for storage
+   */
+  prepareDataForStorage(data, ttl) {
+    const preparedData = {
+      data
+    };
+    if (ttl) {
+      preparedData.ttl = ttl;
+      preparedData.expiresAt = this.getExpiresAt(ttl);
+    }
+    return preparedData;
+  }
+  /**
+   * Parse fetched data from cache
+   */
+  async parseCachedData(key, data) {
+    this.log("fetched", key);
+    if (data.expiresAt && data.expiresAt < Date.now()) {
+      this.remove(key);
+      return null;
+    }
+    const value = data.data;
+    if (value === null || value === void 0) {
+      return value;
+    }
+    const type = typeof value;
+    if (type === "string" || type === "number" || type === "boolean") {
+      return value;
+    }
+    try {
+      return structuredClone(value);
+    } catch (error) {
+      console.log(value);
+      this.logError(
+        `Failed to clone cached value for ${key}, typeof value: ${typeof value}`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async connect() {
+    this.log("connecting");
+    this.log("connected");
+    await this.emit("connected");
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async disconnect() {
+    this.log("disconnected");
+    await this.emit("disconnected");
+  }
+  /**
+   * Create a tagged cache instance for the given tags
+   */
+  tags(tags) {
+    return new TaggedCache(tags, this);
+  }
+};
+var FileCacheDriver = class extends BaseCacheDriver {
+  /**
+   * {@inheritdoc}
+   */
+  name = "file";
+  /**
+   * {@inheritdoc}
+   */
+  setOptions(options) {
+    if (!options.directory) {
+      throw new CacheConfigurationError(
+        "File driver requires 'directory' option to be configured."
+      );
+    }
+    return super.setOptions(options);
+  }
+  /**
+   * Get the cache directory
+   */
+  get directory() {
+    const directory = this.options.directory;
+    if (typeof directory === "function") {
+      return directory();
+    }
+    throw new CacheConfigurationError(
+      "Cache directory is not defined, please define it in the file driver options"
+    );
+  }
+  /**
+   * Get file name
+   */
+  get fileName() {
+    const fileName = this.options.fileName;
+    if (typeof fileName === "function") {
+      return fileName();
+    }
+    return "cache.json";
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async removeNamespace(namespace) {
+    this.log("clearing", namespace);
+    try {
+      await removeDirectoryAsync(path.resolve(this.directory, namespace));
+      this.log("cleared", namespace);
+    } catch (error) {
+    }
+    return this;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async set(key, value, ttl) {
+    key = this.parseKey(key);
+    this.log("caching", key);
+    const data = this.prepareDataForStorage(value, ttl);
+    const fileDirectory = path.resolve(this.directory, key);
+    await ensureDirectoryAsync(fileDirectory);
+    await putJsonFileAsync(path.resolve(fileDirectory, this.fileName), data);
+    this.log("cached", key);
+    await this.emit("set", { key, value, ttl });
+    return this;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async get(key) {
+    const parsedKey = this.parseKey(key);
+    this.log("fetching", parsedKey);
+    const fileDirectory = path.resolve(this.directory, parsedKey);
+    try {
+      const value = await getJsonFileAsync(
+        path.resolve(fileDirectory, this.fileName)
+      );
+      const result = await this.parseCachedData(parsedKey, value);
+      if (result === null) {
+        await this.emit("miss", { key: parsedKey });
+      } else {
+        await this.emit("hit", { key: parsedKey, value: result });
+      }
+      return result;
+    } catch (error) {
+      this.log("notFound", parsedKey);
+      await this.emit("miss", { key: parsedKey });
+      this.remove(key);
+      return null;
+    }
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async remove(key) {
+    const parsedKey = this.parseKey(key);
+    this.log("removing", parsedKey);
+    const fileDirectory = path.resolve(this.directory, parsedKey);
+    try {
+      await removeDirectoryAsync(fileDirectory);
+      this.log("removed", parsedKey);
+      await this.emit("removed", { key: parsedKey });
+    } catch (error) {
+    }
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async flush() {
+    this.log("flushing");
+    if (this.options.globalPrefix) {
+      await this.removeNamespace("");
+    } else {
+      await removeDirectoryAsync(this.directory);
+    }
+    this.log("flushed");
+    await this.emit("flushed");
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async connect() {
+    this.log("connecting");
+    await ensureDirectoryAsync(this.directory);
+    this.log("connected");
+    await this.emit("connected");
+  }
+};
+
+// ../../warlock.js/cache/src/drivers/lru-memory-cache-driver.ts
+var CacheNode = class {
+  constructor(key, value, ttl) {
+    this.key = key;
+    this.value = value;
+    if (ttl && ttl !== Infinity) {
+      this.expiresAt = Date.now() + ttl * 1e3;
+    }
+  }
+  next = null;
+  prev = null;
+  expiresAt;
+  get isExpired() {
+    return this.expiresAt !== void 0 && this.expiresAt < Date.now();
+  }
+};
+var LRUMemoryCacheDriver = class extends BaseCacheDriver {
+  /**
+   * {@inheritdoc}
+   */
+  name = "lru";
+  /**
+   * Cache map
+   */
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Head of the cache
+   */
+  head = new CacheNode("", null);
+  /**
+   * Tail of the cache
+   */
+  tail = new CacheNode("", null);
+  /**
+   * Cleanup interval reference
+   */
+  cleanupInterval;
+  /**
+   * {@inheritdoc}
+   */
+  constructor() {
+    super();
+    this.init();
+    this.startCleanup();
+  }
+  /**
+   * Initialize the cache
+   */
+  init() {
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+  /**
+   * Start the cleanup process for expired items
+   */
+  startCleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.cleanupInterval = setInterval(async () => {
+      const now = Date.now();
+      const expiredKeys = [];
+      for (const [key, node] of this.cache) {
+        if (node.expiresAt && node.expiresAt <= now) {
+          expiredKeys.push(key);
+        }
+      }
+      for (const key of expiredKeys) {
+        const node = this.cache.get(key);
+        if (node) {
+          this.removeNode(node);
+          this.cache.delete(key);
+          this.log("expired", key);
+          await this.emit("expired", { key });
+        }
+      }
+    }, 1e3);
+    this.cleanupInterval.unref();
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async removeNamespace(_namespace) {
+    throw new Error("Namespace is not supported in LRU cache driver.");
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async set(key, value, ttl) {
+    key = this.parseKey(key);
+    this.log("caching", key);
+    if (ttl === void 0) {
+      ttl = this.ttl;
+    }
+    const existingNode = this.cache.get(key);
+    if (existingNode) {
+      existingNode.value = value;
+      if (ttl && ttl !== Infinity) {
+        existingNode.expiresAt = Date.now() + ttl * 1e3;
+      } else {
+        existingNode.expiresAt = void 0;
+      }
+      this.moveHead(existingNode);
+    } else {
+      const newNode = new CacheNode(key, value, ttl);
+      this.cache.set(key, newNode);
+      this.addNode(newNode);
+      if (this.cache.size > this.capacity) {
+        this.removeTail();
+      }
+    }
+    this.log("cached", key);
+    await this.emit("set", { key, value, ttl });
+    return this;
+  }
+  /**
+   * Move the node to the head
+   */
+  moveHead(node) {
+    this.removeNode(node);
+    this.addNode(node);
+  }
+  /**
+   * Remove the node from the cache
+   */
+  removeNode(node) {
+    node.prev.next = node.next;
+    node.next.prev = node.prev;
+  }
+  /**
+   * Add the node to the head
+   */
+  addNode(node) {
+    node.next = this.head.next;
+    node.prev = this.head;
+    this.head.next.prev = node;
+    this.head.next = node;
+  }
+  /**
+   * Remove the tail node
+   */
+  removeTail() {
+    const node = this.tail.prev;
+    this.removeNode(node);
+    this.cache.delete(node.key);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async get(key) {
+    const parsedKey = this.parseKey(key);
+    this.log("fetching", parsedKey);
+    const node = this.cache.get(parsedKey);
+    if (!node) {
+      this.log("notFound", parsedKey);
+      await this.emit("miss", { key: parsedKey });
+      return null;
+    }
+    if (node.isExpired) {
+      this.removeNode(node);
+      this.cache.delete(parsedKey);
+      this.log("expired", parsedKey);
+      await this.emit("expired", { key: parsedKey });
+      await this.emit("miss", { key: parsedKey });
+      return null;
+    }
+    this.moveHead(node);
+    this.log("fetched", parsedKey);
+    const value = node.value;
+    if (value === null || value === void 0) {
+      return value;
+    }
+    const type = typeof value;
+    if (type === "string" || type === "number" || type === "boolean") {
+      await this.emit("hit", { key: parsedKey, value });
+      return value;
+    }
+    try {
+      const clonedValue = structuredClone(value);
+      await this.emit("hit", { key: parsedKey, value: clonedValue });
+      return clonedValue;
+    } catch (error) {
+      this.logError(`Failed to clone cached value for ${parsedKey}`, error);
+      throw error;
+    }
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async remove(key) {
+    const parsedKey = this.parseKey(key);
+    this.log("removing", parsedKey);
+    const node = this.cache.get(parsedKey);
+    if (node) {
+      this.removeNode(node);
+      this.cache.delete(parsedKey);
+    }
+    this.log("removed", parsedKey);
+    await this.emit("removed", { key: parsedKey });
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async flush() {
+    this.log("flushing");
+    this.cache.clear();
+    this.init();
+    this.log("flushed");
+    await this.emit("flushed");
+  }
+  /**
+   * Get lru capacity
+   */
+  get capacity() {
+    return this.options.capacity || 1e3;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async disconnect() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = void 0;
+    }
+    await super.disconnect();
+  }
+};
+var MemoryCacheDriver = class extends BaseCacheDriver {
+  /**
+   * {@inheritdoc}
+   */
+  name = "memory";
+  /**
+   * Cached data
+   */
+  data = {};
+  /**
+   * List of data that will be cleared from cache
+   */
+  temporaryData = {};
+  /**
+   * Cleanup interval reference
+   */
+  cleanupInterval;
+  /**
+   * Access order tracking for LRU eviction (when maxSize is set)
+   */
+  accessOrder = [];
+  /**
+   * {@inheritdoc}
+   */
+  constructor() {
+    super();
+    this.startCleanup();
+  }
+  /**
+   * Start the cleanup process whenever a data that has a cache key is set
+   */
+  startCleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.cleanupInterval = setInterval(async () => {
+      const now = Date.now();
+      for (const key in this.temporaryData) {
+        if (this.temporaryData[key].expiresAt <= now) {
+          await this.remove(this.temporaryData[key].key);
+          delete this.temporaryData[key];
+          this.log("expired", key);
+          await this.emit("expired", { key });
+        }
+      }
+    }, 1e3);
+    this.cleanupInterval.unref();
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async removeNamespace(namespace) {
+    this.log("clearing", namespace);
+    namespace = this.parseKey(namespace);
+    unset(this.data, [namespace]);
+    this.log("cleared", namespace);
+    return this;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async set(key, value, ttl) {
+    const parsedKey = this.parseKey(key);
+    this.log("caching", parsedKey);
+    if (ttl === void 0) {
+      ttl = this.ttl;
+    }
+    const data = this.prepareDataForStorage(value, ttl);
+    if (ttl) {
+      this.setTemporaryData(key, parsedKey, ttl);
+    }
+    const existingData = get(this.data, parsedKey);
+    const isNewKey = !existingData;
+    set(this.data, parsedKey, data);
+    this.trackAccess(parsedKey);
+    if (isNewKey && this.options.maxSize) {
+      await this.enforceMaxSize();
+    }
+    this.log("cached", parsedKey);
+    await this.emit("set", { key: parsedKey, value, ttl });
+    return this;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async get(key) {
+    const parsedKey = this.parseKey(key);
+    this.log("fetching", parsedKey);
+    const value = get(this.data, parsedKey);
+    if (!value) {
+      this.log("notFound", parsedKey);
+      await this.emit("miss", { key: parsedKey });
+      return null;
+    }
+    const result = await this.parseCachedData(parsedKey, value);
+    if (result === null) {
+      await this.emit("miss", { key: parsedKey });
+    } else {
+      this.trackAccess(parsedKey);
+      await this.emit("hit", { key: parsedKey, value: result });
+    }
+    return result;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async remove(key) {
+    const parsedKey = this.parseKey(key);
+    this.log("removing", parsedKey);
+    unset(this.data, [parsedKey]);
+    delete this.temporaryData[parsedKey];
+    this.removeFromAccessOrder(parsedKey);
+    this.log("removed", parsedKey);
+    await this.emit("removed", { key: parsedKey });
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async flush() {
+    this.log("flushing");
+    if (this.options.globalPrefix) {
+      this.removeNamespace("");
+    } else {
+      this.data = {};
+      this.accessOrder = [];
+    }
+    this.log("flushed");
+    await this.emit("flushed");
+  }
+  /**
+   * Set the temporary data
+   */
+  setTemporaryData(key, parsedKey, ttl) {
+    this.temporaryData[parsedKey] = {
+      key: JSON.stringify(key),
+      expiresAt: Date.now() + ttl * 1e3
+    };
+  }
+  /**
+   * Track access for LRU eviction
+   */
+  trackAccess(key) {
+    if (!this.options.maxSize) return;
+    const index = this.accessOrder.indexOf(key);
+    if (index > -1) {
+      this.accessOrder.splice(index, 1);
+    }
+    this.accessOrder.push(key);
+  }
+  /**
+   * Remove key from access order tracking
+   */
+  removeFromAccessOrder(key) {
+    const index = this.accessOrder.indexOf(key);
+    if (index > -1) {
+      this.accessOrder.splice(index, 1);
+    }
+  }
+  /**
+   * Enforce max size by evicting least recently used items
+   */
+  async enforceMaxSize() {
+    if (!this.options.maxSize) return;
+    const cacheSize = this.getCacheSize();
+    while (cacheSize > this.options.maxSize && this.accessOrder.length > 0) {
+      const lruKey = this.accessOrder.shift();
+      if (lruKey) {
+        this.log("removing", lruKey);
+        unset(this.data, [lruKey]);
+        delete this.temporaryData[lruKey];
+        this.log("removed", lruKey);
+      }
+    }
+  }
+  /**
+   * Get current cache size (number of cached items)
+   */
+  getCacheSize() {
+    return Object.keys(this.data).length;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async disconnect() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = void 0;
+    }
+    await super.disconnect();
+  }
+};
+var MemoryExtendedCacheDriver = class extends MemoryCacheDriver {
+  /**
+   * {@inheritdoc}
+   */
+  name = "memoryExtended";
+  /**
+   * {@inheritdoc}
+   */
+  async get(key) {
+    const parsedKey = this.parseKey(key);
+    this.log("fetching", parsedKey);
+    const value = get(this.data, parsedKey);
+    if (!value) {
+      this.log("notFound", parsedKey);
+      return null;
+    }
+    const ttl = value.ttl || this.options.ttl;
+    if (ttl) {
+      this.setTemporaryData(key, parsedKey, ttl);
+      value.expiresAt = this.getExpiresAt(ttl);
+    }
+    return this.parseCachedData(parsedKey, value);
+  }
+};
+var NullCacheDriver = class extends BaseCacheDriver {
+  /**
+   * Options list
+   */
+  options = {};
+  /**
+   * {@inheritdoc}
+   */
+  name = "null";
+  /**
+   * Cached data
+   */
+  data = {};
+  /**
+   * {@inheritdoc}
+   */
+  get client() {
+    return this;
+  }
+  /**
+   * Constructor
+   */
+  constructor(options = {}) {
+    super();
+    this.setOptions(options);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  setOptions(options) {
+    this.options = options;
+    return this;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  parseKey(_key) {
+    return "";
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async removeNamespace(namespace) {
+    log.info("cache", "clearing namespace", namespace);
+    log.success("cache", "namespace cleared", namespace);
+    return this;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async set(key, _value) {
+    log.info("cache", "setting key", key);
+    log.success("cache", "key set", key);
+    return this;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async get(key) {
+    log.info("cache", "fetching", key);
+    log.success("cache", "fetched", key);
+    return null;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async remove(key) {
+    log.info("cache", "removing", key);
+    log.success("cache", "removed", key);
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async flush() {
+    log.info("cache", "flushing", "all");
+    log.success("cache", "flushed", "all");
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async connect() {
+    log.success("cache", "connected", "Connected to null cache driver");
+  }
+};
+var RedisCacheDriver = class extends BaseCacheDriver {
+  /**
+   * Cache driver name
+   */
+  name = "redis";
+  /**
+   * {@inheritdoc}
+   */
+  setOptions(options) {
+    if (!options.url && !options.host) {
+      throw new CacheConfigurationError(
+        "Redis driver requires either 'url' or 'host' option to be configured."
+      );
+    }
+    return super.setOptions(options);
+  }
+  /**
+   * {@inheritDoc}
+   */
+  async removeNamespace(namespace) {
+    namespace = this.parseKey(namespace);
+    this.log("clearing", namespace);
+    const keys = await this.client?.keys(`${namespace}*`);
+    if (!keys || keys.length === 0) {
+      this.log("notFound", namespace);
+      return;
+    }
+    await this.client?.del(keys);
+    this.log("cleared", namespace);
+    return keys;
+  }
+  /**
+   * {@inheritDoc}
+   */
+  async set(key, value, ttl) {
+    key = this.parseKey(key);
+    this.log("caching", key);
+    if (ttl === void 0) {
+      ttl = this.ttl;
+    }
+    if (ttl && ttl !== Infinity) {
+      await this.client?.set(key, JSON.stringify(value), { EX: ttl });
+    } else {
+      await this.client?.set(key, JSON.stringify(value));
+    }
+    this.log("cached", key);
+    await this.emit("set", { key, value, ttl });
+    return value;
+  }
+  /**
+   * {@inheritDoc}
+   */
+  async get(key) {
+    key = this.parseKey(key);
+    this.log("fetching", key);
+    const value = await this.client?.get(key);
+    if (!value) {
+      this.log("notFound", key);
+      await this.emit("miss", { key });
+      return null;
+    }
+    this.log("fetched", key);
+    const parsedValue = JSON.parse(value);
+    if (parsedValue === null || parsedValue === void 0) {
+      await this.emit("hit", { key, value: parsedValue });
+      return parsedValue;
+    }
+    const type = typeof parsedValue;
+    if (type === "string" || type === "number" || type === "boolean") {
+      await this.emit("hit", { key, value: parsedValue });
+      return parsedValue;
+    }
+    try {
+      const clonedValue = structuredClone(parsedValue);
+      await this.emit("hit", { key, value: clonedValue });
+      return clonedValue;
+    } catch (error) {
+      this.logError(`Failed to clone cached value for ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * {@inheritDoc}
+   */
+  async remove(key) {
+    key = this.parseKey(key);
+    this.log("removing", key);
+    await this.client?.del(key);
+    this.log("removed", key);
+    await this.emit("removed", { key });
+  }
+  /**
+   * {@inheritDoc}
+   */
+  async flush() {
+    this.log("flushing");
+    if (this.options.globalPrefix) {
+      await this.removeNamespace("");
+    } else {
+      await this.client?.flushAll();
+    }
+    this.log("flushed");
+    await this.emit("flushed");
+  }
+  /**
+   * {@inheritDoc}
+   */
+  async connect() {
+    if (this.clientDriver) return;
+    const options = this.options;
+    if (options && !options.url && options.host) {
+      const auth = options.password || options.username ? `${options.username}:${options.password}@` : "";
+      if (!options.url) {
+        const host = options.host || "localhost";
+        const port = options.port || 6379;
+        options.url = `redis://${auth}${host}:${port}`;
+      }
+    }
+    const clientOptions = {
+      ...options,
+      ...this.options.clientOptions || {}
+    };
+    this.log("connecting");
+    const { createClient } = await import('redis');
+    this.client = createClient(clientOptions);
+    this.client.on("error", (error) => {
+      this.log("error", error.message);
+    });
+    try {
+      await this.client.connect();
+      this.log("connected");
+      await this.emit("connected");
+    } catch (error) {
+      log.error("cache", "redis", error);
+      await this.emit("error", { error });
+    }
+  }
+  /**
+   * {@inheritDoc}
+   */
+  async disconnect() {
+    if (!this.client) return;
+    this.log("disconnecting");
+    await this.client.quit();
+    this.log("disconnected");
+    await this.emit("disconnected");
+  }
+  /**
+   * Atomic increment using Redis native INCRBY command
+   * {@inheritdoc}
+   */
+  async increment(key, value = 1) {
+    const parsedKey = this.parseKey(key);
+    this.log("caching", parsedKey);
+    const result = await this.client?.incrBy(parsedKey, value);
+    this.log("cached", parsedKey);
+    await this.emit("set", { key: parsedKey, value: result, ttl: void 0 });
+    return result || 0;
+  }
+  /**
+   * Atomic decrement using Redis native DECRBY command
+   * {@inheritdoc}
+   */
+  async decrement(key, value = 1) {
+    const parsedKey = this.parseKey(key);
+    this.log("caching", parsedKey);
+    const result = await this.client?.decrBy(parsedKey, value);
+    this.log("cached", parsedKey);
+    await this.emit("set", { key: parsedKey, value: result, ttl: void 0 });
+    return result || 0;
+  }
+  /**
+   * Set if not exists (atomic operation)
+   * Returns true if key was set, false if key already existed
+   */
+  async setNX(key, value, ttl) {
+    const parsedKey = this.parseKey(key);
+    this.log("caching", parsedKey);
+    if (ttl === void 0) {
+      ttl = this.ttl;
+    }
+    let result;
+    if (ttl && ttl !== Infinity) {
+      result = await this.client?.set(parsedKey, JSON.stringify(value), {
+        NX: true,
+        EX: ttl
+      });
+    } else {
+      result = await this.client?.set(parsedKey, JSON.stringify(value), {
+        NX: true
+      });
+    }
+    const wasSet = result === "OK";
+    if (wasSet) {
+      this.log("cached", parsedKey);
+      await this.emit("set", { key: parsedKey, value, ttl });
+    } else {
+      this.log("notFound", parsedKey);
+    }
+    return wasSet;
+  }
+};
+
+export { BaseCacheDriver, CACHE_FOR, CacheConfigurationError, CacheConnectionError, CacheDriverNotInitializedError, CacheError, CacheManager, FileCacheDriver, LRUMemoryCacheDriver, MemoryCacheDriver, MemoryExtendedCacheDriver, NullCacheDriver, RedisCacheDriver, TaggedCache, cache, parseCacheKey };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map