@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/cache/index.js

@@ -0,0 +1,817 @@
+// src/cache/stores/MemoryStore.ts
+var MemoryStore = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  checkInterval = null;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? Infinity;
+    const checkPeriod = options.checkPeriod ?? 6e4;
+    if (checkPeriod > 0) {
+      this.checkInterval = setInterval(() => {
+        this.removeExpired();
+      }, checkPeriod);
+      if (this.checkInterval.unref) {
+        this.checkInterval.unref();
+      }
+    }
+  }
+  /**
+   * Remove expired items from the cache.
+   */
+  removeExpired() {
+    const now = Date.now();
+    for (const [key, item] of this.cache) {
+      if (item.expiresAt !== null && item.expiresAt <= now) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  /**
+   * Check if an item is expired.
+   */
+  isExpired(item) {
+    return item.expiresAt !== null && item.expiresAt <= Date.now();
+  }
+  /**
+   * Evict items if cache is full.
+   */
+  evictIfNeeded() {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+  }
+  async get(key) {
+    const item = this.cache.get(key);
+    if (!item) {
+      return null;
+    }
+    if (this.isExpired(item)) {
+      this.cache.delete(key);
+      return null;
+    }
+    return item.value;
+  }
+  async set(key, value, ttl) {
+    this.evictIfNeeded();
+    const expiresAt = ttl ? Date.now() + ttl * 1e3 : null;
+    this.cache.set(key, {
+      value,
+      expiresAt
+    });
+  }
+  async has(key) {
+    const item = this.cache.get(key);
+    if (!item) {
+      return false;
+    }
+    if (this.isExpired(item)) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async delete(key) {
+    return this.cache.delete(key);
+  }
+  async clear() {
+    this.cache.clear();
+  }
+  async increment(key, value = 1) {
+    const current = await this.get(key);
+    const newValue = (current ?? 0) + value;
+    const item = this.cache.get(key);
+    const ttl = item?.expiresAt ? Math.max(0, Math.ceil((item.expiresAt - Date.now()) / 1e3)) : void 0;
+    await this.set(key, newValue, ttl);
+    return newValue;
+  }
+  async decrement(key, value = 1) {
+    return this.increment(key, -value);
+  }
+  async remember(key, ttl, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value, ttl);
+    return value;
+  }
+  async rememberForever(key, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value);
+    return value;
+  }
+  async getMany(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      result.set(key, await this.get(key));
+    }
+    return result;
+  }
+  async setMany(items, ttl) {
+    for (const [key, value] of items) {
+      await this.set(key, value, ttl);
+    }
+  }
+  async deleteMany(keys) {
+    let deleted = 0;
+    for (const key of keys) {
+      if (await this.delete(key)) {
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  async ttl(key) {
+    const item = this.cache.get(key);
+    if (!item) {
+      return -2;
+    }
+    if (this.isExpired(item)) {
+      this.cache.delete(key);
+      return -2;
+    }
+    if (item.expiresAt === null) {
+      return -1;
+    }
+    return Math.max(0, Math.ceil((item.expiresAt - Date.now()) / 1e3));
+  }
+  /**
+   * Get the number of items in the cache.
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * Stop the expiration check interval.
+   */
+  destroy() {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+  }
+};
+
+// src/cache/stores/RedisStore.ts
+var RedisStore = class {
+  client;
+  prefix;
+  constructor(options) {
+    this.client = options.client;
+    this.prefix = options.prefix ?? "cache:";
+  }
+  /**
+   * Get the prefixed key.
+   */
+  prefixKey(key) {
+    return `${this.prefix}${key}`;
+  }
+  /**
+   * Serialize a value for storage.
+   */
+  serialize(value) {
+    return JSON.stringify(value);
+  }
+  /**
+   * Deserialize a stored value.
+   */
+  deserialize(value) {
+    if (value === null) {
+      return null;
+    }
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  async get(key) {
+    const value = await this.client.get(this.prefixKey(key));
+    return this.deserialize(value);
+  }
+  async set(key, value, ttl) {
+    const serialized = this.serialize(value);
+    const prefixedKey = this.prefixKey(key);
+    if (ttl) {
+      await this.client.setex(prefixedKey, ttl, serialized);
+    } else {
+      await this.client.set(prefixedKey, serialized);
+    }
+  }
+  async has(key) {
+    const exists = await this.client.exists(this.prefixKey(key));
+    return exists > 0;
+  }
+  async delete(key) {
+    const deleted = await this.client.del(this.prefixKey(key));
+    return deleted > 0;
+  }
+  async clear() {
+    const keys = await this.client.keys(`${this.prefix}*`);
+    if (keys.length > 0) {
+      await this.client.del(...keys);
+    }
+  }
+  async increment(key, value = 1) {
+    const prefixedKey = this.prefixKey(key);
+    const exists = await this.client.exists(prefixedKey);
+    if (!exists) {
+      await this.client.set(prefixedKey, "0");
+    }
+    return this.client.incrby(prefixedKey, value);
+  }
+  async decrement(key, value = 1) {
+    const prefixedKey = this.prefixKey(key);
+    const exists = await this.client.exists(prefixedKey);
+    if (!exists) {
+      await this.client.set(prefixedKey, "0");
+    }
+    return this.client.decrby(prefixedKey, value);
+  }
+  async remember(key, ttl, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value, ttl);
+    return value;
+  }
+  async rememberForever(key, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value);
+    return value;
+  }
+  async getMany(keys) {
+    const prefixedKeys = keys.map((key) => this.prefixKey(key));
+    const values = await this.client.mget(...prefixedKeys);
+    const result = /* @__PURE__ */ new Map();
+    for (let i = 0; i < keys.length; i++) {
+      result.set(keys[i], this.deserialize(values[i]));
+    }
+    return result;
+  }
+  async setMany(items, ttl) {
+    const pipeline = this.client.pipeline();
+    for (const [key, value] of items) {
+      const serialized = this.serialize(value);
+      const prefixedKey = this.prefixKey(key);
+      if (ttl) {
+        pipeline.setex(prefixedKey, ttl, serialized);
+      } else {
+        pipeline.set(prefixedKey, serialized);
+      }
+    }
+    await pipeline.exec();
+  }
+  async deleteMany(keys) {
+    if (keys.length === 0) {
+      return 0;
+    }
+    const prefixedKeys = keys.map((key) => this.prefixKey(key));
+    return this.client.del(...prefixedKeys);
+  }
+  async ttl(key) {
+    return this.client.ttl(this.prefixKey(key));
+  }
+  /**
+   * Get the Redis client instance.
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Get the key prefix.
+   */
+  getPrefix() {
+    return this.prefix;
+  }
+};
+
+// src/cache/stores/FileStore.ts
+import { readFile, writeFile, unlink, readdir, mkdir, rm } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { createHash } from "crypto";
+var FileStore = class {
+  basePath;
+  extension;
+  constructor(options) {
+    this.basePath = options.path;
+    this.extension = options.extension ?? ".cache";
+  }
+  /**
+   * Generate a hashed filename for a cache key.
+   */
+  getFilePath(key) {
+    const hash = createHash("sha256").update(key).digest("hex");
+    const dir = hash.slice(0, 2);
+    return join(this.basePath, dir, `${hash}${this.extension}`);
+  }
+  /**
+   * Ensure the cache directory exists.
+   */
+  async ensureDirectory(filePath) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+  }
+  /**
+   * Read a cache file.
+   */
+  async readCacheFile(filePath) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Write a cache file.
+   */
+  async writeCacheFile(filePath, item) {
+    await this.ensureDirectory(filePath);
+    await writeFile(filePath, JSON.stringify(item), "utf-8");
+  }
+  /**
+   * Delete a cache file.
+   */
+  async deleteCacheFile(filePath) {
+    try {
+      await unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if a cached item is expired.
+   */
+  isExpired(item) {
+    return item.expiresAt !== null && item.expiresAt <= Date.now();
+  }
+  async get(key) {
+    const filePath = this.getFilePath(key);
+    const item = await this.readCacheFile(filePath);
+    if (!item) {
+      return null;
+    }
+    if (this.isExpired(item)) {
+      await this.deleteCacheFile(filePath);
+      return null;
+    }
+    return item.value;
+  }
+  async set(key, value, ttl) {
+    const filePath = this.getFilePath(key);
+    const expiresAt = ttl ? Date.now() + ttl * 1e3 : null;
+    await this.writeCacheFile(filePath, {
+      value,
+      expiresAt
+    });
+  }
+  async has(key) {
+    const value = await this.get(key);
+    return value !== null;
+  }
+  async delete(key) {
+    const filePath = this.getFilePath(key);
+    return this.deleteCacheFile(filePath);
+  }
+  async clear() {
+    if (!existsSync(this.basePath)) {
+      return;
+    }
+    await rm(this.basePath, { recursive: true, force: true });
+    await mkdir(this.basePath, { recursive: true });
+  }
+  async increment(key, value = 1) {
+    const current = await this.get(key);
+    const newValue = (current ?? 0) + value;
+    const filePath = this.getFilePath(key);
+    const item = await this.readCacheFile(filePath);
+    const ttl = item?.expiresAt ? Math.max(0, Math.ceil((item.expiresAt - Date.now()) / 1e3)) : void 0;
+    await this.set(key, newValue, ttl);
+    return newValue;
+  }
+  async decrement(key, value = 1) {
+    return this.increment(key, -value);
+  }
+  async remember(key, ttl, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value, ttl);
+    return value;
+  }
+  async rememberForever(key, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value);
+    return value;
+  }
+  async getMany(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      result.set(key, await this.get(key));
+    }
+    return result;
+  }
+  async setMany(items, ttl) {
+    const promises = [];
+    for (const [key, value] of items) {
+      promises.push(this.set(key, value, ttl));
+    }
+    await Promise.all(promises);
+  }
+  async deleteMany(keys) {
+    let deleted = 0;
+    for (const key of keys) {
+      if (await this.delete(key)) {
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  async ttl(key) {
+    const filePath = this.getFilePath(key);
+    const item = await this.readCacheFile(filePath);
+    if (!item) {
+      return -2;
+    }
+    if (this.isExpired(item)) {
+      await this.deleteCacheFile(filePath);
+      return -2;
+    }
+    if (item.expiresAt === null) {
+      return -1;
+    }
+    return Math.max(0, Math.ceil((item.expiresAt - Date.now()) / 1e3));
+  }
+  /**
+   * Clean up expired cache files.
+   * This can be called periodically to free disk space.
+   */
+  async cleanup() {
+    let cleaned = 0;
+    if (!existsSync(this.basePath)) {
+      return cleaned;
+    }
+    const subdirs = await readdir(this.basePath);
+    for (const subdir of subdirs) {
+      const subdirPath = join(this.basePath, subdir);
+      let files;
+      try {
+        files = await readdir(subdirPath);
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        if (!file.endsWith(this.extension)) {
+          continue;
+        }
+        const filePath = join(subdirPath, file);
+        const item = await this.readCacheFile(filePath);
+        if (item && this.isExpired(item)) {
+          await this.deleteCacheFile(filePath);
+          cleaned++;
+        }
+      }
+    }
+    return cleaned;
+  }
+  /**
+   * Get the base path.
+   */
+  getBasePath() {
+    return this.basePath;
+  }
+};
+
+// src/cache/TaggedCache.ts
+var TaggedCache = class {
+  store;
+  tags;
+  tagSetPrefix;
+  constructor(store, tags, tagSetPrefix = "tag:") {
+    this.store = store;
+    this.tags = tags;
+    this.tagSetPrefix = tagSetPrefix;
+  }
+  /**
+   * Get a unique namespace for the current tags.
+   */
+  async getTagNamespace() {
+    const namespaces = [];
+    for (const tag of this.tags) {
+      const tagKey = `${this.tagSetPrefix}${tag}`;
+      let namespace = await this.store.get(tagKey);
+      if (!namespace) {
+        namespace = this.generateNamespace();
+        await this.store.set(tagKey, namespace);
+      }
+      namespaces.push(namespace);
+    }
+    return namespaces.join(":");
+  }
+  /**
+   * Generate a unique namespace identifier.
+   */
+  generateNamespace() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+  /**
+   * Get the tagged key.
+   */
+  async taggedKey(key) {
+    const namespace = await this.getTagNamespace();
+    return `tagged:${namespace}:${key}`;
+  }
+  /**
+   * Track a key in the tag sets.
+   */
+  async trackKey(key) {
+    const taggedKey = await this.taggedKey(key);
+    for (const tag of this.tags) {
+      const setKey = `${this.tagSetPrefix}${tag}:keys`;
+      const keys = await this.store.get(setKey) ?? [];
+      if (!keys.includes(taggedKey)) {
+        keys.push(taggedKey);
+        await this.store.set(setKey, keys);
+      }
+    }
+  }
+  async get(key) {
+    const taggedKey = await this.taggedKey(key);
+    return this.store.get(taggedKey);
+  }
+  async set(key, value, ttl) {
+    const taggedKey = await this.taggedKey(key);
+    await this.store.set(taggedKey, value, ttl);
+    await this.trackKey(key);
+  }
+  async has(key) {
+    const taggedKey = await this.taggedKey(key);
+    return this.store.has(taggedKey);
+  }
+  async delete(key) {
+    const taggedKey = await this.taggedKey(key);
+    return this.store.delete(taggedKey);
+  }
+  async clear() {
+    await this.flush();
+  }
+  async increment(key, value = 1) {
+    const taggedKey = await this.taggedKey(key);
+    await this.trackKey(key);
+    return this.store.increment(taggedKey, value);
+  }
+  async decrement(key, value = 1) {
+    const taggedKey = await this.taggedKey(key);
+    await this.trackKey(key);
+    return this.store.decrement(taggedKey, value);
+  }
+  async remember(key, ttl, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value, ttl);
+    return value;
+  }
+  async rememberForever(key, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value);
+    return value;
+  }
+  async getMany(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      result.set(key, await this.get(key));
+    }
+    return result;
+  }
+  async setMany(items, ttl) {
+    for (const [key, value] of items) {
+      await this.set(key, value, ttl);
+    }
+  }
+  async deleteMany(keys) {
+    let deleted = 0;
+    for (const key of keys) {
+      if (await this.delete(key)) {
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  async ttl(key) {
+    const taggedKey = await this.taggedKey(key);
+    return this.store.ttl(taggedKey);
+  }
+  /**
+   * Flush all items with the current tags.
+   * This works by resetting the tag namespaces, effectively
+   * making all previously tagged items inaccessible.
+   */
+  async flush() {
+    for (const tag of this.tags) {
+      const tagKey = `${this.tagSetPrefix}${tag}`;
+      const setKey = `${this.tagSetPrefix}${tag}:keys`;
+      const keys = await this.store.get(setKey) ?? [];
+      for (const key of keys) {
+        await this.store.delete(key);
+      }
+      await this.store.delete(tagKey);
+      await this.store.delete(setKey);
+    }
+  }
+  /**
+   * Get the current tags.
+   */
+  getTags() {
+    return [...this.tags];
+  }
+  /**
+   * Get the underlying store.
+   */
+  getStore() {
+    return this.store;
+  }
+};
+
+// src/cache/CacheManager.ts
+var TaggableCacheStoreWrapper = class {
+  constructor(store) {
+    this.store = store;
+  }
+  get(key) {
+    return this.store.get(key);
+  }
+  set(key, value, ttl) {
+    return this.store.set(key, value, ttl);
+  }
+  has(key) {
+    return this.store.has(key);
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  clear() {
+    return this.store.clear();
+  }
+  increment(key, value) {
+    return this.store.increment(key, value);
+  }
+  decrement(key, value) {
+    return this.store.decrement(key, value);
+  }
+  remember(key, ttl, callback) {
+    return this.store.remember(key, ttl, callback);
+  }
+  rememberForever(key, callback) {
+    return this.store.rememberForever(key, callback);
+  }
+  getMany(keys) {
+    return this.store.getMany(keys);
+  }
+  setMany(items, ttl) {
+    return this.store.setMany(items, ttl);
+  }
+  deleteMany(keys) {
+    return this.store.deleteMany(keys);
+  }
+  ttl(key) {
+    return this.store.ttl(key);
+  }
+  tags(tags) {
+    return new TaggedCache(this.store, tags);
+  }
+};
+var CacheManager = class {
+  defaultStoreName;
+  storeFactories = /* @__PURE__ */ new Map();
+  resolvedStores = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.defaultStoreName = config.default ?? "memory";
+    this.registerBuiltinDrivers();
+    if (config.stores) {
+      for (const [name, storeConfig] of Object.entries(config.stores)) {
+        this.registerStoreFromConfig(name, storeConfig);
+      }
+    }
+    if (!this.storeFactories.has(this.defaultStoreName) && this.defaultStoreName === "memory") {
+      this.storeFactories.set("memory", () => new MemoryStore());
+    }
+  }
+  driverFactories = /* @__PURE__ */ new Map();
+  /**
+   * Register built-in store drivers.
+   */
+  registerBuiltinDrivers() {
+    this.driverFactories.set("memory", (options) => {
+      return new MemoryStore(options);
+    });
+    this.driverFactories.set("redis", (options) => {
+      return new RedisStore(options);
+    });
+    this.driverFactories.set("file", (options) => {
+      return new FileStore(options);
+    });
+  }
+  /**
+   * Register a store from configuration.
+   */
+  registerStoreFromConfig(name, config) {
+    const { driver, ...options } = config;
+    const factory = this.driverFactories.get(driver);
+    if (!factory) {
+      throw new Error(`Unknown cache driver: ${driver}`);
+    }
+    this.storeFactories.set(name, () => factory(options));
+  }
+  /**
+   * Get a cache store by name.
+   * Returns the default store if no name is specified.
+   */
+  store(name) {
+    const storeName = name ?? this.defaultStoreName;
+    const cached = this.resolvedStores.get(storeName);
+    if (cached) {
+      return cached;
+    }
+    const factory = this.storeFactories.get(storeName);
+    if (!factory) {
+      throw new Error(`Cache store not found: ${storeName}`);
+    }
+    const store = new TaggableCacheStoreWrapper(factory());
+    this.resolvedStores.set(storeName, store);
+    return store;
+  }
+  /**
+   * Register a custom store factory.
+   */
+  registerStore(name, factory) {
+    this.storeFactories.set(name, factory);
+    this.resolvedStores.delete(name);
+  }
+  /**
+   * Register a custom driver.
+   */
+  registerDriver(name, factory) {
+    this.driverFactories.set(name, factory);
+  }
+  /**
+   * Check if a store is registered.
+   */
+  hasStore(name) {
+    return this.storeFactories.has(name);
+  }
+  /**
+   * Get the default store name.
+   */
+  getDefaultStoreName() {
+    return this.defaultStoreName;
+  }
+  /**
+   * Get all registered store names.
+   */
+  getStoreNames() {
+    return Array.from(this.storeFactories.keys());
+  }
+};
+function createCacheManager(config) {
+  return new CacheManager(config);
+}
+export {
+  CacheManager,
+  FileStore,
+  MemoryStore,
+  RedisStore,
+  TaggedCache,
+  createCacheManager
+};