ts-packages 2.0.0 → 3.0.0

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryCache = void 0;
+const cacheErrorCodes_1 = require("src/errors/cacheErrorCodes");
 const BaseCache_1 = require("../../core/BaseCache");
 const errors_1 = require("../../errors");
 /**
@@ -49,8 +50,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             this.recordHit();
             return entry.value;
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to get key "${key}" from memory cache`, 'MEMORY_GET_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_KEY_NOT_FOUND, {
+                adapter: 'memory',
+                operation: 'get',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -73,8 +79,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             this.store.set(fullKey, { value, expiresAt });
             this.recordSet();
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to set key "${key}" in memory cache`, 'MEMORY_SET_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'set',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -89,8 +100,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             }
             return deleted;
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to delete key "${key}" from memory cache`, 'MEMORY_DELETE_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'delete',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -110,8 +126,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             }
             return true;
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to check existence of key "${key}" in memory cache`, 'MEMORY_EXISTS_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'exists',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -132,8 +153,12 @@ class MemoryCache extends BaseCache_1.BaseCache {
                 this.store.clear();
             }
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to clear memory cache', 'MEMORY_CLEAR_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_OPERATION_TIMEOUT, {
+                adapter: 'memory',
+                operation: 'clear',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -164,8 +189,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             }
             return result;
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to get multiple keys from memory cache', 'MEMORY_GET_MULTIPLE_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'getMultiple',
+                details: { keys },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -181,8 +211,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             }
             this.stats.sets += Object.keys(data).length;
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to set multiple keys in memory cache', 'MEMORY_SET_MULTIPLE_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'setMultiple',
+                details: { keys: Object.keys(data) },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -200,8 +235,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             this.stats.deletes += count;
             return count;
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to delete multiple keys from memory cache', 'MEMORY_DELETE_MULTIPLE_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'deleteMultiple',
+                details: { keys },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -222,8 +262,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             this.store.set(fullKey, { value: value, expiresAt });
             return value;
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to increment key "${key}" in memory cache`, 'MEMORY_INCREMENT_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'increment',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -244,8 +289,13 @@ class MemoryCache extends BaseCache_1.BaseCache {
             this.store.set(fullKey, { value: value, expiresAt });
             return value;
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to decrement key "${key}" in memory cache`, 'MEMORY_DECREMENT_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'decrement',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -269,8 +319,12 @@ class MemoryCache extends BaseCache_1.BaseCache {
             }
             this.store.clear();
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to close memory cache', 'MEMORY_CLOSE_ERROR', 'memory', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'close',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisCache = void 0;
 const redis_1 = require("redis");
+const cacheErrorCodes_1 = require("src/errors/cacheErrorCodes");
 const BaseCache_1 = require("../../core/BaseCache");
 const errors_1 = require("../../errors");
 /**
@@ -69,8 +70,12 @@ class RedisCache extends BaseCache_1.BaseCache {
                 this.isConnected = true;
             }
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to connect to Redis', 'REDIS_CONNECTION_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_CONNECTION_FAILED, {
+                adapter: 'redis',
+                operation: 'connect',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -96,8 +101,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             this.recordHit();
             return this.deserialize(value);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to get key "${key}" from Redis`, 'REDIS_GET_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'get',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -117,8 +127,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             }
             this.recordSet();
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to set key "${key}" in Redis`, 'REDIS_SET_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'set',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -132,8 +147,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             this.recordDelete();
             return result > 0;
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to delete key "${key}" from Redis`, 'REDIS_DELETE_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'delete',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -146,8 +166,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             const result = await this.client.exists(fullKey);
             return result > 0;
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to check existence of key "${key}" in Redis`, 'REDIS_EXISTS_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'exists',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -172,8 +197,12 @@ class RedisCache extends BaseCache_1.BaseCache {
                 }
             }
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to clear Redis cache', 'REDIS_CLEAR_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_OPERATION_TIMEOUT, {
+                adapter: 'redis',
+                operation: 'clear',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -198,8 +227,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             });
             return result;
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to get multiple keys from Redis', 'REDIS_GET_MULTIPLE_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'getMultiple',
+                details: { keys },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -230,8 +264,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             }
             this.stats.sets += Object.keys(data).length;
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to set multiple keys in Redis', 'REDIS_SET_MULTIPLE_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'setMultiple',
+                details: { keys: Object.keys(data) },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -245,8 +284,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             this.stats.deletes += result;
             return result;
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to delete multiple keys from Redis', 'REDIS_DELETE_MULTIPLE_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'deleteMultiple',
+                details: { keys },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -258,8 +302,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             const fullKey = this.buildKey(key);
             return await this.client.incrBy(fullKey, amount);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to increment key "${key}" in Redis`, 'REDIS_INCREMENT_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'increment',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -271,8 +320,13 @@ class RedisCache extends BaseCache_1.BaseCache {
             const fullKey = this.buildKey(key);
             return await this.client.decrBy(fullKey, amount);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to decrement key "${key}" in Redis`, 'REDIS_DECREMENT_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'decrement',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -297,12 +351,12 @@ class RedisCache extends BaseCache_1.BaseCache {
                 timestamp: new Date(),
             };
         }
-        catch (err) {
+        catch (error) {
             return {
                 isAlive: false,
                 adapter: 'redis',
                 timestamp: new Date(),
-                error: err.message,
+                error: error.message,
             };
         }
     }
@@ -317,8 +371,12 @@ class RedisCache extends BaseCache_1.BaseCache {
                 this.client = null;
             }
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to close Redis connection', 'REDIS_CLOSE_ERROR', 'redis', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'close',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
 }

package/packages/cache/dist/cjs/core/BaseCache.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCache = void 0;
+const cacheErrorCodes_1 = require("src/errors/cacheErrorCodes");
 const errors_1 = require("../errors");
 /**
  * Abstract base class for all cache adapters
@@ -30,8 +31,12 @@ class BaseCache {
         try {
             return JSON.parse(data);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to deserialize cache value for key`, 'DESERIALIZE_ERROR', this.config.adapter, err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_DESERIALIZE_ERROR, {
+                adapter: this.config.adapter,
+                operation: 'deserialize',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -41,8 +46,12 @@ class BaseCache {
         try {
             return JSON.stringify(value);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to serialize cache value`, 'SERIALIZE_ERROR', this.config.adapter, err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_SERIALIZE_ERROR, {
+                adapter: this.config.adapter,
+                operation: 'serialize',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**

package/packages/cache/dist/cjs/core/factory.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheFactory = void 0;
+const cacheErrorCodes_1 = require("src/errors/cacheErrorCodes");
 const memcache_1 = require("../adapters/memcache");
 const memory_1 = require("../adapters/memory");
 const redis_1 = require("../adapters/redis");
@@ -18,11 +19,23 @@ class CacheFactory {
                 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');
+                    throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_INVALID_CONFIG, {
+                        adapter: 'redis',
+                        operation: 'create',
+                        details: {
+                            reason: 'Redis config cannot have both "host" and "cluster" defined',
+                        },
+                    });
                 }
                 // Require either single or cluster
                 if (!redisConfig.host && !redisConfig.cluster) {
-                    throw new errors_1.CacheError('Redis requires either host or cluster config', 'INVALID_CONFIG');
+                    throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_INVALID_CONFIG, {
+                        adapter: 'redis',
+                        operation: 'create',
+                        details: {
+                            reason: 'Redis requires either host or cluster config',
+                        },
+                    });
                 }
                 return new redis_1.RedisCache(redisConfig);
             case 'memcache':
@@ -30,7 +43,10 @@ class CacheFactory {
             case 'memory':
                 return new memory_1.MemoryCache(config);
             default:
-                throw new errors_1.CacheError(`Unknown cache adapter: ${config.adapter}`, 'UNKNOWN_ADAPTER');
+                throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_UNSUPPORTED_ADAPTER, {
+                    adapter: config.adapter,
+                    operation: 'create',
+                });
         }
     }
     /**
@@ -54,7 +70,13 @@ class CacheFactory {
             });
         }
         // No fallback, throw error
-        throw new errors_1.CacheError(`Failed to initialize ${config.adapter} cache and fallback is disabled`, 'CACHE_INIT_ERROR');
+        throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.CACHE_CONNECTION_FAILED, {
+            adapter: config.adapter,
+            operation: 'createWithFallback',
+            details: {
+                reason: `${config.adapter} cache is not alive and fallback is disabled`,
+            },
+        });
     }
 }
 exports.CacheFactory = CacheFactory;

package/packages/cache/dist/cjs/errors/CacheError.d.ts

@@ -1,9 +1,12 @@
-/**
- * Custom error class for cache operations
- */
-export declare class CacheError extends Error {
-    readonly code: string;
+import { AppError } from '@naman_deep_singh/errors-utils';
+import type { CacheErrorCode } from './cacheErrorCodes';
+export declare class CacheError extends AppError {
     readonly adapter?: string;
-    readonly originalError?: Error;
-    constructor(message: string, code?: string, adapter?: string, originalError?: Error);
+    readonly operation?: string;
+    constructor(code: CacheErrorCode, options?: {
+        adapter?: string;
+        operation?: string;
+        details?: unknown;
+        cause?: Error;
+    });
 }

package/packages/cache/dist/cjs/errors/CacheError.js

@@ -1,17 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheError = void 0;
-/**
- * Custom error class for cache operations
- */
-class CacheError extends Error {
-    constructor(message, code = 'CACHE_ERROR', adapter, originalError) {
-        super(message);
-        this.name = 'CacheError';
-        this.code = code;
-        this.adapter = adapter;
-        this.originalError = originalError;
-        Object.setPrototypeOf(this, CacheError.prototype);
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+class CacheError extends errors_utils_1.AppError {
+    constructor(code, options) {
+        super(code, undefined, options?.details, options?.cause);
+        this.adapter = options?.adapter;
+        this.operation = options?.operation;
     }
 }
 exports.CacheError = CacheError;

package/packages/cache/dist/cjs/errors/cacheErrorCodes.d.ts

@@ -0,0 +1,22 @@
+export declare const CACHE_ERROR_CODES: {
+    readonly CACHE_ERROR: "Temporary caching issue, please retry";
+    readonly CACHE_CONNECTION_FAILED: "Failed to connect to the cache server";
+    readonly CACHE_UNSUPPORTED_ADAPTER: "The specified cache adapter is not supported";
+    readonly CACHE_INVALID_CONFIG: "The provided cache configuration is invalid";
+    readonly CACHE_KEY_NOT_FOUND: "The requested cache key was not found";
+    readonly CACHE_OPERATION_TIMEOUT: "The cache operation timed out";
+    readonly CACHE_SERIALIZE_ERROR: "Failed to serialize cached data";
+    readonly CACHE_DESERIALIZE_ERROR: "Failed to deserialize cached data";
+    readonly SESSION_CREATE_ERROR: "Failed to create a new session";
+    readonly SESSION_GET_ERROR: "Failed to get session data";
+    readonly SESSION_UPDATE_ERROR: "Failed to update session data";
+    readonly SESSION_DELETE_ERROR: "Failed to delete session data";
+    readonly SESSION_EXISTS_ERROR: "Failed to check session existence";
+    readonly SESSION_CLEAR_ERROR: "Failed to clear sessions";
+    readonly SESSION_GET_MULTIPLE_ERROR: "Failed to get multiple sessions";
+    readonly SESSION_DELETE_MULTIPLE_ERROR: "Failed to delete multiple sessions";
+    readonly SESSION_EXTEND_ERROR: "Failed to extend session expiry";
+    readonly SESSION_GET_EXTEND_ERROR: "Failed to get and extend session data";
+    readonly SESSION_NOT_FOUND: "Session not found";
+};
+export type CacheErrorCode = (typeof CACHE_ERROR_CODES)[keyof typeof CACHE_ERROR_CODES];

package/packages/cache/dist/cjs/errors/cacheErrorCodes.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_ERROR_CODES = void 0;
+exports.CACHE_ERROR_CODES = {
+    CACHE_ERROR: 'Temporary caching issue, please retry',
+    CACHE_CONNECTION_FAILED: 'Failed to connect to the cache server',
+    CACHE_UNSUPPORTED_ADAPTER: 'The specified cache adapter is not supported',
+    CACHE_INVALID_CONFIG: 'The provided cache configuration is invalid',
+    CACHE_KEY_NOT_FOUND: 'The requested cache key was not found',
+    CACHE_OPERATION_TIMEOUT: 'The cache operation timed out',
+    CACHE_SERIALIZE_ERROR: 'Failed to serialize cached data',
+    CACHE_DESERIALIZE_ERROR: 'Failed to deserialize cached data',
+    SESSION_CREATE_ERROR: 'Failed to create a new session',
+    SESSION_GET_ERROR: 'Failed to get session data',
+    SESSION_UPDATE_ERROR: 'Failed to update session data',
+    SESSION_DELETE_ERROR: 'Failed to delete session data',
+    SESSION_EXISTS_ERROR: 'Failed to check session existence',
+    SESSION_CLEAR_ERROR: 'Failed to clear sessions',
+    SESSION_GET_MULTIPLE_ERROR: 'Failed to get multiple sessions',
+    SESSION_DELETE_MULTIPLE_ERROR: 'Failed to delete multiple sessions',
+    SESSION_EXTEND_ERROR: 'Failed to extend session expiry',
+    SESSION_GET_EXTEND_ERROR: 'Failed to get and extend session data',
+    SESSION_NOT_FOUND: 'Session not found',
+};

package/packages/cache/dist/cjs/errors/index.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheError = void 0;
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const cacheErrorCodes_1 = require("./cacheErrorCodes");
+errors_utils_1.errorMessageRegistry.register(cacheErrorCodes_1.CACHE_ERROR_CODES);
 var CacheError_1 = require("./CacheError");
 Object.defineProperty(exports, "CacheError", { enumerable: true, get: function () { return CacheError_1.CacheError; } });

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

@@ -23,8 +23,8 @@ function cacheSessionMiddleware(sessionStore, options) {
             }
             next();
         }
-        catch (err) {
-            console.error('Session middleware error:', err);
+        catch (error) {
+            console.error('Session middleware error:', error);
             next();
         }
     };
@@ -40,12 +40,12 @@ function cacheHealthCheckMiddleware(cache, endpoint = '/.health/cache') {
                 .then((health) => {
                 res.status(health.isAlive ? 200 : 503).json(health);
             })
-                .catch((err) => {
+                .catch((error) => {
                 res.status(503).json({
                     isAlive: false,
                     adapter: 'unknown',
                     timestamp: new Date(),
-                    error: err.message,
+                    error: error.message,
                 });
             });
             return;
@@ -98,8 +98,8 @@ function cacheResponseMiddleware(cache, options) {
                         }
                     }
                     if (responseData !== null) {
-                        cache.set(cacheKey, responseData, ttl).catch((err) => {
-                            console.error('Failed to cache response:', err);
+                        cache.set(cacheKey, responseData, ttl).catch((error) => {
+                            console.error('Failed to cache response:', error);
                         });
                     }
                 }
@@ -108,8 +108,8 @@ function cacheResponseMiddleware(cache, options) {
             };
             next();
         })
-            .catch((err) => {
-            console.error('Cache middleware error:', err);
+            .catch((error) => {
+            console.error('Cache middleware error:', error);
             next();
         });
     };