@naman_deep_singh/cache 1.2.0 → 1.3.1

package/README.md

@@ -1,6 +1,6 @@
 # @naman_deep_singh/cache
 
-**Version:** 1.2.0 (with Redis Clustering support)
+**Version:** 1.3.1 (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.
 
@@ -687,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.d.ts

@@ -1,5 +1,5 @@
-import type { MemcacheCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, MemcacheCacheConfig } from '../../types';
 /**
  * Memcache adapter
  */

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

@@ -31,12 +31,14 @@ class MemcacheCache extends BaseCache_1.BaseCache {
                 remove: true,
                 failOverServers: [],
                 maxValue: 1048576, // 1MB default
-                idle: 30000
+                idle: 30000,
             };
             if (this.memcacheConfig.username) {
+                ;
                 options.username = this.memcacheConfig.username;
             }
             if (this.memcacheConfig.password) {
+                ;
                 options.password = this.memcacheConfig.password;
             }
             this.client = new memcached_1.default(servers, options);
@@ -86,19 +88,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);
+                    }
                 });
             });
         }
@@ -193,7 +204,7 @@ class MemcacheCache extends BaseCache_1.BaseCache {
     async getMultiple(keys) {
         try {
             await this.ensureConnected();
-            const fullKeys = keys.map(k => this.buildKey(k));
+            const fullKeys = keys.map((k) => this.buildKey(k));
             return new Promise((resolve, reject) => {
                 this.client.getMulti(fullKeys, (err, data) => {
                     if (err) {
@@ -201,21 +212,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);
                 });
@@ -259,9 +291,9 @@ class MemcacheCache extends BaseCache_1.BaseCache {
     async deleteMultiple(keys) {
         try {
             await this.ensureConnected();
-            const fullKeys = keys.map(k => this.buildKey(k));
+            const fullKeys = keys.map((k) => this.buildKey(k));
             let deletedCount = 0;
-            await Promise.all(fullKeys.map(key => new Promise((resolve, reject) => {
+            await Promise.all(fullKeys.map((key) => new Promise((resolve, reject) => {
                 this.client.del(key, (err) => {
                     if (err) {
                         reject(err);
@@ -316,7 +348,7 @@ class MemcacheCache extends BaseCache_1.BaseCache {
             return {
                 isAlive: true,
                 adapter: 'memcache',
-                timestamp: new Date()
+                timestamp: new Date(),
             };
         }
         catch (err) {
@@ -324,7 +356,7 @@ class MemcacheCache extends BaseCache_1.BaseCache {
                 isAlive: false,
                 adapter: 'memcache',
                 timestamp: new Date(),
-                error: err.message
+                error: err.message,
             };
         }
     }

package/dist/cjs/adapters/memory/MemoryCache.d.ts

@@ -1,5 +1,5 @@
-import type { MemoryCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, MemoryCacheConfig } from '../../types';
 /**
  * In-memory cache adapter for development and testing
  */

package/dist/cjs/adapters/memory/MemoryCache.js

@@ -212,7 +212,9 @@ class MemoryCache extends BaseCache_1.BaseCache {
             const fullKey = this.buildKey(key);
             const entry = this.store.get(fullKey);
             const current = entry && (!entry.expiresAt || entry.expiresAt >= Date.now())
-                ? (typeof entry.value === 'number' ? entry.value : 0)
+                ? typeof entry.value === 'number'
+                    ? entry.value
+                    : 0
                 : 0;
             const value = current + amount;
             const expiry = this.ttl;
@@ -232,7 +234,9 @@ class MemoryCache extends BaseCache_1.BaseCache {
             const fullKey = this.buildKey(key);
             const entry = this.store.get(fullKey);
             const current = entry && (!entry.expiresAt || entry.expiresAt >= Date.now())
-                ? (typeof entry.value === 'number' ? entry.value : 0)
+                ? typeof entry.value === 'number'
+                    ? entry.value
+                    : 0
                 : 0;
             const value = current - amount;
             const expiry = this.ttl;
@@ -251,7 +255,7 @@ class MemoryCache extends BaseCache_1.BaseCache {
         return {
             isAlive: true,
             adapter: 'memory',
-            timestamp: new Date()
+            timestamp: new Date(),
         };
     }
     /**

package/dist/cjs/adapters/redis/RedisCache.d.ts

@@ -1,5 +1,5 @@
-import type { RedisCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, RedisCacheConfig } from '../../types';
 /**
  * Redis cache adapter
  */

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

@@ -20,7 +20,10 @@ class RedisCache extends BaseCache_1.BaseCache {
     async connect() {
         try {
             const cluster = this.redisConfig.cluster;
-            const hasCluster = cluster && (Array.isArray(cluster) ? cluster.length > 0 : cluster.nodes?.length > 0);
+            const hasCluster = cluster &&
+                (Array.isArray(cluster)
+                    ? cluster.length > 0
+                    : cluster.nodes?.length > 0);
             if (hasCluster && cluster) {
                 // Cluster mode
                 let nodes = [];
@@ -31,7 +34,9 @@ class RedisCache extends BaseCache_1.BaseCache {
                     nodes = cluster.nodes;
                 }
                 this.client = (0, redis_1.createCluster)({
-                    rootNodes: nodes.map(node => ({ url: `redis://${node.host}:${node.port}` }))
+                    rootNodes: nodes.map((node) => ({
+                        url: `redis://${node.host}:${node.port}`,
+                    })),
                 });
             }
             else {
@@ -39,7 +44,7 @@ class RedisCache extends BaseCache_1.BaseCache {
                 const options = {
                     host: this.redisConfig.host ?? 'localhost',
                     port: this.redisConfig.port ?? 6379,
-                    db: this.redisConfig.db ?? 0
+                    db: this.redisConfig.db ?? 0,
                 };
                 if (this.redisConfig.username) {
                     options.username = this.redisConfig.username;
@@ -159,7 +164,7 @@ class RedisCache extends BaseCache_1.BaseCache {
             else {
                 // Clear all keys only in single-instance mode
                 const client = this.client;
-                if (client.flushDb) {
+                if (client && typeof client.flushDb === 'function') {
                     await client.flushDb();
                 }
                 else {
@@ -177,7 +182,7 @@ class RedisCache extends BaseCache_1.BaseCache {
     async getMultiple(keys) {
         try {
             await this.ensureConnected();
-            const fullKeys = keys.map(k => this.buildKey(k));
+            const fullKeys = keys.map((k) => this.buildKey(k));
             const values = await this.client.mGet(fullKeys);
             const result = {};
             keys.forEach((key, index) => {
@@ -235,7 +240,7 @@ class RedisCache extends BaseCache_1.BaseCache {
     async deleteMultiple(keys) {
         try {
             await this.ensureConnected();
-            const fullKeys = keys.map(k => this.buildKey(k));
+            const fullKeys = keys.map((k) => this.buildKey(k));
             const result = await this.client.del(fullKeys);
             this.stats.deletes += result;
             return result;
@@ -277,11 +282,19 @@ class RedisCache extends BaseCache_1.BaseCache {
         try {
             await this.ensureConnected();
             // Use sendCommand which works for both single and cluster
-            await this.client.sendCommand(['PING']);
+            // `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',
-                timestamp: new Date()
+                timestamp: new Date(),
             };
         }
         catch (err) {
@@ -289,7 +302,7 @@ class RedisCache extends BaseCache_1.BaseCache {
                 isAlive: false,
                 adapter: 'redis',
                 timestamp: new Date(),
-                error: err.message
+                error: err.message,
             };
         }
     }

package/dist/cjs/core/BaseCache.d.ts

@@ -1,4 +1,4 @@
-import type { CacheConfig, CacheStats, HealthCheckResponse, BatchResult } from '../types';
+import type { BatchResult, CacheConfig, CacheStats, HealthCheckResponse } from '../types';
 import type { ICache } from './interfaces';
 /**
  * Abstract base class for all cache adapters

package/dist/cjs/core/BaseCache.js

@@ -12,7 +12,7 @@ class BaseCache {
             hits: 0,
             misses: 0,
             sets: 0,
-            deletes: 0
+            deletes: 0,
         };
         this.namespace = config.namespace ? `${config.namespace}:` : '';
         this.ttl = config.ttl ?? 3600; // 1 hour default
@@ -77,7 +77,7 @@ class BaseCache {
             hits: 0,
             misses: 0,
             sets: 0,
-            deletes: 0
+            deletes: 0,
         };
     }
     /**

package/dist/cjs/core/factory.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheFactory = void 0;
-const redis_1 = require("../adapters/redis");
 const memcache_1 = require("../adapters/memcache");
 const memory_1 = require("../adapters/memory");
+const redis_1 = require("../adapters/redis");
 const errors_1 = require("../errors");
 /**
  * Factory for creating cache instances
@@ -50,7 +50,7 @@ class CacheFactory {
             return new memory_1.MemoryCache({
                 adapter: 'memory',
                 namespace: config.namespace,
-                ttl: config.ttl
+                ttl: config.ttl,
             });
         }
         // No fallback, throw error

package/dist/cjs/core/interfaces/ICache.d.ts

@@ -1,4 +1,4 @@
-import type { CacheStats, HealthCheckResponse, BatchResult } from '../../types';
+import type { BatchResult, CacheStats, HealthCheckResponse } from '../../types';
 /**
  * Main cache interface - defines all cache operations
  */

package/dist/cjs/index.d.ts

@@ -1,4 +1,4 @@
-export type { CacheConfig, RedisCacheConfig, MemcacheCacheConfig, MemoryCacheConfig, SessionData, SessionOptions, CacheStats, HealthCheckResponse, BatchResult, CacheEntry } from './types';
+export type { CacheConfig, RedisCacheConfig, MemcacheCacheConfig, MemoryCacheConfig, SessionData, SessionOptions, CacheStats, HealthCheckResponse, BatchResult, CacheEntry, } from './types';
 export { CacheError } from './errors';
 export type { ICache, ISession } from './core/interfaces';
 export { BaseCache } from './core/BaseCache';
@@ -7,4 +7,4 @@ export { MemcacheCache } from './adapters/memcache';
 export { MemoryCache } from './adapters/memory';
 export { CacheFactory } from './core/factory';
 export { SessionStore } from './session';
-export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware } from './middleware/express';
+export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware, } from './middleware/express';

package/dist/cjs/middleware/express/cacheMiddleware.d.ts

@@ -1,6 +1,6 @@
-import type { Request, Response, NextFunction } from 'express';
+import type { NextFunction, Request, Response } from 'express';
 import type { ICache } from '../../core/interfaces';
-import { SessionStore } from '../../session/SessionStore';
+import type { SessionStore } from '../../session/SessionStore';
 /**
  * Express middleware for session management using cache
  */

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

@@ -17,6 +17,7 @@ function cacheSessionMiddleware(sessionStore, options) {
                 // Fetch session data and extend expiry
                 const sessionData = await sessionStore.getAndExtend(sessionId);
                 if (sessionData) {
+                    ;
                     req[sessionDataKey] = sessionData;
                 }
             }
@@ -44,7 +45,7 @@ function cacheHealthCheckMiddleware(cache, endpoint = '/.health/cache') {
                     isAlive: false,
                     adapter: 'unknown',
                     timestamp: new Date(),
-                    error: err.message
+                    error: err.message,
                 });
             });
             return;
@@ -58,7 +59,9 @@ function cacheHealthCheckMiddleware(cache, endpoint = '/.health/cache') {
 function cacheResponseMiddleware(cache, options) {
     const ttl = options?.ttl ?? 300; // 5 minutes default
     const keyPrefix = options?.keyPrefix ?? 'response:';
-    const excludeStatusCodes = options?.excludeStatusCodes ?? [300, 301, 302, 303, 304, 307, 308, 404, 500, 501, 502, 503];
+    const excludeStatusCodes = options?.excludeStatusCodes ?? [
+        300, 301, 302, 303, 304, 307, 308, 404, 500, 501, 502, 503,
+    ];
     return (req, res, next) => {
         // Only cache GET requests
         if (req.method !== 'GET') {
@@ -82,10 +85,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/middleware/express/index.d.ts

@@ -1 +1 @@
-export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware } from './cacheMiddleware';
+export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware, } from './cacheMiddleware';

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

@@ -12,7 +12,7 @@ class SessionStore {
         this.options = {
             ttl: options.ttl ?? 3600, // 1 hour default
             serialize: options.serialize ?? ((data) => JSON.stringify(data)),
-            deserialize: options.deserialize ?? ((data) => JSON.parse(data))
+            deserialize: options.deserialize ?? ((data) => JSON.parse(data)),
         };
     }
     /**
@@ -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/esm/adapters/memcache/MemcacheCache.d.ts

@@ -1,5 +1,5 @@
-import type { MemcacheCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, MemcacheCacheConfig } from '../../types';
 /**
  * Memcache adapter
  */

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

@@ -25,12 +25,14 @@ export class MemcacheCache extends BaseCache {
                 remove: true,
                 failOverServers: [],
                 maxValue: 1048576, // 1MB default
-                idle: 30000
+                idle: 30000,
             };
             if (this.memcacheConfig.username) {
+                ;
                 options.username = this.memcacheConfig.username;
             }
             if (this.memcacheConfig.password) {
+                ;
                 options.password = this.memcacheConfig.password;
             }
             this.client = new Memcached(servers, options);
@@ -80,19 +82,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);
+                    }
                 });
             });
         }
@@ -187,7 +198,7 @@ export class MemcacheCache extends BaseCache {
     async getMultiple(keys) {
         try {
             await this.ensureConnected();
-            const fullKeys = keys.map(k => this.buildKey(k));
+            const fullKeys = keys.map((k) => this.buildKey(k));
             return new Promise((resolve, reject) => {
                 this.client.getMulti(fullKeys, (err, data) => {
                     if (err) {
@@ -195,21 +206,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);
                 });
@@ -253,9 +285,9 @@ export class MemcacheCache extends BaseCache {
     async deleteMultiple(keys) {
         try {
             await this.ensureConnected();
-            const fullKeys = keys.map(k => this.buildKey(k));
+            const fullKeys = keys.map((k) => this.buildKey(k));
             let deletedCount = 0;
-            await Promise.all(fullKeys.map(key => new Promise((resolve, reject) => {
+            await Promise.all(fullKeys.map((key) => new Promise((resolve, reject) => {
                 this.client.del(key, (err) => {
                     if (err) {
                         reject(err);
@@ -310,7 +342,7 @@ export class MemcacheCache extends BaseCache {
             return {
                 isAlive: true,
                 adapter: 'memcache',
-                timestamp: new Date()
+                timestamp: new Date(),
             };
         }
         catch (err) {
@@ -318,7 +350,7 @@ export class MemcacheCache extends BaseCache {
                 isAlive: false,
                 adapter: 'memcache',
                 timestamp: new Date(),
-                error: err.message
+                error: err.message,
             };
         }
     }

package/dist/esm/adapters/memory/MemoryCache.d.ts

@@ -1,5 +1,5 @@
-import type { MemoryCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, MemoryCacheConfig } from '../../types';
 /**
  * In-memory cache adapter for development and testing
  */

package/dist/esm/adapters/memory/MemoryCache.js

@@ -209,7 +209,9 @@ export class MemoryCache extends BaseCache {
             const fullKey = this.buildKey(key);
             const entry = this.store.get(fullKey);
             const current = entry && (!entry.expiresAt || entry.expiresAt >= Date.now())
-                ? (typeof entry.value === 'number' ? entry.value : 0)
+                ? typeof entry.value === 'number'
+                    ? entry.value
+                    : 0
                 : 0;
             const value = current + amount;
             const expiry = this.ttl;
@@ -229,7 +231,9 @@ export class MemoryCache extends BaseCache {
             const fullKey = this.buildKey(key);
             const entry = this.store.get(fullKey);
             const current = entry && (!entry.expiresAt || entry.expiresAt >= Date.now())
-                ? (typeof entry.value === 'number' ? entry.value : 0)
+                ? typeof entry.value === 'number'
+                    ? entry.value
+                    : 0
                 : 0;
             const value = current - amount;
             const expiry = this.ttl;
@@ -248,7 +252,7 @@ export class MemoryCache extends BaseCache {
         return {
             isAlive: true,
             adapter: 'memory',
-            timestamp: new Date()
+            timestamp: new Date(),
         };
     }
     /**

package/dist/esm/adapters/redis/RedisCache.d.ts

@@ -1,5 +1,5 @@
-import type { RedisCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, RedisCacheConfig } from '../../types';
 /**
  * Redis cache adapter
  */

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

@@ -17,7 +17,10 @@ export class RedisCache extends BaseCache {
     async connect() {
         try {
             const cluster = this.redisConfig.cluster;
-            const hasCluster = cluster && (Array.isArray(cluster) ? cluster.length > 0 : cluster.nodes?.length > 0);
+            const hasCluster = cluster &&
+                (Array.isArray(cluster)
+                    ? cluster.length > 0
+                    : cluster.nodes?.length > 0);
             if (hasCluster && cluster) {
                 // Cluster mode
                 let nodes = [];
@@ -28,7 +31,9 @@ export class RedisCache extends BaseCache {
                     nodes = cluster.nodes;
                 }
                 this.client = createCluster({
-                    rootNodes: nodes.map(node => ({ url: `redis://${node.host}:${node.port}` }))
+                    rootNodes: nodes.map((node) => ({
+                        url: `redis://${node.host}:${node.port}`,
+                    })),
                 });
             }
             else {
@@ -36,7 +41,7 @@ export class RedisCache extends BaseCache {
                 const options = {
                     host: this.redisConfig.host ?? 'localhost',
                     port: this.redisConfig.port ?? 6379,
-                    db: this.redisConfig.db ?? 0
+                    db: this.redisConfig.db ?? 0,
                 };
                 if (this.redisConfig.username) {
                     options.username = this.redisConfig.username;
@@ -156,7 +161,7 @@ export class RedisCache extends BaseCache {
             else {
                 // Clear all keys only in single-instance mode
                 const client = this.client;
-                if (client.flushDb) {
+                if (client && typeof client.flushDb === 'function') {
                     await client.flushDb();
                 }
                 else {
@@ -174,7 +179,7 @@ export class RedisCache extends BaseCache {
     async getMultiple(keys) {
         try {
             await this.ensureConnected();
-            const fullKeys = keys.map(k => this.buildKey(k));
+            const fullKeys = keys.map((k) => this.buildKey(k));
             const values = await this.client.mGet(fullKeys);
             const result = {};
             keys.forEach((key, index) => {
@@ -232,7 +237,7 @@ export class RedisCache extends BaseCache {
     async deleteMultiple(keys) {
         try {
             await this.ensureConnected();
-            const fullKeys = keys.map(k => this.buildKey(k));
+            const fullKeys = keys.map((k) => this.buildKey(k));
             const result = await this.client.del(fullKeys);
             this.stats.deletes += result;
             return result;
@@ -274,11 +279,19 @@ export class RedisCache extends BaseCache {
         try {
             await this.ensureConnected();
             // Use sendCommand which works for both single and cluster
-            await this.client.sendCommand(['PING']);
+            // `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',
-                timestamp: new Date()
+                timestamp: new Date(),
             };
         }
         catch (err) {
@@ -286,7 +299,7 @@ export class RedisCache extends BaseCache {
                 isAlive: false,
                 adapter: 'redis',
                 timestamp: new Date(),
-                error: err.message
+                error: err.message,
             };
         }
     }

package/dist/esm/core/BaseCache.d.ts

@@ -1,4 +1,4 @@
-import type { CacheConfig, CacheStats, HealthCheckResponse, BatchResult } from '../types';
+import type { BatchResult, CacheConfig, CacheStats, HealthCheckResponse } from '../types';
 import type { ICache } from './interfaces';
 /**
  * Abstract base class for all cache adapters

package/dist/esm/core/BaseCache.js

@@ -9,7 +9,7 @@ export class BaseCache {
             hits: 0,
             misses: 0,
             sets: 0,
-            deletes: 0
+            deletes: 0,
         };
         this.namespace = config.namespace ? `${config.namespace}:` : '';
         this.ttl = config.ttl ?? 3600; // 1 hour default
@@ -74,7 +74,7 @@ export class BaseCache {
             hits: 0,
             misses: 0,
             sets: 0,
-            deletes: 0
+            deletes: 0,
         };
     }
     /**

package/dist/esm/core/factory.js

@@ -1,6 +1,6 @@
-import { RedisCache } from '../adapters/redis';
 import { MemcacheCache } from '../adapters/memcache';
 import { MemoryCache } from '../adapters/memory';
+import { RedisCache } from '../adapters/redis';
 import { CacheError } from '../errors';
 /**
  * Factory for creating cache instances
@@ -47,7 +47,7 @@ export class CacheFactory {
             return new MemoryCache({
                 adapter: 'memory',
                 namespace: config.namespace,
-                ttl: config.ttl
+                ttl: config.ttl,
             });
         }
         // No fallback, throw error

package/dist/esm/core/interfaces/ICache.d.ts

@@ -1,4 +1,4 @@
-import type { CacheStats, HealthCheckResponse, BatchResult } from '../../types';
+import type { BatchResult, CacheStats, HealthCheckResponse } from '../../types';
 /**
  * Main cache interface - defines all cache operations
  */

package/dist/esm/index.d.ts

@@ -1,4 +1,4 @@
-export type { CacheConfig, RedisCacheConfig, MemcacheCacheConfig, MemoryCacheConfig, SessionData, SessionOptions, CacheStats, HealthCheckResponse, BatchResult, CacheEntry } from './types';
+export type { CacheConfig, RedisCacheConfig, MemcacheCacheConfig, MemoryCacheConfig, SessionData, SessionOptions, CacheStats, HealthCheckResponse, BatchResult, CacheEntry, } from './types';
 export { CacheError } from './errors';
 export type { ICache, ISession } from './core/interfaces';
 export { BaseCache } from './core/BaseCache';
@@ -7,4 +7,4 @@ export { MemcacheCache } from './adapters/memcache';
 export { MemoryCache } from './adapters/memory';
 export { CacheFactory } from './core/factory';
 export { SessionStore } from './session';
-export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware } from './middleware/express';
+export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware, } from './middleware/express';

package/dist/esm/index.js

@@ -11,4 +11,4 @@ export { CacheFactory } from './core/factory';
 // Session
 export { SessionStore } from './session';
 // Middleware
-export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware } from './middleware/express';
+export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware, } from './middleware/express';

package/dist/esm/middleware/express/cacheMiddleware.d.ts

@@ -1,6 +1,6 @@
-import type { Request, Response, NextFunction } from 'express';
+import type { NextFunction, Request, Response } from 'express';
 import type { ICache } from '../../core/interfaces';
-import { SessionStore } from '../../session/SessionStore';
+import type { SessionStore } from '../../session/SessionStore';
 /**
  * Express middleware for session management using cache
  */

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

@@ -12,6 +12,7 @@ export function cacheSessionMiddleware(sessionStore, options) {
                 // Fetch session data and extend expiry
                 const sessionData = await sessionStore.getAndExtend(sessionId);
                 if (sessionData) {
+                    ;
                     req[sessionDataKey] = sessionData;
                 }
             }
@@ -39,7 +40,7 @@ export function cacheHealthCheckMiddleware(cache, endpoint = '/.health/cache') {
                     isAlive: false,
                     adapter: 'unknown',
                     timestamp: new Date(),
-                    error: err.message
+                    error: err.message,
                 });
             });
             return;
@@ -53,7 +54,9 @@ export function cacheHealthCheckMiddleware(cache, endpoint = '/.health/cache') {
 export function cacheResponseMiddleware(cache, options) {
     const ttl = options?.ttl ?? 300; // 5 minutes default
     const keyPrefix = options?.keyPrefix ?? 'response:';
-    const excludeStatusCodes = options?.excludeStatusCodes ?? [300, 301, 302, 303, 304, 307, 308, 404, 500, 501, 502, 503];
+    const excludeStatusCodes = options?.excludeStatusCodes ?? [
+        300, 301, 302, 303, 304, 307, 308, 404, 500, 501, 502, 503,
+    ];
     return (req, res, next) => {
         // Only cache GET requests
         if (req.method !== 'GET') {
@@ -77,10 +80,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/middleware/express/index.d.ts

@@ -1 +1 @@
-export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware } from './cacheMiddleware';
+export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware, } from './cacheMiddleware';

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

@@ -1 +1 @@
-export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware } from './cacheMiddleware';
+export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware, } from './cacheMiddleware';

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

@@ -9,7 +9,7 @@ export class SessionStore {
         this.options = {
             ttl: options.ttl ?? 3600, // 1 hour default
             serialize: options.serialize ?? ((data) => JSON.stringify(data)),
-            deserialize: options.deserialize ?? ((data) => JSON.parse(data))
+            deserialize: options.deserialize ?? ((data) => JSON.parse(data)),
         };
     }
     /**
@@ -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/types/adapters/memcache/MemcacheCache.d.ts

@@ -1,5 +1,5 @@
-import type { MemcacheCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, MemcacheCacheConfig } from '../../types';
 /**
  * Memcache adapter
  */

package/dist/types/adapters/memory/MemoryCache.d.ts

@@ -1,5 +1,5 @@
-import type { MemoryCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, MemoryCacheConfig } from '../../types';
 /**
  * In-memory cache adapter for development and testing
  */

package/dist/types/adapters/redis/RedisCache.d.ts

@@ -1,5 +1,5 @@
-import type { RedisCacheConfig, HealthCheckResponse } from '../../types';
 import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, RedisCacheConfig } from '../../types';
 /**
  * Redis cache adapter
  */

package/dist/types/core/BaseCache.d.ts

@@ -1,4 +1,4 @@
-import type { CacheConfig, CacheStats, HealthCheckResponse, BatchResult } from '../types';
+import type { BatchResult, CacheConfig, CacheStats, HealthCheckResponse } from '../types';
 import type { ICache } from './interfaces';
 /**
  * Abstract base class for all cache adapters

package/dist/types/core/interfaces/ICache.d.ts

@@ -1,4 +1,4 @@
-import type { CacheStats, HealthCheckResponse, BatchResult } from '../../types';
+import type { BatchResult, CacheStats, HealthCheckResponse } from '../../types';
 /**
  * Main cache interface - defines all cache operations
  */

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export type { CacheConfig, RedisCacheConfig, MemcacheCacheConfig, MemoryCacheConfig, SessionData, SessionOptions, CacheStats, HealthCheckResponse, BatchResult, CacheEntry } from './types';
+export type { CacheConfig, RedisCacheConfig, MemcacheCacheConfig, MemoryCacheConfig, SessionData, SessionOptions, CacheStats, HealthCheckResponse, BatchResult, CacheEntry, } from './types';
 export { CacheError } from './errors';
 export type { ICache, ISession } from './core/interfaces';
 export { BaseCache } from './core/BaseCache';
@@ -7,4 +7,4 @@ export { MemcacheCache } from './adapters/memcache';
 export { MemoryCache } from './adapters/memory';
 export { CacheFactory } from './core/factory';
 export { SessionStore } from './session';
-export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware } from './middleware/express';
+export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware, } from './middleware/express';

package/dist/types/middleware/express/cacheMiddleware.d.ts

@@ -1,6 +1,6 @@
-import type { Request, Response, NextFunction } from 'express';
+import type { NextFunction, Request, Response } from 'express';
 import type { ICache } from '../../core/interfaces';
-import { SessionStore } from '../../session/SessionStore';
+import type { SessionStore } from '../../session/SessionStore';
 /**
  * Express middleware for session management using cache
  */

package/dist/types/middleware/express/index.d.ts

@@ -1 +1 @@
-export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware } from './cacheMiddleware';
+export { cacheSessionMiddleware, cacheHealthCheckMiddleware, cacheResponseMiddleware, } from './cacheMiddleware';

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naman_deep_singh/cache",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "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",