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

package/dist/cache/index.d.ts

@@ -0,0 +1,233 @@
+import { b as CacheStore, M as MemoryStoreOptions, R as RedisStoreOptions, F as FileStoreOptions, T as TaggedCacheStore } from '../CacheManager-BkvHEOZX.js';
+export { a as CacheConfig, C as CacheManager, c as CacheStoreFactory, e as CachedItem, S as StoreConfig, f as TaggableCacheStore, d as createCacheManager } from '../CacheManager-BkvHEOZX.js';
+
+/**
+ * In-memory cache store.
+ *
+ * @example
+ * ```ts
+ * const store = new MemoryStore()
+ *
+ * await store.set('user:1', { name: 'John' }, 3600)
+ * const user = await store.get<User>('user:1')
+ * ```
+ */
+declare class MemoryStore implements CacheStore {
+    private readonly cache;
+    private readonly maxSize;
+    private checkInterval;
+    constructor(options?: MemoryStoreOptions);
+    /**
+     * Remove expired items from the cache.
+     */
+    private removeExpired;
+    /**
+     * Check if an item is expired.
+     */
+    private isExpired;
+    /**
+     * Evict items if cache is full.
+     */
+    private evictIfNeeded;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    increment(key: string, value?: number): Promise<number>;
+    decrement(key: string, value?: number): Promise<number>;
+    remember<T>(key: string, ttl: number, callback: () => Promise<T>): Promise<T>;
+    rememberForever<T>(key: string, callback: () => Promise<T>): Promise<T>;
+    getMany<T>(keys: string[]): Promise<Map<string, T | null>>;
+    setMany<T>(items: Map<string, T>, ttl?: number): Promise<void>;
+    deleteMany(keys: string[]): Promise<number>;
+    ttl(key: string): Promise<number>;
+    /**
+     * Get the number of items in the cache.
+     */
+    size(): number;
+    /**
+     * Stop the expiration check interval.
+     */
+    destroy(): void;
+}
+
+/**
+ * Redis-backed cache store.
+ *
+ * @example
+ * ```ts
+ * import Redis from 'ioredis'
+ *
+ * const redis = new Redis(process.env.REDIS_URL)
+ * const store = new RedisStore({ client: redis })
+ *
+ * await store.set('user:1', { name: 'John' }, 3600)
+ * const user = await store.get<User>('user:1')
+ * ```
+ */
+declare class RedisStore implements CacheStore {
+    private readonly client;
+    private readonly prefix;
+    constructor(options: RedisStoreOptions);
+    /**
+     * Get the prefixed key.
+     */
+    private prefixKey;
+    /**
+     * Serialize a value for storage.
+     */
+    private serialize;
+    /**
+     * Deserialize a stored value.
+     */
+    private deserialize;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    increment(key: string, value?: number): Promise<number>;
+    decrement(key: string, value?: number): Promise<number>;
+    remember<T>(key: string, ttl: number, callback: () => Promise<T>): Promise<T>;
+    rememberForever<T>(key: string, callback: () => Promise<T>): Promise<T>;
+    getMany<T>(keys: string[]): Promise<Map<string, T | null>>;
+    setMany<T>(items: Map<string, T>, ttl?: number): Promise<void>;
+    deleteMany(keys: string[]): Promise<number>;
+    ttl(key: string): Promise<number>;
+    /**
+     * Get the Redis client instance.
+     */
+    getClient(): unknown;
+    /**
+     * Get the key prefix.
+     */
+    getPrefix(): string;
+}
+
+/**
+ * File-based cache store.
+ *
+ * @example
+ * ```ts
+ * const store = new FileStore({ path: './storage/cache' })
+ *
+ * await store.set('user:1', { name: 'John' }, 3600)
+ * const user = await store.get<User>('user:1')
+ * ```
+ */
+declare class FileStore implements CacheStore {
+    private readonly basePath;
+    private readonly extension;
+    constructor(options: FileStoreOptions);
+    /**
+     * Generate a hashed filename for a cache key.
+     */
+    private getFilePath;
+    /**
+     * Ensure the cache directory exists.
+     */
+    private ensureDirectory;
+    /**
+     * Read a cache file.
+     */
+    private readCacheFile;
+    /**
+     * Write a cache file.
+     */
+    private writeCacheFile;
+    /**
+     * Delete a cache file.
+     */
+    private deleteCacheFile;
+    /**
+     * Check if a cached item is expired.
+     */
+    private isExpired;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    increment(key: string, value?: number): Promise<number>;
+    decrement(key: string, value?: number): Promise<number>;
+    remember<T>(key: string, ttl: number, callback: () => Promise<T>): Promise<T>;
+    rememberForever<T>(key: string, callback: () => Promise<T>): Promise<T>;
+    getMany<T>(keys: string[]): Promise<Map<string, T | null>>;
+    setMany<T>(items: Map<string, T>, ttl?: number): Promise<void>;
+    deleteMany(keys: string[]): Promise<number>;
+    ttl(key: string): Promise<number>;
+    /**
+     * Clean up expired cache files.
+     * This can be called periodically to free disk space.
+     */
+    cleanup(): Promise<number>;
+    /**
+     * Get the base path.
+     */
+    getBasePath(): string;
+}
+
+/**
+ * Tagged cache implementation.
+ * Allows grouping cache items by tags for bulk invalidation.
+ *
+ * @example
+ * ```ts
+ * const tagged = new TaggedCache(store, ['posts', 'user:1'])
+ *
+ * await tagged.set('user:1:posts', posts, 3600)
+ * await tagged.flush() // Removes all items with these tags
+ * ```
+ */
+declare class TaggedCache implements TaggedCacheStore {
+    private readonly store;
+    private readonly tags;
+    private readonly tagSetPrefix;
+    constructor(store: CacheStore, tags: string[], tagSetPrefix?: string);
+    /**
+     * Get a unique namespace for the current tags.
+     */
+    private getTagNamespace;
+    /**
+     * Generate a unique namespace identifier.
+     */
+    private generateNamespace;
+    /**
+     * Get the tagged key.
+     */
+    private taggedKey;
+    /**
+     * Track a key in the tag sets.
+     */
+    private trackKey;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    increment(key: string, value?: number): Promise<number>;
+    decrement(key: string, value?: number): Promise<number>;
+    remember<T>(key: string, ttl: number, callback: () => Promise<T>): Promise<T>;
+    rememberForever<T>(key: string, callback: () => Promise<T>): Promise<T>;
+    getMany<T>(keys: string[]): Promise<Map<string, T | null>>;
+    setMany<T>(items: Map<string, T>, ttl?: number): Promise<void>;
+    deleteMany(keys: string[]): Promise<number>;
+    ttl(key: string): Promise<number>;
+    /**
+     * Flush all items with the current tags.
+     * This works by resetting the tag namespaces, effectively
+     * making all previously tagged items inaccessible.
+     */
+    flush(): Promise<void>;
+    /**
+     * Get the current tags.
+     */
+    getTags(): string[];
+    /**
+     * Get the underlying store.
+     */
+    getStore(): CacheStore;
+}
+
+export { CacheStore, FileStore, FileStoreOptions, MemoryStore, MemoryStoreOptions, RedisStore, RedisStoreOptions, TaggedCache, TaggedCacheStore };