@naman_deep_singh/cache 1.1.0 → 1.3.0

package/README.md

@@ -1,5 +1,7 @@
 # @naman_deep_singh/cache
 
+**Version:** 1.3.0 (with Redis Clustering support)
+
 A flexible, extensible caching layer with support for Redis, Memcache, and in-memory caches. Includes session management, health checks, and Express middleware.
 
 ## Features
@@ -208,6 +210,51 @@ await cache.delete('key');
 // ... and all other methods
 ```
 
+### Redis Cluster Support
+
+```typescript
+import { CacheFactory } from '@naman_deep_singh/cache';
+
+// Single cluster configuration with array notation
+const clusterCache = CacheFactory.create({
+  adapter: 'redis',
+  cluster: [
+    { host: 'redis-node-1.example.com', port: 6379 },
+    { host: 'redis-node-2.example.com', port: 6379 },
+    { host: 'redis-node-3.example.com', port: 6379 }
+  ],
+  namespace: 'myapp',
+  ttl: 3600
+});
+
+// Or with detailed cluster config
+const clusterCacheAlt = CacheFactory.create({
+  adapter: 'redis',
+  cluster: {
+    nodes: [
+      { host: 'redis-node-1.example.com', port: 6379 },
+      { host: 'redis-node-2.example.com', port: 6379 }
+    ],
+    options: {
+      enableReadyCheck: true,
+      maxRedirections: 3,
+      retryDelayOnFailover: 100,
+      retryDelayOnClusterDown: 300
+    }
+  }
+});
+
+// Use exactly like single instance - same ICache interface
+await clusterCache.set('key', value);
+const data = await clusterCache.get('key');
+await clusterCache.delete('key');
+
+// Cluster automatically handles key distribution across nodes
+// No changes needed to your application logic
+```
+
+**Note:** Cannot mix single-instance (`host`/`port`) and cluster (`cluster`) config. Choose one or the other.
+
 ### Memcache Adapter
 
 ```typescript
@@ -563,33 +610,38 @@ All adapters implement the same `ICache<T>` interface and work identically. Choo
 | **Best For** | Production (distributed systems) | High-traffic scenarios | Development & testing |
 | **Cost** | Free (open source) | Free (open source) | Free |
 | **Performance** | Fast | Very Fast | Fastest (in-memory) |
