ts-packages 2.0.0 → 3.0.0

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

@@ -1 +1,6 @@
+import { errorMessageRegistry } from '@naman_deep_singh/errors-utils'
+import { CACHE_ERROR_CODES } from './cacheErrorCodes'
+
+errorMessageRegistry.register(CACHE_ERROR_CODES)
+
 export { CacheError } from './CacheError'

package/packages/cache/src/middleware/express/cacheMiddleware.ts

@@ -31,8 +31,8 @@ export function cacheSessionMiddleware(
 			}
 
 			next()
-		} catch (err) {
-			console.error('Session middleware error:', err)
+		} catch (error) {
+			console.error('Session middleware error:', error)
 			next()
 		}
 	}
@@ -52,12 +52,12 @@ export function cacheHealthCheckMiddleware(
 				.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 as Error).message,
+						error: (error as Error).message,
 					})
 				})
 			return
@@ -125,8 +125,8 @@ export function cacheResponseMiddleware(
 						}
 
 						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)
 							})
 						}
 					}
@@ -137,8 +137,8 @@ export function cacheResponseMiddleware(
 
 				next()
 			})
-			.catch((err) => {
-				console.error('Cache middleware error:', err)
+			.catch((error) => {
+				console.error('Cache middleware error:', error)
 				next()
 			})
 	}

package/packages/cache/src/session/SessionStore.ts

@@ -1,5 +1,6 @@
 import { CacheError } from '../errors'
 
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes'
 import type { ICache } from '../core/interfaces'
 import type { SessionData, SessionOptions } from '../types'
 
@@ -31,13 +32,13 @@ export class SessionStore {
 		try {
 			const ttlValue = ttl ?? this.options.ttl
 			await this.cache.set(sessionId, data, ttlValue)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to create session "${sessionId}"`,
-				'SESSION_CREATE_ERROR',
-				'session',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_CREATE_ERROR, {
+				adapter: 'session',
+				operation: 'create',
+				details: { sessionId },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -47,13 +48,13 @@ export class SessionStore {
 	async get(sessionId: string): Promise<SessionData | null> {
 		try {
 			return await this.cache.get(sessionId)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to get session "${sessionId}"`,
-				'SESSION_GET_ERROR',
-				'session',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_GET_ERROR, {
+				adapter: 'session',
+				operation: 'get',
+				details: { sessionId },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -65,24 +66,25 @@ export class SessionStore {
 			const current = await this.cache.get(sessionId)
 
 			if (!current) {
-				throw new CacheError(
-					`Session "${sessionId}" not found`,
-					'SESSION_NOT_FOUND',
-				)
+				throw new CacheError(CACHE_ERROR_CODES.SESSION_NOT_FOUND, {
+					adapter: 'session',
+					operation: 'update',
+					details: { sessionId },
+				})
 			}
 
 			const merged = { ...current, ...data }
 			await this.cache.set(sessionId, merged, this.options.ttl)
-		} catch (err) {
-			if (err instanceof CacheError) {
-				throw err
+		} catch (error) {
+			if (error instanceof CacheError) {
+				throw error
 			}
-			throw new CacheError(
-				`Failed to update session "${sessionId}"`,
-				'SESSION_UPDATE_ERROR',
-				'session',
-				err as Error,
-			)
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_UPDATE_ERROR, {
+				adapter: 'session',
+				operation: 'update',
+				details: { sessionId },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -92,13 +94,13 @@ export class SessionStore {
 	async delete(sessionId: string): Promise<boolean> {
 		try {
 			return await this.cache.delete(sessionId)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to delete session "${sessionId}"`,
-				'SESSION_DELETE_ERROR',
-				'session',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_DELETE_ERROR, {
+				adapter: 'session',
+				operation: 'delete',
+				details: { sessionId },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -108,13 +110,13 @@ export class SessionStore {
 	async exists(sessionId: string): Promise<boolean> {
 		try {
 			return await this.cache.exists(sessionId)
-		} catch (err) {
-			throw new CacheError(
-				`Failed to check session "${sessionId}" existence`,
-				'SESSION_EXISTS_ERROR',
-				'session',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_EXISTS_ERROR, {
+				adapter: 'session',
+				operation: 'exists',
+				details: { sessionId },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -124,13 +126,12 @@ export class SessionStore {
 	async clear(): Promise<void> {
 		try {
 			await this.cache.clear()
-		} catch (err) {
-			throw new CacheError(
-				'Failed to clear sessions',
-				'SESSION_CLEAR_ERROR',
-				'session',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_CLEAR_ERROR, {
+				adapter: 'session',
+				operation: 'clear',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -142,13 +143,12 @@ export class SessionStore {
 	): Promise<Record<string, SessionData | null>> {
 		try {
 			return await this.cache.getMultiple(sessionIds)
-		} catch (err) {
-			throw new CacheError(
-				'Failed to get multiple sessions',
-				'SESSION_GET_MULTIPLE_ERROR',
-				'session',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_GET_MULTIPLE_ERROR, {
+				adapter: 'session',
+				operation: 'getMultiple',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -158,13 +158,12 @@ export class SessionStore {
 	async deleteMultiple(sessionIds: string[]): Promise<number> {
 		try {
 			return await this.cache.deleteMultiple(sessionIds)
-		} catch (err) {
-			throw new CacheError(
-				'Failed to delete multiple sessions',
-				'SESSION_DELETE_MULTIPLE_ERROR',
-				'session',
-				err as Error,
-			)
+		} catch (error) {
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_DELETE_MULTIPLE_ERROR, {
+				adapter: 'session',
+				operation: 'deleteMultiple',
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -176,24 +175,25 @@ export class SessionStore {
 			const current = await this.cache.get(sessionId)
 
 			if (!current) {
-				throw new CacheError(
-					`Session "${sessionId}" not found`,
-					'SESSION_NOT_FOUND',
-				)
+				throw new CacheError(CACHE_ERROR_CODES.SESSION_NOT_FOUND, {
+					adapter: 'session',
+					operation: 'extend',
+					details: { sessionId },
+				})
 			}
 
 			const ttlValue = ttl ?? this.options.ttl
 			await this.cache.set(sessionId, current, ttlValue)
-		} catch (err) {
-			if (err instanceof CacheError) {
-				throw err
+		} catch (error) {
+			if (error instanceof CacheError) {
+				throw error
 			}
-			throw new CacheError(
-				`Failed to extend session "${sessionId}"`,
-				'SESSION_EXTEND_ERROR',
-				'session',
-				err as Error,
-			)
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_EXTEND_ERROR, {
+				adapter: 'session',
+				operation: 'extend',
+				details: { sessionId },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 
@@ -212,16 +212,16 @@ export class SessionStore {
 			}
 
 			return data
-		} catch (err) {
-			if (err instanceof CacheError) {
-				throw err
+		} catch (error) {
+			if (error instanceof CacheError) {
+				throw error
 			}
-			throw new CacheError(
-				`Failed to get and extend session "${sessionId}"`,
-				'SESSION_GET_EXTEND_ERROR',
-				'session',
-				err as Error,
-			)
+			throw new CacheError(CACHE_ERROR_CODES.SESSION_GET_EXTEND_ERROR, {
+				adapter: 'session',
+				operation: 'getAndExtend',
+				details: { sessionId },
+				cause: error instanceof Error ? error : undefined,
+			})
 		}
 	}
 

package/packages/errors-utils/README.md

@@ -1,24 +1,20 @@
+```bash
 @naman_deep_singh/errors-utils
 
-Version: 1.3.1
+Version: 1.4.2
 
 A standardized, code-driven error handling system for TypeScript and Express applications, providing consistent error identity, responses, and middleware integration.
 
 🚀 Features
 
 ✅ Structured Error Classes — AppError, HTTPError, ValidationError, etc.
-
 ✅ Strongly-Typed Error Codes — Centralized error identity via constants
-
 ✅ Centralized Error Messages — One source of truth for user-facing messages
-
 ✅ Express Middleware — Error converter & global handler
-
 ✅ Response Integration — Works seamlessly with @naman_deep_singh/response-utils
-
 ✅ TypeScript First — Full type safety & IntelliSense
-
 ✅ Consistent API Responses — Unified error shape across services
+✅ Extendable Error Messages — Add or override messages at runtime
 
 📦 Installation
 npm install @naman_deep_singh/errors-utils
@@ -27,19 +23,17 @@ npm install @naman_deep_singh/errors-utils
 
 This package is code-driven, not message-driven.
 
-Errors are identified by stable error codes
-
-Messages are resolved internally via centralized mappings
-
-API contracts remain stable even if messages change
+Errors are identified by stable error codes.
 
-This ensures:
+Messages are resolved internally via centralized mappings.
 
-Consistency across microservices
+API contracts remain stable even if messages change.
 
-Safe refactoring
+Benefits:
 
-Better logging, tracing, and observability
+✅ Consistency across microservices
+✅ Safe refactoring
+✅ Better logging, tracing, and observability
 
 🔧 Usage
 Creating Errors (Recommended)
@@ -49,32 +43,29 @@ import {
   NotFoundError,
   ValidationError,
   InternalServerError,
-  ERROR_CODES,
 } from '@naman_deep_singh/errors-utils'
 
-throw new BadRequestError(ERROR_CODES.BAD_REQUEST)
+// Basic usage
+throw new BadRequestError()
 
-throw new UnauthorizedError(ERROR_CODES.UNAUTHORIZED)
+throw new UnauthorizedError()
 
-throw new NotFoundError(ERROR_CODES.NOT_FOUND)
+throw new NotFoundError()
 
-throw new ValidationError(ERROR_CODES.VALIDATION_FAILED, {
+// With additional details
+throw new ValidationError({
   fields: ['email', 'password'],
 })
 
-throw new InternalServerError(ERROR_CODES.INTERNAL_SERVER_ERROR)
+throw new InternalServerError()
 
 🧾 Error Codes & Messages
-
-The package exposes a strongly-typed error code system.
-
 import {
   ERROR_CODES,
   ERROR_MESSAGES,
   ErrorCode,
 } from '@naman_deep_singh/errors-utils'
 
-Exports
 
 ERROR_CODES — Canonical list of all supported error codes
 
@@ -85,24 +76,16 @@ ErrorCode — Union type of all valid error codes
 Why Error Codes?
 
 ✅ Consistent error identity across services
-
 ✅ Centralized message management
-
 ✅ Safer API contracts
-
 ✅ Improved logging & observability
 
 🌐 Express Middleware
-
-This package provides Express-specific middleware under the hood
-and exposes a clean public API.
-
 import express from 'express'
 import {
   errorConverter,
   expressErrorHandler,
   ValidationError,
-  ERROR_CODES,
 } from '@naman_deep_singh/errors-utils'
 
 const app = express()
@@ -115,25 +98,18 @@ app.use(expressErrorHandler)
 
 app.post('/users', (req, res) => {
   if (!req.body.email) {
-    throw new ValidationError(ERROR_CODES.VALIDATION_FAILED)
+    throw new ValidationError({
+      fields: ['email'],
+    })
   }
 })
 
-Middleware Responsibilities
-
-errorConverter
 
-Converts unknown errors into AppError
-
-Preserves known operational errors
-
-expressErrorHandler
-
-Sends standardized API responses
+Middleware Responsibilities
 
-Integrates with @naman_deep_singh/response-utils
+errorConverter — Converts unknown errors into AppError, preserves operational errors
 
-Hides internal errors in production
+expressErrorHandler — Sends standardized API responses and integrates with @naman_deep_singh/response-utils
 
 🔗 Integration
 With @naman_deep_singh/response-utils
@@ -148,17 +124,14 @@ import { createServer } from '@naman_deep_singh/server-utils'
 import { expressErrorHandler } from '@naman_deep_singh/errors-utils'
 
 const server = createServer('My API', '1.0.0')
-
 server.app.use(expressErrorHandler)
 
-🧠 Custom Errors
+🧠 Extending & Adding Error Messages
 
-You can safely extend existing errors:
+You can safely extend existing errors or add new codes/messages dynamically.
 
-import {
-  InternalServerError,
-  ERROR_CODES,
-} from '@naman_deep_singh/errors-utils'
+Extending Existing Error Class
+import { InternalServerError, ERROR_CODES } from '@naman_deep_singh/errors-utils'
 
 export class CryptoIntegrityError extends InternalServerError {
   constructor(details?: unknown, cause?: Error) {
@@ -166,6 +139,28 @@ export class CryptoIntegrityError extends InternalServerError {
   }
 }
 
+Registering Custom Error Messages
+import { errorMessageRegistry } from '@naman_deep_singh/errors-utils'
+
+// Add new messages or override existing ones
+errorMessageRegistry.register({
+  CUSTOM_ERROR: 'Something went wrong with custom logic',
+  VALIDATION_FAILED: 'Custom validation failed message',
+})
+
+
+After this, AppError or any derived class will use the updated messages automatically.
+
+import { AppError, ErrorCode } from '@naman_deep_singh/errors-utils'
+
+throw new AppError(
+  'CUSTOM_ERROR' as ErrorCode,
+  500,
+  {
+    reason: "Something went wrong with custom logic"
+  }
+)
+
 📚 Available Error Classes
 Class	Status Code	Use Case
 AppError	Custom	Base error class
@@ -179,9 +174,10 @@ NotFoundError	404	Resource not found
 ConflictError	409	Resource conflicts
 ValidationError	422	Validation errors
 RateLimitError	429	Rate limiting
-TooManyRequestsError	429	Alias of RateLimitError
 CryptoIntegrityError	500	Crypto validation failure
 InternalServerError	500	Server-side failures
+ServiceUnavailableError 500 Service not available
+
 🎯 Standard Error Response
 
 All errors resolve to a consistent response shape:
@@ -192,9 +188,10 @@ All errors resolve to a consistent response shape:
   "message": "Validation failed",
   "details": {
     "fields": ["email"]
-  }
+  },
 }
 
 📄 License
 
-ISC © Naman Deep Singh
+ISC © Naman Deep Singh
+```

package/packages/errors-utils/dist/cjs/constants/errorCodes.d.ts

@@ -1,32 +1,37 @@
 export declare const ERROR_CODES: {
     readonly BAD_REQUEST: "BAD_REQUEST";
+    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
     readonly UNAUTHORIZED: "UNAUTHORIZED";
     readonly FORBIDDEN: "FORBIDDEN";
     readonly NOT_FOUND: "NOT_FOUND";
     readonly CONFLICT: "CONFLICT";
-    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
-    readonly RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED";
-    readonly INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR";
-    readonly CRYPTO_INTEGRITY_ERROR: "CRYPTO_INTEGRITY_ERROR";
     readonly TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS";
-    readonly TOKEN_EXPIRED: "TOKEN_EXPIRED";
+    readonly INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+    readonly DEPENDENCY_FAILURE: "DEPENDENCY_FAILURE";
+    readonly HTTP_ERROR: "HTTP_ERROR";
+    readonly HTTP_TIMEOUT: "HTTP_TIMEOUT";
+    readonly UPSTREAM_SERVICE_ERROR: "UPSTREAM_SERVICE_ERROR";
+    readonly AUTH_FAILED: "AUTH_FAILED";
+    readonly TOKEN_MISSING: "TOKEN_MISSING";
     readonly TOKEN_INVALID: "TOKEN_INVALID";
-    readonly TOKEN_NOT_PROVIDED: "TOKEN_NOT_PROVIDED";
-    readonly TOKEN_NOT_FOUND: "TOKEN_NOT_FOUND";
-    readonly TOKEN_NOT_CREATED: "TOKEN_NOT_CREATED";
-    readonly TOKEN_NOT_UPDATED: "TOKEN_NOT_UPDATED";
-    readonly TOKEN_NOT_DELETED: "TOKEN_NOT_DELETED";
-    readonly TOKEN_NOT_VALIDATED: "TOKEN_NOT_VALIDATED";
-    readonly TOKEN_NOT_REFRESHED: "TOKEN_NOT_REFRESHED";
-    readonly TOKEN_NOT_REVOKED: "TOKEN_NOT_REVOKED";
-    readonly TOKEN_NOT_BLACKLISTED: "TOKEN_NOT_BLACKLISTED";
-    readonly TOKEN_NOT_WHITELISTED: "TOKEN_NOT_WHITELISTED";
-    readonly TOKEN_NOT_DECODED: "TOKEN_NOT_DECODED";
-    readonly TOKEN_NOT_ENCODED: "TOKEN_NOT_ENCODED";
-    readonly TOKEN_NOT_SIGNED: "TOKEN_NOT_SIGNED";
-    readonly TOKEN_NOT_VERIFIED: "TOKEN_NOT_VERIFIED";
-    readonly TOKEN_NOT_DECRYPTED: "TOKEN_NOT_DECRYPTED";
-    readonly TOKEN_NOT_ENCRYPTED: "TOKEN_NOT_ENCRYPTED";
-    readonly TOKEN_NOT_GENERATED: "TOKEN_NOT_GENERATED";
+    readonly TOKEN_EXPIRED: "TOKEN_EXPIRED";
+    readonly CRYPTO_ERROR: "CRYPTO_ERROR";
+    readonly CRYPTO_INTEGRITY_ERROR: "CRYPTO_INTEGRITY_ERROR";
+    readonly CACHE_ERROR: "CACHE_ERROR";
+    readonly CACHE_CONNECTION_FAILED: "CACHE_CONNECTION_FAILED";
+    readonly DATABASE_ERROR: "DATABASE_ERROR";
+    readonly DATABASE_CONNECTION_FAILED: "DATABASE_CONNECTION_FAILED";
+    readonly DATABASE_CONSTRAINT_VIOLATION: "DATABASE_CONSTRAINT_VIOLATION";
+    readonly MESSAGE_BROKER_ERROR: "MESSAGE_BROKER_ERROR";
+    readonly MESSAGE_PUBLISH_FAILED: "MESSAGE_PUBLISH_FAILED";
+    readonly FILE_ERROR: "FILE_ERROR";
+    readonly FILE_NOT_FOUND: "FILE_NOT_FOUND";
+    readonly FILE_UPLOAD_FAILED: "FILE_UPLOAD_FAILED";
+    readonly FILE_TOO_LARGE: "FILE_TOO_LARGE";
+    readonly CONFIG_ERROR: "CONFIG_ERROR";
+    readonly CONFIG_MISSING: "CONFIG_MISSING";
+    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+    readonly RESOURCE_EXHAUSTED: "RESOURCE_EXHAUSTED";
 };
-export type ErrorCode = keyof typeof ERROR_CODES;
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];