@warlock.js/cache 4.0.31 → 4.0.41

package/esm/index.js

@@ -1 +1,1681 @@
-export{CacheManager,cache}from'./cache-manager.js';export{BaseCacheDriver}from'./drivers/base-cache-driver.js';export{FileCacheDriver}from'./drivers/file-cache-driver.js';export{LRUMemoryCacheDriver}from'./drivers/lru-memory-cache-driver.js';export{MemoryCacheDriver}from'./drivers/memory-cache-driver.js';export{MemoryExtendedCacheDriver}from'./drivers/memory-extended-cache-driver.js';export{NullCacheDriver}from'./drivers/null-cache-driver.js';export{RedisCacheDriver}from'./drivers/redis-cache-driver.js';export{TaggedCache}from'./tagged-cache.js';export{CacheConfigurationError,CacheConnectionError,CacheDriverNotInitializedError,CacheError}from'./types.js';export{CACHE_FOR,parseCacheKey}from'./utils.js';//# 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