ts-packages 2.0.0 → 3.0.0

package/packages/cache/src/adapters/memory/MemoryCache.ts

@@ -1,3 +1,4 @@
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes'
 import { BaseCache } from '../../core/BaseCache'
 import { CacheError } from '../../errors'
 import type { HealthCheckResponse, MemoryCacheConfig } from '../../types'
@@ -52,13 +53,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 
 			this.recordHit()
 			return entry.value
-		} catch (err) {
-			throw new CacheError(
-				`Failed to get key "${key}" from memory cache`,
-				'MEMORY_GET_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_KEY_NOT_FOUND, {
+				adapter: 'memory',
+				operation: 'get',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -84,13 +85,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 
 			this.store.set(fullKey, { value, expiresAt })
 			this.recordSet()
-		} catch (err) {
-			throw new CacheError(
-				`Failed to set key "${key}" in memory cache`,
-				'MEMORY_SET_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'set',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -105,13 +106,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 				this.recordDelete()
 			}
 			return deleted
-		} catch (err) {
-			throw new CacheError(
-				`Failed to delete key "${key}" from memory cache`,
-				'MEMORY_DELETE_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'delete',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -134,13 +135,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 			}
 
 			return true
-		} catch (err) {
-			throw new CacheError(
-				`Failed to check existence of key "${key}" in memory cache`,
-				'MEMORY_EXISTS_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'exists',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -160,13 +161,12 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 				// Clear all
 				this.store.clear()
 			}
-		} catch (err) {
-			throw new CacheError(
-				'Failed to clear memory cache',
-				'MEMORY_CLEAR_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_OPERATION_TIMEOUT, {
+				adapter: 'memory',
+				operation: 'clear',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -200,13 +200,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 			}
 
 			return result
-		} catch (err) {
-			throw new CacheError(
-				'Failed to get multiple keys from memory cache',
-				'MEMORY_GET_MULTIPLE_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'getMultiple',
+				details: { keys },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -224,13 +224,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 			}
 
 			this.stats.sets += Object.keys(data).length
-		} catch (err) {
-			throw new CacheError(
-				'Failed to set multiple keys in memory cache',
-				'MEMORY_SET_MULTIPLE_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'setMultiple',
+				details: { keys: Object.keys(data) },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -248,13 +248,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 			}
 			this.stats.deletes += count
 			return count
-		} catch (err) {
-			throw new CacheError(
-				'Failed to delete multiple keys from memory cache',
-				'MEMORY_DELETE_MULTIPLE_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'deleteMultiple',
+				details: { keys },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -280,13 +280,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 
 			this.store.set(fullKey, { value: value as T, expiresAt })
 			return value
-		} catch (err) {
-			throw new CacheError(
-				`Failed to increment key "${key}" in memory cache`,
-				'MEMORY_INCREMENT_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'increment',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -312,13 +312,13 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 
 			this.store.set(fullKey, { value: value as T, expiresAt })
 			return value
-		} catch (err) {
-			throw new CacheError(
-				`Failed to decrement key "${key}" in memory cache`,
-				'MEMORY_DECREMENT_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'decrement',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -343,13 +343,12 @@ export class MemoryCache<T = unknown> extends BaseCache<T> {
 				this.cleanupInterval = null
 			}
 			this.store.clear()
-		} catch (err) {
-			throw new CacheError(
-				'Failed to close memory cache',
-				'MEMORY_CLOSE_ERROR',
-				'memory',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'memory',
+				operation: 'close',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 }

package/packages/cache/src/adapters/redis/RedisCache.ts

@@ -1,5 +1,6 @@
 import { createClient, createCluster } from 'redis'
 import type { RedisClientOptions } from 'redis'
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes'
 import { BaseCache } from '../../core/BaseCache'
 import { CacheError } from '../../errors'
 import type { HealthCheckResponse, RedisCacheConfig } from '../../types'
@@ -81,13 +82,12 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 				await this.client.connect()
 				this.isConnected = true
 			}
-		} catch (err) {
-			throw new CacheError(
-				'Failed to connect to Redis',
-				'REDIS_CONNECTION_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_CONNECTION_FAILED, {
+				adapter: 'redis',
+				operation: 'connect',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -116,13 +116,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 
 			this.recordHit()
 			return this.deserialize(value)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to get key "${key}" from Redis`,
-				'REDIS_GET_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'get',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -143,13 +143,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 			}
 
 			this.recordSet()
-		} catch (err) {
-			throw new CacheError(
-				`Failed to set key "${key}" in Redis`,
-				'REDIS_SET_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'set',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -163,13 +163,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 			const result = await this.client!.del(fullKey)
 			this.recordDelete()
 			return result > 0
-		} catch (err) {
-			throw new CacheError(
-				`Failed to delete key "${key}" from Redis`,
-				'REDIS_DELETE_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'delete',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -182,13 +182,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 			const fullKey = this.buildKey(key)
 			const result = await this.client!.exists(fullKey)
 			return result > 0
-		} catch (err) {
-			throw new CacheError(
-				`Failed to check existence of key "${key}" in Redis`,
-				'REDIS_EXISTS_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'exists',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -214,13 +214,12 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 					console.warn('Clear operation not supported in cluster mode')
 				}
 			}
-		} catch (err) {
-			throw new CacheError(
-				'Failed to clear Redis cache',
-				'REDIS_CLEAR_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_OPERATION_TIMEOUT, {
+				adapter: 'redis',
+				operation: 'clear',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -246,13 +245,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 			})
 
 			return result
-		} catch (err) {
-			throw new CacheError(
-				'Failed to get multiple keys from Redis',
-				'REDIS_GET_MULTIPLE_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'getMultiple',
+				details: { keys },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -284,13 +283,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 			}
 
 			this.stats.sets += Object.keys(data).length
-		} catch (err) {
-			throw new CacheError(
-				'Failed to set multiple keys in Redis',
-				'REDIS_SET_MULTIPLE_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'setMultiple',
+				details: { keys: Object.keys(data) },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -304,13 +303,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 			const result = await this.client!.del(fullKeys)
 			this.stats.deletes += result
 			return result
-		} catch (err) {
-			throw new CacheError(
-				'Failed to delete multiple keys from Redis',
-				'REDIS_DELETE_MULTIPLE_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'deleteMultiple',
+				details: { keys },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -322,13 +321,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 			await this.ensureConnected()
 			const fullKey = this.buildKey(key)
 			return await this.client!.incrBy(fullKey, amount)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to increment key "${key}" in Redis`,
-				'REDIS_INCREMENT_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'increment',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -340,13 +339,13 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 			await this.ensureConnected()
 			const fullKey = this.buildKey(key)
 			return await this.client!.decrBy(fullKey, amount)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to decrement key "${key}" in Redis`,
-				'REDIS_DECREMENT_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'decrement',
+				details: { key },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -374,12 +373,12 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 				adapter: 'redis',
 				timestamp: new Date(),
 			}
-		} catch (err) {
+		} catch (error) {
 			return {
 				isAlive: false,
 				adapter: 'redis',
 				timestamp: new Date(),
-				error: (err as Error).message,
+				error: (error as Error).message,
 			}
 		}
 	}
@@ -394,13 +393,12 @@ export class RedisCache<T = unknown> extends BaseCache<T> {
 				this.isConnected = false
 				this.client = null
 			}
-		} catch (err) {
-			throw new CacheError(
-				'Failed to close Redis connection',
-				'REDIS_CLOSE_ERROR',
-				'redis',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+				adapter: 'redis',
+				operation: 'close',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 }

package/packages/cache/src/core/BaseCache.ts

@@ -1,3 +1,4 @@
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes'
 import { CacheError } from '../errors'
 
 import type {
@@ -39,13 +40,12 @@ export abstract class BaseCache<T = unknown> implements ICache<T> {
 	protected deserialize(data: string): T {
 		try {
 			return JSON.parse(data)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to deserialize cache value for key`,
-				'DESERIALIZE_ERROR',
-				this.config.adapter,
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_DESERIALIZE_ERROR, {
+				adapter: this.config.adapter,
+				operation: 'deserialize',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -55,13 +55,12 @@ export abstract class BaseCache<T = unknown> implements ICache<T> {
 	protected serialize(value: T): string {
 		try {
 			return JSON.stringify(value)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to serialize cache value`,
-				'SERIALIZE_ERROR',
-				this.config.adapter,
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.CACHE_SERIALIZE_ERROR, {
+				adapter: this.config.adapter,
+				operation: 'serialize',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 

package/packages/cache/src/core/factory.ts

@@ -1,3 +1,4 @@
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes'
 import { MemcacheCache } from '../adapters/memcache'
 import { MemoryCache } from '../adapters/memory'
 import { RedisCache } from '../adapters/redis'
@@ -25,18 +26,25 @@ export class CacheFactory {
 
 				// Validate: can't use both single + cluster
 				if (redisConfig.host && redisConfig.cluster) {
-					throw new CacheError(
-						'Cannot specify both host and cluster config',
-						'INVALID_CONFIG',
-					)
+					throw new CacheError(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 CacheError(
-						'Redis requires either host or cluster config',
-						'INVALID_CONFIG',
-					)
+					throw new CacheError(CACHE_ERROR_CODES.CACHE_INVALID_CONFIG, {
+						adapter: 'redis',
+						operation: 'create',
+						details: {
+							reason: 'Redis requires either host or cluster config',
+						},
+					})
 				}
 				return new RedisCache<T>(redisConfig)
 
@@ -47,10 +55,10 @@ export class CacheFactory {
 				return new MemoryCache<T>(config as MemoryCacheConfig)
 
 			default:
-				throw new CacheError(
-					`Unknown cache adapter: ${config.adapter}`,
-					'UNKNOWN_ADAPTER',
-				)
+				throw new CacheError(CACHE_ERROR_CODES.CACHE_UNSUPPORTED_ADAPTER, {
+					adapter: config.adapter,
+					operation: 'create',
+				})
 		}
 	}
 
@@ -84,9 +92,12 @@ export class CacheFactory {
 		}
 
 		// No fallback, throw error
-		throw new CacheError(
-			`Failed to initialize ${config.adapter} cache and fallback is disabled`,
-			'CACHE_INIT_ERROR',
-		)
+		throw new CacheError(CACHE_ERROR_CODES.CACHE_CONNECTION_FAILED, {
+			adapter: config.adapter,
+			operation: 'createWithFallback',
+			details: {
+				reason: `${config.adapter} cache is not alive and fallback is disabled`,
+			},
+		})
 	}
 }

package/packages/cache/src/errors/CacheError.ts

@@ -1,22 +1,21 @@
-/**
- * Custom error class for cache operations
- */
-export class CacheError extends Error {
-	public readonly code: string
-	public readonly adapter?: string
-	public readonly originalError?: Error
+import { AppError, type ErrorCode } from '@naman_deep_singh/errors-utils'
+import type { CacheErrorCode } from './cacheErrorCodes'
+
+export class CacheError extends AppError {
+	readonly adapter?: string
+	readonly operation?: string
 
 	constructor(
-		message: string,
-		code = 'CACHE_ERROR',
-		adapter?: string,
-		originalError?: Error,
+		code: CacheErrorCode,
+		options?: {
+			adapter?: string
+			operation?: string
+			details?: unknown
+			cause?: Error
+		},
 	) {
-		super(message)
-		this.name = 'CacheError'
-		this.code = code
-		this.adapter = adapter
-		this.originalError = originalError
-		Object.setPrototypeOf(this, CacheError.prototype)
+		super(code as ErrorCode, undefined, options?.details, options?.cause)
+		this.adapter = options?.adapter
+		this.operation = options?.operation
 	}
 }

package/packages/cache/src/errors/cacheErrorCodes.ts

@@ -0,0 +1,24 @@
+export const 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',
+} as const
+
+export type CacheErrorCode =
+	(typeof CACHE_ERROR_CODES)[keyof typeof CACHE_ERROR_CODES]