@open-mercato/cache 0.3.2

package/dist/strategies/sqlite.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { CacheDependencyUnavailableError } from '../errors';
+/**
+ * SQLite cache strategy with tag support
+ * Persistent across process restarts, stored in a SQLite database file
+ *
+ * Uses two tables:
+ * - cache_entries: stores cache data
+ * - cache_tags: stores tag associations (many-to-many)
+ */
+export function createSqliteStrategy(dbPath, options) {
+    let db = null;
+    const defaultTtl = options === null || options === void 0 ? void 0 : options.defaultTtl;
+    const filePath = dbPath || process.env.CACHE_SQLITE_PATH || '.cache.db';
+    async function getDb() {
+        if (db)
+            return db;
+        try {
+            const imported = await import('better-sqlite3');
+            const Database = typeof imported === 'function' ? imported : imported.default;
+            // Ensure directory exists
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            db = new Database(filePath);
+            // Create tables
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS cache_entries (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL,
+          expires_at INTEGER,
+          created_at INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS cache_tags (
+          key TEXT NOT NULL,
+          tag TEXT NOT NULL,
+          PRIMARY KEY (key, tag),
+          FOREIGN KEY (key) REFERENCES cache_entries(key) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_cache_tags_tag ON cache_tags(tag);
+        CREATE INDEX IF NOT EXISTS idx_cache_entries_expires_at ON cache_entries(expires_at);
+      `);
+            return db;
+        }
+        catch (error) {
+            throw new CacheDependencyUnavailableError('sqlite', 'better-sqlite3', error);
+        }
+    }
+    function isExpired(expiresAt) {
+        if (expiresAt === null)
+            return false;
+        return Date.now() > expiresAt;
+    }
+    function matchPattern(key, pattern) {
+        const regexPattern = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(key);
+    }
+    const get = async (key, options) => {
+        const database = await getDb();
+        const stmt = database.prepare('SELECT value, expires_at FROM cache_entries WHERE key = ?');
+        const row = stmt.get(key);
+        if (!row)
+            return null;
+        try {
+            const value = JSON.parse(row.value);
+            const expiresAt = row.expires_at;
+            if (isExpired(expiresAt)) {
+                if (options === null || options === void 0 ? void 0 : options.returnExpired) {
+                    return value;
+                }
+                // Clean up expired entry
+                await deleteKey(key);
+                return null;
+            }
+            return value;
+        }
+        catch (_a) {
+            // Invalid JSON, remove it
+            await deleteKey(key);
+            return null;
+        }
+    };
+    const set = async (key, value, options) => {
+        var _a;
+        const database = await getDb();
+        const ttl = (_a = options === null || options === void 0 ? void 0 : options.ttl) !== null && _a !== void 0 ? _a : defaultTtl;
+        const tags = (options === null || options === void 0 ? void 0 : options.tags) || [];
+        const expiresAt = ttl ? Date.now() + ttl : null;
+        const createdAt = Date.now();
+        const serialized = JSON.stringify(value);
+        database.transaction(() => {
+            // Delete old tags
+            database.prepare('DELETE FROM cache_tags WHERE key = ?').run(key);
+            // Insert or replace cache entry
+            database.prepare(`
+        INSERT OR REPLACE INTO cache_entries (key, value, expires_at, created_at)
+        VALUES (?, ?, ?, ?)
+      `).run(key, serialized, expiresAt, createdAt);
+            // Insert new tags
+            if (tags.length > 0) {
+                const insertTag = database.prepare('INSERT INTO cache_tags (key, tag) VALUES (?, ?)');
+                for (const tag of tags) {
+                    insertTag.run(key, tag);
+                }
+            }
+        })();
+    };
+    const has = async (key) => {
+        const database = await getDb();
+        const stmt = database.prepare('SELECT expires_at FROM cache_entries WHERE key = ?');
+        const row = stmt.get(key);
+        if (!row)
+            return false;
+        if (isExpired(row.expires_at)) {
+            await deleteKey(key);
+            return false;
+        }
+        return true;
+    };
+    const deleteKey = async (key) => {
+        const database = await getDb();
+        const result = database.transaction(() => {
+            database.prepare('DELETE FROM cache_tags WHERE key = ?').run(key);
+            const info = database.prepare('DELETE FROM cache_entries WHERE key = ?').run(key);
+            return info.changes > 0;
+        })();
+        return result;
+    };
+    const deleteByTags = async (tags) => {
+        const database = await getDb();
+        // Get all unique keys that have any of the specified tags
+        const placeholders = tags.map(() => '?').join(',');
+        const stmt = database.prepare(`
+      SELECT DISTINCT key FROM cache_tags WHERE tag IN (${placeholders})
+    `);
+        const rows = stmt.all(...tags);
+        let deleted = 0;
+        for (const row of rows) {
+            const success = await deleteKey(row.key);
+            if (success)
+                deleted++;
+        }
+        return deleted;
+    };
+    const clear = async () => {
+        const database = await getDb();
+        const result = database.transaction(() => {
+            const countStmt = database.prepare('SELECT COUNT(*) as count FROM cache_entries');
+            const count = countStmt.get().count;
+            database.prepare('DELETE FROM cache_tags').run();
+            database.prepare('DELETE FROM cache_entries').run();
+            return count;
+        })();
+        return result;
+    };
+    const keys = async (pattern) => {
+        const database = await getDb();
+        const stmt = database.prepare('SELECT key FROM cache_entries');
+        const rows = stmt.all();
+        const allKeys = rows.map((row) => row.key);
+        if (!pattern)
+            return allKeys;
+        return allKeys.filter((key) => matchPattern(key, pattern));
+    };
+    const stats = async () => {
+        const database = await getDb();
+        const sizeStmt = database.prepare('SELECT COUNT(*) as count FROM cache_entries');
+        const size = sizeStmt.get().count;
+        const now = Date.now();
+        const expiredStmt = database.prepare('SELECT COUNT(*) as count FROM cache_entries WHERE expires_at IS NOT NULL AND expires_at < ?');
+        const expired = expiredStmt.get(now).count;
+        return { size, expired };
+    };
+    const cleanup = async () => {
+        const database = await getDb();
+        const now = Date.now();
+        const result = database.transaction(() => {
+            // Get keys to delete
+            const stmt = database.prepare('SELECT key FROM cache_entries WHERE expires_at IS NOT NULL AND expires_at < ?');
+            const rows = stmt.all(now);
+            // Delete tags for expired keys
+            for (const row of rows) {
+                database.prepare('DELETE FROM cache_tags WHERE key = ?').run(row.key);
+            }
+            // Delete expired entries
+            const info = database.prepare('DELETE FROM cache_entries WHERE expires_at IS NOT NULL AND expires_at < ?').run(now);
+            return info.changes;
+        })();
+        return result;
+    };
+    const close = async () => {
+        if (db) {
+            db.close();
+            db = null;
+        }
+    };
+    return {
+        get,
+        set,
+        has,
+        delete: deleteKey,
+        deleteByTags,
+        clear,
+        keys,
+        stats,
+        cleanup,
+        close,
+    };
+}

package/dist/tenantContext.d.ts

@@ -0,0 +1,4 @@
+export declare function runWithCacheTenant<T>(tenantId: string | null, fn: () => T): T;
+export declare function runWithCacheTenant<T>(tenantId: string | null, fn: () => Promise<T>): Promise<T>;
+export declare function getCurrentCacheTenant(): string | null;
+//# sourceMappingURL=tenantContext.d.ts.map

package/dist/tenantContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenantContext.d.ts","sourceRoot":"","sources":["../src/tenantContext.ts"],"names":[],"mappings":"AAIA,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;AAC9E,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAKhG,wBAAgB,qBAAqB,IAAI,MAAM,GAAG,IAAI,CAErD"}

package/dist/tenantContext.js

@@ -0,0 +1,9 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const tenantStorage = new AsyncLocalStorage();
+export function runWithCacheTenant(tenantId, fn) {
+    return tenantStorage.run(tenantId !== null && tenantId !== void 0 ? tenantId : null, fn);
+}
+export function getCurrentCacheTenant() {
+    var _a;
+    return (_a = tenantStorage.getStore()) !== null && _a !== void 0 ? _a : null;
+}

package/dist/types.d.ts

@@ -0,0 +1,86 @@
+export type CacheValue = unknown;
+export type CacheEntry = {
+    key: string;
+    value: CacheValue;
+    tags: string[];
+    expiresAt: number | null;
+    createdAt: number;
+};
+export type CacheOptions = {
+    ttl?: number;
+    tags?: string[];
+};
+export type CacheGetOptions = {
+    returnExpired?: boolean;
+};
+export type CacheSetOptions = CacheOptions;
+export type CacheStrategy = {
+    /**
+     * Get a value from cache
+     * @param key - Cache key
+     * @param options - Get options
+     * @returns The cached value or null if not found or expired
+     */
+    get(key: string, options?: CacheGetOptions): Promise<CacheValue | null>;
+    /**
+     * Set a value in cache
+     * @param key - Cache key
+     * @param value - Value to cache
+     * @param options - Cache options (ttl, tags)
+     */
+    set(key: string, value: CacheValue, options?: CacheSetOptions): Promise<void>;
+    /**
+     * Check if a key exists in cache (and is not expired)
+     * @param key - Cache key
+     * @returns true if key exists and is not expired
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Delete a specific key from cache
+     * @param key - Cache key
+     * @returns true if key was deleted, false if not found
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Delete all keys with specified tags
+     * @param tags - Tags to match (any key with ANY of these tags will be deleted)
+     * @returns Number of keys deleted
+     */
+    deleteByTags(tags: string[]): Promise<number>;
+    /**
+     * Clear all cache entries
+     * @returns Number of keys deleted
+     */
+    clear(): Promise<number>;
+    /**
+     * Get all keys matching a pattern
+     * @param pattern - Pattern to match (supports wildcards: * and ?)
+     * @returns Array of matching keys
+     */
+    keys(pattern?: string): Promise<string[]>;
+    /**
+     * Get cache statistics
+     * @returns Statistics object
+     */
+    stats(): Promise<{
+        size: number;
+        expired: number;
+    }>;
+    /**
+     * Clean up expired entries (optional, some strategies may auto-cleanup)
+     * @returns Number of entries removed
+     */
+    cleanup?(): Promise<number>;
+    /**
+     * Close/disconnect the cache strategy
+     */
+    close?(): Promise<void>;
+};
+export type CacheServiceOptions = {
+    strategy?: 'memory' | 'redis' | 'sqlite' | 'jsonfile';
+    redisUrl?: string;
+    sqlitePath?: string;
+    jsonFilePath?: string;
+    defaultTtl?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,OAAO,CAAA;AAEhC,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,UAAU,CAAA;IACjB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,YAAY,CAAA;AAE1C,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAA;IAEvE;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7E;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAElC;;;;OAIG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAErC;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAE7C;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;IAExB;;;;OAIG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IAEzC;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC;QACf,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;KAChB,CAAC,CAAA;IAEF;;;OAGG;IACH,OAAO,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;IAE3B;;OAEG;IACH,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAA;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/jest.config.js

@@ -0,0 +1,19 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  transform: {
+    '^.+\\.ts$': ['ts-jest', {
+      tsconfig: {
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+      },
+    }],
+  },
+  moduleNameMapper: {
+    '^@open-mercato/cache$': '<rootDir>/src/index.ts',
+    '^@open-mercato/cache/(.*)$': '<rootDir>/src/$1',
+  },
+}
+

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@open-mercato/cache",
+  "version": "0.3.2",
+  "description": "Multi-strategy cache service with tag-based invalidation support",
+  "main": "dist/index.js",
+  "private": false,
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [
+    "cache",
+    "caching",
+    "redis",
+    "sqlite",
+    "memory",
+    "tags",
+    "invalidation"
+  ],
+  "peerDependencies": {
+    "ioredis": "^5.0.0",
+    "better-sqlite3": "^9.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/__tests__/memory.strategy.test.ts

@@ -0,0 +1,245 @@
+import { createMemoryStrategy } from '../strategies/memory'
+import type { CacheStrategy } from '../types'
+
+describe('Memory Cache Strategy', () => {
+  let cache: CacheStrategy
+
+  beforeEach(() => {
+    cache = createMemoryStrategy()
+  })
+
+  describe('Basic operations', () => {
+    it('should set and get a value', async () => {
+      await cache.set('key1', 'value1')
+      const value = await cache.get('key1')
+      expect(value).toBe('value1')
+    })
+
+    it('should return null for non-existent key', async () => {
+      const value = await cache.get('nonexistent')
+      expect(value).toBeNull()
+    })
+
+    it('should store complex objects', async () => {
+      const obj = { name: 'John', age: 30, nested: { city: 'NYC' } }
+      await cache.set('user', obj)
+      const value = await cache.get('user')
+      expect(value).toEqual(obj)
+    })
+
+    it('should check if key exists', async () => {
+      await cache.set('key1', 'value1')
+      expect(await cache.has('key1')).toBe(true)
+      expect(await cache.has('nonexistent')).toBe(false)
+    })
+
+    it('should delete a key', async () => {
+      await cache.set('key1', 'value1')
+      const deleted = await cache.delete('key1')
+      expect(deleted).toBe(true)
+      expect(await cache.has('key1')).toBe(false)
+      expect(await cache.get('key1')).toBeNull()
+    })
+
+    it('should return false when deleting non-existent key', async () => {
+      const deleted = await cache.delete('nonexistent')
+      expect(deleted).toBe(false)
+    })
+
+    it('should overwrite existing key', async () => {
+      await cache.set('key1', 'value1')
+      await cache.set('key1', 'value2')
+      const value = await cache.get('key1')
+      expect(value).toBe('value2')
+    })
+  })
+
+  describe('TTL and expiration', () => {
+    it('should expire after TTL', async () => {
+      await cache.set('key1', 'value1', { ttl: 100 }) // 100ms
+      expect(await cache.get('key1')).toBe('value1')
+
+      await new Promise((resolve) => setTimeout(resolve, 150))
+      expect(await cache.get('key1')).toBeNull()
+      expect(await cache.has('key1')).toBe(false)
+    })
+
+    it('should not expire without TTL', async () => {
+      await cache.set('key1', 'value1')
+      await new Promise((resolve) => setTimeout(resolve, 100))
+      expect(await cache.get('key1')).toBe('value1')
+    })
+
+    it('should return expired value if returnExpired is true', async () => {
+      await cache.set('key1', 'value1', { ttl: 50 })
+      await new Promise((resolve) => setTimeout(resolve, 100))
+      const value = await cache.get('key1', { returnExpired: true })
+      expect(value).toBe('value1')
+    })
+
+    it('should use default TTL when provided', async () => {
+      const cacheWithTtl = createMemoryStrategy({ defaultTtl: 100 })
+      await cacheWithTtl.set('key1', 'value1') // Should use default TTL
+      expect(await cacheWithTtl.get('key1')).toBe('value1')
+
+      await new Promise((resolve) => setTimeout(resolve, 150))
+      expect(await cacheWithTtl.get('key1')).toBeNull()
+    })
+
+    it('should override default TTL with explicit TTL', async () => {
+      const cacheWithTtl = createMemoryStrategy({ defaultTtl: 100 })
+      await cacheWithTtl.set('key1', 'value1', { ttl: 200 })
+
+      await new Promise((resolve) => setTimeout(resolve, 150))
+      expect(await cacheWithTtl.get('key1')).toBe('value1') // Still valid
+
+      await new Promise((resolve) => setTimeout(resolve, 100))
+      expect(await cacheWithTtl.get('key1')).toBeNull() // Now expired
+    })
+  })
+
+  describe('Tag-based operations', () => {
+    it('should set value with tags', async () => {
+      await cache.set('user:1', { name: 'John' }, { tags: ['users', 'user:1'] })
+      const value = await cache.get('user:1')
+      expect(value).toEqual({ name: 'John' })
+    })
+
+    it('should delete by single tag', async () => {
+      await cache.set('user:1', { name: 'John' }, { tags: ['users'] })
+      await cache.set('user:2', { name: 'Jane' }, { tags: ['users'] })
+      await cache.set('org:1', { name: 'ACME' }, { tags: ['organizations'] })
+
+      const deleted = await cache.deleteByTags(['users'])
+      expect(deleted).toBe(2)
+      expect(await cache.get('user:1')).toBeNull()
+      expect(await cache.get('user:2')).toBeNull()
+      expect(await cache.get('org:1')).toEqual({ name: 'ACME' })
+    })
+
+    it('should delete by multiple tags', async () => {
+      await cache.set('user:1', { name: 'John' }, { tags: ['users', 'org:1'] })
+      await cache.set('user:2', { name: 'Jane' }, { tags: ['users', 'org:2'] })
+      await cache.set('org:1', { name: 'ACME' }, { tags: ['organizations', 'org:1'] })
+
+      const deleted = await cache.deleteByTags(['org:1'])
+      expect(deleted).toBe(2) // user:1 and org:1
+      expect(await cache.get('user:1')).toBeNull()
+      expect(await cache.get('org:1')).toBeNull()
+      expect(await cache.get('user:2')).toEqual({ name: 'Jane' })
+    })
+
+    it('should handle empty tags array', async () => {
+      await cache.set('user:1', { name: 'John' }, { tags: ['users'] })
+      const deleted = await cache.deleteByTags([])
+      expect(deleted).toBe(0)
+      expect(await cache.get('user:1')).toEqual({ name: 'John' })
+    })
+
+    it('should handle non-existent tags', async () => {
+      await cache.set('user:1', { name: 'John' }, { tags: ['users'] })
+      const deleted = await cache.deleteByTags(['nonexistent'])
+      expect(deleted).toBe(0)
+      expect(await cache.get('user:1')).toEqual({ name: 'John' })
+    })
+
+    it('should update tags when overwriting key', async () => {
+      await cache.set('user:1', { name: 'John' }, { tags: ['users', 'org:1'] })
+      await cache.set('user:1', { name: 'John Doe' }, { tags: ['users', 'org:2'] })
+
+      await cache.deleteByTags(['org:1'])
+      expect(await cache.get('user:1')).toEqual({ name: 'John Doe' }) // Should still exist
+
+      await cache.deleteByTags(['org:2'])
+      expect(await cache.get('user:1')).toBeNull() // Now deleted
+    })
+  })
+
+  describe('Pattern matching', () => {
+    beforeEach(async () => {
+      await cache.set('user:1', 'John')
+      await cache.set('user:2', 'Jane')
+      await cache.set('org:1', 'ACME')
+      await cache.set('product:1', 'Widget')
+    })
+
+    it('should return all keys without pattern', async () => {
+      const keys = await cache.keys()
+      expect(keys).toHaveLength(4)
+      expect(keys).toContain('user:1')
+      expect(keys).toContain('user:2')
+      expect(keys).toContain('org:1')
+      expect(keys).toContain('product:1')
+    })
+
+    it('should match keys with wildcard', async () => {
+      const keys = await cache.keys('user:*')
+      expect(keys).toHaveLength(2)
+      expect(keys).toContain('user:1')
+      expect(keys).toContain('user:2')
+    })
+
+    it('should match keys with question mark', async () => {
+      const keys = await cache.keys('user:?')
+      expect(keys).toHaveLength(2)
+      expect(keys).toContain('user:1')
+      expect(keys).toContain('user:2')
+    })
+
+    it('should match exact key', async () => {
+      const keys = await cache.keys('org:1')
+      expect(keys).toHaveLength(1)
+      expect(keys).toContain('org:1')
+    })
+
+    it('should return empty array for no matches', async () => {
+      const keys = await cache.keys('nonexistent:*')
+      expect(keys).toHaveLength(0)
+    })
+  })
+
+  describe('Clear and cleanup', () => {
+    it('should clear all cache entries', async () => {
+      await cache.set('key1', 'value1')
+      await cache.set('key2', 'value2')
+      await cache.set('key3', 'value3')
+
+      const cleared = await cache.clear()
+      expect(cleared).toBe(3)
+      expect(await cache.keys()).toHaveLength(0)
+    })
+
+    it('should cleanup expired entries', async () => {
+      await cache.set('key1', 'value1', { ttl: 50 })
+      await cache.set('key2', 'value2', { ttl: 50 })
+      await cache.set('key3', 'value3') // No TTL
+
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      const removed = await cache.cleanup!()
+      expect(removed).toBe(2)
+      expect(await cache.get('key1')).toBeNull()
+      expect(await cache.get('key2')).toBeNull()
+      expect(await cache.get('key3')).toBe('value3')
+    })
+  })
+
+  describe('Statistics', () => {
+    it('should return correct statistics', async () => {
+      await cache.set('key1', 'value1')
+      await cache.set('key2', 'value2')
+      await cache.set('key3', 'value3', { ttl: 50 })
+
+      let stats = await cache.stats()
+      expect(stats.size).toBe(3)
+      expect(stats.expired).toBe(0)
+
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      stats = await cache.stats()
+      expect(stats.size).toBe(3)
+      expect(stats.expired).toBe(1)
+    })
+  })
+})
+