-| **Cluster Support** | Yes (v2 planned) | Yes | N/A |
+| **Cluster Support** | Yes (v1.2+) | Yes | N/A |
 | **Authentication** | Username/Password/TLS | Optional | N/A |
 
 ### When to Use Each
 
 ```typescript
 // Development: quick setup, no dependencies
-const devCache = new MemoryCache({ adapter: 'memory' });
+const devCache = CacheFactory.create({ adapter: 'memory' });
 
 // Testing: mock external services
-const testCache = new MemoryCache({ adapter: 'memory' });
+const testCache = CacheFactory.create({ adapter: 'memory' });
 
-// Production: single server, high performance
-const prodCache = new RedisCache({
+// Production single instance: single server, high performance
+const prodCache = CacheFactory.create({
   adapter: 'redis',
   host: process.env.REDIS_HOST,
+  port: process.env.REDIS_PORT ? parseInt(process.env.REDIS_PORT) : 6379,
   password: process.env.REDIS_PASSWORD
 });
 
-// High-traffic distributed system
-const distributedCache = new RedisCache({
+// Production cluster: distributed Redis cluster
+const clusterCache = CacheFactory.create({
   adapter: 'redis',
-  host: process.env.REDIS_CLUSTER_ENDPOINT
+  cluster: [
+    { host: 'redis-node-1', port: 6379 },
+    { host: 'redis-node-2', port: 6379 },
+    { host: 'redis-node-3', port: 6379 }
+  ]
 });
 
-// Legacy system with Memcache
-const legacyCache = new MemcacheCache({
+// High-traffic with Memcache multi-server
+const memcacheCache = CacheFactory.create({
   adapter: 'memcache',
   servers: ['memcache1:11211', 'memcache2:11211']
 });
@@ -635,3 +687,9 @@ ISC
 ## Author
 
 Naman Deep Singh
+
+## TypeScript Notes
+
+- The package provides strong generics for `ICache<T>` and `SessionStore` so you can store typed values safely.
+- Middleware in this package may attach runtime properties (for example session data) to `Request` objects in Express. If you're using TypeScript, import the package into your project so the included type augmentations are picked up automatically — no need to cast `req` to `any` in most cases.
+

package/dist/cjs/adapters/memcache/MemcacheCache.js

@@ -86,19 +86,28 @@ class MemcacheCache extends BaseCache_1.BaseCache {
                         reject(err);
                         return;
                     }
-                    if (data === undefined) {
+                    if (data === undefined || data === null) {
                         this.recordMiss();
                         resolve(null);
+                        return;
                     }
-                    else {
-                        this.recordHit();
-                        try {
+                    this.recordHit();
+                    try {
+                        if (typeof data === 'string') {
                             resolve(this.deserialize(data));
                         }
-                        catch (parseErr) {
-                            reject(parseErr);
+                        else if (Buffer.isBuffer(data)) {
+                            resolve(this.deserialize(data.toString()));
+                        }
+                        else {
+                            // Unknown shape from memcached client - treat as miss
+                            this.recordMiss();
+                            resolve(null);
                         }
                     }
+                    catch (parseErr) {
+                        reject(parseErr);
+                    }
                 });
             });
         }
@@ -201,21 +210,42 @@ class MemcacheCache extends BaseCache_1.BaseCache {
                         return;
                     }
                     const result = {};
+                    if (!data || typeof data !== 'object') {
+                        // Treat as all misses
+                        for (const key of keys) {
+                            this.recordMiss();
+                            result[key] = null;
+                        }
+                        resolve(result);
+                        return;
+                    }
+                    const map = data;
                     keys.forEach((key) => {
                         const fullKey = this.buildKey(key);
-                        if (fullKey in data) {
+                        const value = map[fullKey];
+                        if (value === undefined || value === null) {
+                            this.recordMiss();
+                            result[key] = null;
+                        }
+                        else {
                             this.recordHit();
                             try {
-                                result[key] = this.deserialize(data[fullKey]);
+                                if (typeof value === 'string') {
+                                    result[key] = this.deserialize(value);
+                                }
+                                else if (Buffer.isBuffer(value)) {
+                                    result[key] = this.deserialize(value.toString());
+                                }
+                                else {
+                                    // Unknown, treat as miss
+                                    this.recordMiss();
+                                    result[key] = null;
+                                }
                             }
                             catch (parseErr) {
                                 reject(parseErr);
                             }
                         }
-                        else {
-                            this.recordMiss();
-                            result[key] = null;
-                        }
                     });
                     resolve(result);
                 });

package/dist/cjs/adapters/redis/RedisCache.js

@@ -19,30 +19,50 @@ class RedisCache extends BaseCache_1.BaseCache {
      */
     async connect() {
         try {
-            const options = {
-                host: this.redisConfig.host ?? 'localhost',
-                port: this.redisConfig.port ?? 6379,
-                db: this.redisConfig.db ?? 0
-            };
-            if (this.redisConfig.username) {
-                options.username = this.redisConfig.username;
-            }
-            if (this.redisConfig.password) {
-                options.password = this.redisConfig.password;
+            const cluster = this.redisConfig.cluster;
+            const hasCluster = cluster && (Array.isArray(cluster) ? cluster.length > 0 : cluster.nodes?.length > 0);
+            if (hasCluster && cluster) {
+                // Cluster mode
+                let nodes = [];
+                if (Array.isArray(cluster)) {
+                    nodes = cluster;
+                }
+                else {
+                    nodes = cluster.nodes;
+                }
+                this.client = (0, redis_1.createCluster)({
+                    rootNodes: nodes.map(node => ({ url: `redis://${node.host}:${node.port}` }))
+                });
             }
