@warlock.js/cache 4.0.42 → 4.0.46

package/cjs/index.js

@@ -1,1702 +1,42 @@
 'use strict';
 
-var logger = require('@warlock.js/logger');
-var reinforcements = require('@mongez/reinforcements');
-var fs = require('@mongez/fs');
-var path = require('path');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var path__default = /*#__PURE__*/_interopDefault(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 reinforcements.rtrim(String(cachePrefix ? reinforcements.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 logger.log.warn(
-        "cache:" + this.name,
-        operation,
-        (key ? key + " " : "") + messages[operation]
-      );
-    }
-    if (operation.endsWith("ed")) {
-      return logger.log.success(
-        "cache:" + this.name,
-        operation,
-        (key ? key + " " : "") + messages[operation]
-      );
-    }
-    logger.log.info("cache:" + this.name, operation, (key ? key + " " : "") + messages[operation]);
-  }
-  /**
-   * Log error message
-   */
-  logError(message, error) {
-    logger.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 fs.removeDirectoryAsync(path__default.default.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__default.default.resolve(this.directory, key);
-    await fs.ensureDirectoryAsync(fileDirectory);
-    await fs.putJsonFileAsync(path__default.default.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__default.default.resolve(this.directory, parsedKey);
-    try {
-      const value = await fs.getJsonFileAsync(
-        path__default.default.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__default.default.resolve(this.directory, parsedKey);
-    try {
-      await fs.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 fs.removeDirectoryAsync(this.directory);
-    }
-    this.log("flushed");
-    await this.emit("flushed");
-  }
-  /**
-   * {@inheritdoc}
-   */
-  async connect() {
-    this.log("connecting");
-    await fs.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);
-    reinforcements.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 = reinforcements.get(this.data, parsedKey);
-    const isNewKey = !existingData;
-    reinforcements.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 = reinforcements.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);
-    reinforcements.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);
-        reinforcements.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 = reinforcements.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) {
-    logger.log.info("cache", "clearing namespace", namespace);
-    logger.log.success("cache", "namespace cleared", namespace);
-    return this;
-  }
-  /**
-   * {@inheritdoc}
-   */
-  async set(key, _value) {
-    logger.log.info("cache", "setting key", key);
-    logger.log.success("cache", "key set", key);
-    return this;
-  }
-  /**
-   * {@inheritdoc}
-   */
-  async get(key) {
-    logger.log.info("cache", "fetching", key);
-    logger.log.success("cache", "fetched", key);
-    return null;
-  }
-  /**
-   * {@inheritdoc}
-   */
-  async remove(key) {
-    logger.log.info("cache", "removing", key);
-    logger.log.success("cache", "removed", key);
-  }
-  /**
-   * {@inheritdoc}
-   */
-  async flush() {
-    logger.log.info("cache", "flushing", "all");
-    logger.log.success("cache", "flushed", "all");
-  }
-  /**
-   * {@inheritdoc}
-   */
-  async connect() {
-    logger.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) {
-      logger.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;
-  }
-};
-
-exports.BaseCacheDriver = BaseCacheDriver;
-exports.CACHE_FOR = CACHE_FOR;
-exports.CacheConfigurationError = CacheConfigurationError;
-exports.CacheConnectionError = CacheConnectionError;
-exports.CacheDriverNotInitializedError = CacheDriverNotInitializedError;
-exports.CacheError = CacheError;
-exports.CacheManager = CacheManager;
-exports.FileCacheDriver = FileCacheDriver;
-exports.LRUMemoryCacheDriver = LRUMemoryCacheDriver;
-exports.MemoryCacheDriver = MemoryCacheDriver;
-exports.MemoryExtendedCacheDriver = MemoryExtendedCacheDriver;
-exports.NullCacheDriver = NullCacheDriver;
-exports.RedisCacheDriver = RedisCacheDriver;
-exports.TaggedCache = TaggedCache;
-exports.cache = cache;
-exports.parseCacheKey = parseCacheKey;
+var cacheManager = require('./cache-manager');
+var drivers = require('./drivers');
+var taggedCache = require('./tagged-cache');
+var types = require('./types');
+var utils = require('./utils');
+
+
+
+Object.keys(cacheManager).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return cacheManager[k]; }
+	});
+});
+Object.keys(drivers).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return drivers[k]; }
+	});
+});
+Object.keys(taggedCache).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return taggedCache[k]; }
+	});
+});
+Object.keys(types).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return types[k]; }
+	});
+});
+Object.keys(utils).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return utils[k]; }
+	});
+});
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map