-            if (this.redisConfig.tls) {
-                options.tls = true;
+            else {
+                // Single instance mode
+                const options = {
+                    host: this.redisConfig.host ?? 'localhost',
+                    port: this.redisConfig.port ?? 6379,
+                    db: this.redisConfig.db ?? 0
+                };
+                if (this.redisConfig.username) {
+                    options.username = this.redisConfig.username;
+                }
+                if (this.redisConfig.password) {
+                    options.password = this.redisConfig.password;
+                }
+                if (this.redisConfig.tls) {
+                    options.tls = true;
+                }
+                this.client = (0, redis_1.createClient)(options);
             }
-            this.client = (0, redis_1.createClient)(options);
-            this.client.on('error', (err) => {
-                this.isConnected = false;
-                console.error('Redis connection error:', err);
-            });
-            this.client.on('connect', () => {
+            if (this.client) {
+                this.client.on('error', (err) => {
+                    this.isConnected = false;
+                    console.error('Redis connection error:', err);
+                });
+                this.client.on('connect', () => {
+                    this.isConnected = true;
+                });
+                await this.client.connect();
                 this.isConnected = true;
-            });
-            await this.client.connect();
-            this.isConnected = true;
+            }
         }
         catch (err) {
             throw new errors_1.CacheError('Failed to connect to Redis', 'REDIS_CONNECTION_ERROR', 'redis', err);
@@ -132,16 +152,19 @@ class RedisCache extends BaseCache_1.BaseCache {
         try {
             await this.ensureConnected();
             if (this.namespace) {
-                // Clear only keys with the current namespace
-                const pattern = `${this.namespace}*`;
-                const keys = await this.client.keys(pattern);
-                if (keys.length > 0) {
-                    await this.client.del(keys);
-                }
+                // For cluster mode, we can't use FLUSHDB, so we skip clearing in cluster
+                // In production, use explicit key tracking or Redis ACL scoping
+                console.warn('Cluster mode: namespace clear requires explicit key tracking');
             }
             else {
-                // Clear all keys
-                await this.client.flushDb();
+                // Clear all keys only in single-instance mode
+                const client = this.client;
+                if (client && typeof client.flushDb === 'function') {
+                    await client.flushDb();
+                }
+                else {
+                    console.warn('Clear operation not supported in cluster mode');
+                }
             }
         }
         catch (err) {
@@ -253,7 +276,14 @@ class RedisCache extends BaseCache_1.BaseCache {
     async isAlive() {
         try {
             await this.ensureConnected();
-            await this.client.ping();
+            // Use sendCommand which works for both single and cluster
+            // `sendCommand` exists on both single and cluster clients in runtime; cast narrowly for the call
+            if (this.client && typeof this.client.sendCommand === 'function') {
+                await this.client.sendCommand(['PING']);
+            }
+            else if (this.client && typeof this.client.ping === 'function') {
+                await this.client.ping();
+            }
             return {
                 isAlive: true,
                 adapter: 'redis',

package/dist/cjs/core/factory.js

@@ -15,7 +15,16 @@ class CacheFactory {
     static create(config) {
         switch (config.adapter) {
             case 'redis':
-                return new redis_1.RedisCache(config);
+                const redisConfig = config;
+                // Validate: can't use both single + cluster
+                if (redisConfig.host && redisConfig.cluster) {
+                    throw new errors_1.CacheError('Cannot specify both host and cluster config', 'INVALID_CONFIG');
+                }
+                // Require either single or cluster
+                if (!redisConfig.host && !redisConfig.cluster) {
+                    throw new errors_1.CacheError('Redis requires either host or cluster config', 'INVALID_CONFIG');
+                }
+                return new redis_1.RedisCache(redisConfig);
             case 'memcache':
                 return new memcache_1.MemcacheCache(config);
             case 'memory':

package/dist/cjs/middleware/express/cacheMiddleware.js

@@ -82,10 +82,23 @@ function cacheResponseMiddleware(cache, options) {
                 if (res.statusCode >= 200 &&
                     res.statusCode < 300 &&
                     !excludeStatusCodes.includes(res.statusCode)) {
-                    const responseData = typeof data === 'string' ? data : JSON.stringify(data);
-                    cache.set(cacheKey, responseData, ttl).catch((err) => {
-                        console.error('Failed to cache response:', err);
-                    });
+                    let responseData = null;
+                    if (typeof data === 'string') {
+                        responseData = data;
+                    }
+                    else {
+                        try {
+                            responseData = JSON.stringify(data);
+                        }
+                        catch (e) {
+                            responseData = null;
+                        }
+                    }
+                    if (responseData !== null) {
+                        cache.set(cacheKey, responseData, ttl).catch((err) => {
+                            console.error('Failed to cache response:', err);
+                        });
+                    }
                 }
                 res.set('X-Cache', 'MISS');
                 return originalSend.call(this, data);

package/dist/cjs/session/SessionStore.d.ts

@@ -48,4 +48,10 @@ export declare class SessionStore {
      * Get session data and extend expiry in one operation
      */
     getAndExtend(sessionId: string, ttl?: number): Promise<SessionData | null>;
+    /**
+     * Optional close hook for graceful shutdowns.
+     * Present to allow callers to call `close()` during shutdown without
+     * requiring every store implementation to provide one.
+     */
+    close(): Promise<void>;
 }

package/dist/cjs/session/SessionStore.js

@@ -149,5 +149,13 @@ class SessionStore {
             throw new errors_1.CacheError(`Failed to get and extend session "${sessionId}"`, 'SESSION_GET_EXTEND_ERROR', 'session', err);
         }
     }
+    /**
+     * Optional close hook for graceful shutdowns.
+     * Present to allow callers to call `close()` during shutdown without
+     * requiring every store implementation to provide one.
+     */
+    async close() {
+        return;
+    }
 }
 exports.SessionStore = SessionStore;

package/dist/cjs/types.d.ts

@@ -7,6 +7,21 @@ export interface CacheConfig {
     ttl?: number;
     fallback?: boolean;
 }
+/**
+ * Redis-cluster configuration
+ */
+export interface RedisClusterConfig {
+    nodes: Array<{
+        host: string;
+        port: number;
+    }>;
+    options?: {
+        enableReadyCheck?: boolean;
+        maxRedirections?: number;
+        retryDelayOnFailover?: number;
+        retryDelayOnClusterDown?: number;
+    };
+}
 /**
  * Redis-specific configuration
  */
@@ -14,6 +29,10 @@ export interface RedisCacheConfig extends CacheConfig {
     adapter: 'redis';
     host?: string;
     port?: number;
+    cluster?: RedisClusterConfig | Array<{
+        host: string;
+        port: number;
+    }>;
     username?: string;
     password?: string;
     db?: number;

package/dist/esm/adapters/memcache/MemcacheCache.js

@@ -80,19 +80,28 @@ export class MemcacheCache extends BaseCache {
                         reject(err);
                         return;
                     }
-                    if (data === undefined) {
+                    if (data === undefined || data === null) {
                         this.recordMiss();
                         resolve(null);
+                        return;
                     }
-                    else {
-                        this.recordHit();
-                        try {
+                    this.recordHit();
+                    try {
+                        if (typeof data === 'string') {
                             resolve(this.deserialize(data));
                         }
-                        catch (parseErr) {
-                            reject(parseErr);
+                        else if (Buffer.isBuffer(data)) {
+                            resolve(this.deserialize(data.toString()));
+                        }
+                        else {
+                            // Unknown shape from memcached client - treat as miss
+                            this.recordMiss();
+                            resolve(null);
                         }
                     }
+                    catch (parseErr) {
+                        reject(parseErr);
+                    }
                 });
             });
         }
@@ -195,21 +204,42 @@ export class MemcacheCache extends BaseCache {
                         return;
                     }
                     const result = {};
+                    if (!data || typeof data !== 'object') {
+                        // Treat as all misses
+                        for (const key of keys) {
+                            this.recordMiss();
+                            result[key] = null;
+                        }
+                        resolve(result);
+                        return;
+                    }
+                    const map = data;
                     keys.forEach((key) => {
                         const fullKey = this.buildKey(key);
-                        if (fullKey in data) {
+                        const value = map[fullKey];
+                        if (value === undefined || value === null) {
+                            this.recordMiss();
+                            result[key] = null;
+                        }
+                        else {
                             this.recordHit();
                             try {
-                                result[key] = this.deserialize(data[fullKey]);
+                                if (typeof value === 'string') {
+                                    result[key] = this.deserialize(value);
+                                }
+                                else if (Buffer.isBuffer(value)) {
+                                    result[key] = this.deserialize(value.toString());
+                                }
+                                else {
+                                    // Unknown, treat as miss
+                                    this.recordMiss();
+                                    result[key] = null;
+                                }
                             }
                             catch (parseErr) {
                                 reject(parseErr);
                             }
                         }
-                        else {
-                            this.recordMiss();
-                            result[key] = null;
-                        }
                     });
                     resolve(result);
                 });

package/dist/esm/adapters/redis/RedisCache.js

@@ -1,4 +1,4 @@
-import { createClient } from 'redis';
+import { createClient, createCluster } from 'redis';
 import { BaseCache } from '../../core/BaseCache';
 import { CacheError } from '../../errors';
 /**
@@ -16,30 +16,50 @@ export class RedisCache extends BaseCache {
      */
     async connect() {
         try {
-            const options = {
-                host: this.redisConfig.host ?? 'localhost',
-                port: this.redisConfig.port ?? 6379,
-                db: this.redisConfig.db ?? 0
-            };
-            if (this.redisConfig.username) {
-                options.username = this.redisConfig.username;
-            }
-            if (this.redisConfig.password) {
-                options.password = this.redisConfig.password;
+            const cluster = this.redisConfig.cluster;
+            const hasCluster = cluster && (Array.isArray(cluster) ? cluster.length > 0 : cluster.nodes?.length > 0);
+            if (hasCluster && cluster) {
+                // Cluster mode
+                let nodes = [];
+                if (Array.isArray(cluster)) {
+                    nodes = cluster;
+                }
+                else {
+                    nodes = cluster.nodes;
+                }
+                this.client = createCluster({
+                    rootNodes: nodes.map(node => ({ url: `redis://${node.host}:${node.port}` }))
+                });
             }
-            if (this.redisConfig.tls) {
-                options.tls = true;
+            else {
+                // Single instance mode
+                const options = {
+                    host: this.redisConfig.host ?? 'localhost',
+                    port: this.redisConfig.port ?? 6379,
+                    db: this.redisConfig.db ?? 0
+                };
+                if (this.redisConfig.username) {
+                    options.username = this.redisConfig.username;
+                }
+                if (this.redisConfig.password) {
+                    options.password = this.redisConfig.password;
+                }
+                if (this.redisConfig.tls) {
+                    options.tls = true;
+                }
+                this.client = createClient(options);
             }
-            this.client = createClient(options);
-            this.client.on('error', (err) => {
-                this.isConnected = false;
-                console.error('Redis connection error:', err);
-            });
-            this.client.on('connect', () => {
+            if (this.client) {
+                this.client.on('error', (err) => {
+                    this.isConnected = false;
+                    console.error('Redis connection error:', err);
+                });
+                this.client.on('connect', () => {
+                    this.isConnected = true;
+                });
+                await this.client.connect();
                 this.isConnected = true;
-            });
-            await this.client.connect();
-            this.isConnected = true;
+            }
         }
         catch (err) {
             throw new CacheError('Failed to connect to Redis', 'REDIS_CONNECTION_ERROR', 'redis', err);
@@ -129,16 +149,19 @@ export class RedisCache extends BaseCache {
         try {
             await this.ensureConnected();
             if (this.namespace) {
-                // Clear only keys with the current namespace
-                const pattern = `${this.namespace}*`;
-                const keys = await this.client.keys(pattern);
-                if (keys.length > 0) {
-                    await this.client.del(keys);
-                }
+                // For cluster mode, we can't use FLUSHDB, so we skip clearing in cluster
+                // In production, use explicit key tracking or Redis ACL scoping
+                console.warn('Cluster mode: namespace clear requires explicit key tracking');
             }
             else {
-                // Clear all keys
-                await this.client.flushDb();
+                // Clear all keys only in single-instance mode
+                const client = this.client;
+                if (client && typeof client.flushDb === 'function') {
+                    await client.flushDb();
+                }
+                else {
+                    console.warn('Clear operation not supported in cluster mode');
+                }
             }
         }
         catch (err) {
@@ -250,7 +273,14 @@ export class RedisCache extends BaseCache {
     async isAlive() {
         try {
             await this.ensureConnected();
-            await this.client.ping();
+            // Use sendCommand which works for both single and cluster
+            // `sendCommand` exists on both single and cluster clients in runtime; cast narrowly for the call
+            if (this.client && typeof this.client.sendCommand === 'function') {
+                await this.client.sendCommand(['PING']);
+            }
+            else if (this.client && typeof this.client.ping === 'function') {
+                await this.client.ping();
+            }
             return {
                 isAlive: true,
                 adapter: 'redis',

package/dist/esm/core/factory.js

@@ -12,7 +12,16 @@ export class CacheFactory {
     static create(config) {
         switch (config.adapter) {
             case 'redis':
-                return new RedisCache(config);
+                const redisConfig = config;
+                // Validate: can't use both single + cluster
+                if (redisConfig.host && redisConfig.cluster) {
+                    throw new CacheError('Cannot specify both host and cluster config', 'INVALID_CONFIG');
+                }
+                // Require either single or cluster
+                if (!redisConfig.host && !redisConfig.cluster) {
+                    throw new CacheError('Redis requires either host or cluster config', 'INVALID_CONFIG');
+                }
+                return new RedisCache(redisConfig);
             case 'memcache':
                 return new MemcacheCache(config);
             case 'memory':

package/dist/esm/middleware/express/cacheMiddleware.js

@@ -77,10 +77,23 @@ export function cacheResponseMiddleware(cache, options) {
                 if (res.statusCode >= 200 &&
                     res.statusCode < 300 &&
                     !excludeStatusCodes.includes(res.statusCode)) {
-                    const responseData = typeof data === 'string' ? data : JSON.stringify(data);
-                    cache.set(cacheKey, responseData, ttl).catch((err) => {
-                        console.error('Failed to cache response:', err);
-                    });
+                    let responseData = null;
+                    if (typeof data === 'string') {
+                        responseData = data;
+                    }
+                    else {
+                        try {
+                            responseData = JSON.stringify(data);
+                        }
+                        catch (e) {
+                            responseData = null;
+                        }
+                    }
+                    if (responseData !== null) {
+                        cache.set(cacheKey, responseData, ttl).catch((err) => {
+                            console.error('Failed to cache response:', err);
+                        });
+                    }
                 }
                 res.set('X-Cache', 'MISS');
                 return originalSend.call(this, data);

package/dist/esm/session/SessionStore.d.ts

@@ -48,4 +48,10 @@ export declare class SessionStore {
      * Get session data and extend expiry in one operation
      */
     getAndExtend(sessionId: string, ttl?: number): Promise<SessionData | null>;
+    /**
+     * Optional close hook for graceful shutdowns.
+     * Present to allow callers to call `close()` during shutdown without
+     * requiring every store implementation to provide one.
+     */
+    close(): Promise<void>;
 }

package/dist/esm/session/SessionStore.js

@@ -146,4 +146,12 @@ export class SessionStore {
             throw new CacheError(`Failed to get and extend session "${sessionId}"`, 'SESSION_GET_EXTEND_ERROR', 'session', err);
         }
     }
+    /**
+     * Optional close hook for graceful shutdowns.
+     * Present to allow callers to call `close()` during shutdown without
+     * requiring every store implementation to provide one.
+     */
+    async close() {
+        return;
+    }
 }

package/dist/esm/types.d.ts

@@ -7,6 +7,21 @@ export interface CacheConfig {
     ttl?: number;
     fallback?: boolean;
 }
+/**
+ * Redis-cluster configuration
+ */
+export interface RedisClusterConfig {
+    nodes: Array<{
+        host: string;
+        port: number;
+    }>;
+    options?: {
+        enableReadyCheck?: boolean;
+        maxRedirections?: number;
+        retryDelayOnFailover?: number;
+        retryDelayOnClusterDown?: number;
+    };
+}
 /**
  * Redis-specific configuration
  */
@@ -14,6 +29,10 @@ export interface RedisCacheConfig extends CacheConfig {
     adapter: 'redis';
     host?: string;
     port?: number;
+    cluster?: RedisClusterConfig | Array<{
+        host: string;
+        port: number;
+    }>;
     username?: string;
     password?: string;
     db?: number;

package/dist/types/session/SessionStore.d.ts

@@ -48,4 +48,10 @@ export declare class SessionStore {
      * Get session data and extend expiry in one operation
      */
     getAndExtend(sessionId: string, ttl?: number): Promise<SessionData | null>;
+    /**
+     * Optional close hook for graceful shutdowns.
+     * Present to allow callers to call `close()` during shutdown without
+     * requiring every store implementation to provide one.
+     */
+    close(): Promise<void>;
 }

package/dist/types/types.d.ts

@@ -7,6 +7,21 @@ export interface CacheConfig {
     ttl?: number;
     fallback?: boolean;
 }
+/**
+ * Redis-cluster configuration
+ */
+export interface RedisClusterConfig {
+    nodes: Array<{
+        host: string;
+        port: number;
+    }>;
+    options?: {
+        enableReadyCheck?: boolean;
+        maxRedirections?: number;
+        retryDelayOnFailover?: number;
+        retryDelayOnClusterDown?: number;
+    };
+}
 /**
  * Redis-specific configuration
  */
@@ -14,6 +29,10 @@ export interface RedisCacheConfig extends CacheConfig {
     adapter: 'redis';
     host?: string;
     port?: number;
+    cluster?: RedisClusterConfig | Array<{
+        host: string;
+        port: number;
+    }>;
     username?: string;
     password?: string;
     db?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naman_deep_singh/cache",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Extensible caching layer supporting Redis, Memcache, and in-memory caches with automatic fallback, namespacing, session management, and Express middleware.",
   "type": "module",
   "main": "./dist/cjs/index.js",