ts-packages 2.0.0 → 3.0.0

package/packages/errors-utils/dist/types/error/TokenMalformedError.d.ts

@@ -1,4 +1,4 @@
-import { UnauthorizedError } from './UnauthorizedError';
-export declare class TokenMalformedError extends UnauthorizedError {
+import { HTTPError } from './HTTPError';
+export declare class TokenMalformedError extends HTTPError {
     constructor(details?: unknown, cause?: Error);
 }

package/packages/errors-utils/dist/types/error/UnauthorizedError.d.ts

@@ -1,5 +1,4 @@
-import { type ErrorCode } from 'src/constants';
 import { HTTPError } from './HTTPError';
 export declare class UnauthorizedError extends HTTPError {
-    constructor(errorCodes?: ErrorCode, status?: number, details?: unknown, cause?: Error);
+    constructor(details?: unknown, cause?: Error);
 }

package/packages/errors-utils/dist/types/error/index.d.ts

@@ -0,0 +1,14 @@
+export * from './AppError';
+export * from './HTTPError';
+export * from './BadRequestError';
+export * from './UnauthorizedError';
+export * from './ForbiddenError';
+export * from './NotFoundError';
+export * from './ConflictError';
+export * from './ValidationError';
+export * from './TooManyRequestsError';
+export * from './TokenExpiredError';
+export * from './TokenMalformedError';
+export * from './InternalServerError';
+export * from './CryptoIntegrityError';
+export * from './ServiceUnavailableError';

package/packages/errors-utils/dist/types/errorRegistry/errorRegistry.d.ts

@@ -0,0 +1,19 @@
+import type { ExpressResponder } from '@naman_deep_singh/response-utils';
+import { type ErrorCode } from 'src/constants';
+import type { AppError } from 'src/error/AppError';
+export declare class ErrorMessageRegistry {
+    private static instance;
+    private readonly registry;
+    private constructor();
+    /** Singleton accessor */
+    static getInstance(): ErrorMessageRegistry;
+    /** Register or override messages */
+    register(messages: Record<string, string>): void;
+    /** Resolve a message for a given error code */
+    resolve(code: ErrorCode | string, defaultMessage?: string): string;
+    /**
+     * Map an AppError to an ExpressResponder
+     * Centralizes error-to-HTTP mapping
+     */
+    mapAppErrorToResponder(responder: ExpressResponder<unknown>, err: AppError): any;
+}

package/packages/errors-utils/dist/types/errorRegistry/index.d.ts

@@ -0,0 +1,3 @@
+import { ErrorMessageRegistry } from './errorRegistry';
+/** Singleton export for easy access */
+export declare const errorMessageRegistry: ErrorMessageRegistry;

package/packages/errors-utils/dist/types/index.d.ts

@@ -1,10 +1,4 @@
-export * from './error/AppError';
-export * from './error/HTTPError';
-export * from './error/BadRequestError';
-export * from './error/UnauthorizedError';
-export * from './error/ForbiddenError';
-export * from './error/NotFoundError';
-export * from './error/ConflictError';
-export * from './error/ValidationError';
-export * from './error/InternalServerError';
+export * from './errorRegistry';
+export * from './error';
+export * from './constants';
 export * from './middleware/express';

package/packages/errors-utils/dist/types/middleware/express/index.d.ts

@@ -1,2 +1,2 @@
-export * from './errorHandler';
-export * from './errorConverter';
+export * from './errorHandler.middleware';
+export * from './errorConverter.middleware';

package/packages/errors-utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@naman_deep_singh/errors-utils",
-    "version": "1.3.1",
+    "version": "1.4.2",
     "description": "Standardized error classes and Express middleware for consistent error handling with TypeScript",
     "type": "module",
     "main": "./dist/cjs/index.js",
@@ -33,10 +33,10 @@
         "@types/express": "^5.0.5",
         "@types/node": "^25.0.1",
         "express": "^5.1.0",
-        "typescript": "^5.9.3",
-        "rimraf": "^5.0.5"
+        "rimraf": "^5.0.5",
+        "typescript": "^5.9.3"
     },
     "dependencies": {
-        "@naman_deep_singh/response-utils": "^2.0.4"
+        "@naman_deep_singh/response-utils": "^2.1.4"
     }
 }

package/packages/errors-utils/src/constants/errorCodes.ts

@@ -1,37 +1,78 @@
 export const ERROR_CODES = {
+	/* ------------------------------------------------------------------ */
+	/* 🧱 Common / Generic                                                  */
+	/* ------------------------------------------------------------------ */
 	BAD_REQUEST: 'BAD_REQUEST',
+	VALIDATION_FAILED: 'VALIDATION_FAILED',
 	UNAUTHORIZED: 'UNAUTHORIZED',
 	FORBIDDEN: 'FORBIDDEN',
 	NOT_FOUND: 'NOT_FOUND',
 	CONFLICT: 'CONFLICT',
-	VALIDATION_FAILED: 'VALIDATION_FAILED',
-	RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
+	TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
 
 	INTERNAL_SERVER_ERROR: 'INTERNAL_SERVER_ERROR',
+	SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
+	DEPENDENCY_FAILURE: 'DEPENDENCY_FAILURE',
+
+	/* ------------------------------------------------------------------ */
+	/* 🌐 HTTP / Network                                                    */
+	/* ------------------------------------------------------------------ */
+	HTTP_ERROR: 'HTTP_ERROR',
+	HTTP_TIMEOUT: 'HTTP_TIMEOUT',
+	UPSTREAM_SERVICE_ERROR: 'UPSTREAM_SERVICE_ERROR',
+
+	/* ------------------------------------------------------------------ */
+	/* 🔐 Authentication / Authorization                                   */
+	/* ------------------------------------------------------------------ */
+	AUTH_FAILED: 'AUTH_FAILED',
+	TOKEN_MISSING: 'TOKEN_MISSING',
+	TOKEN_INVALID: 'TOKEN_INVALID',
+	TOKEN_EXPIRED: 'TOKEN_EXPIRED',
 
+	/* ------------------------------------------------------------------ */
+	/* 🔑 Cryptography / Security                                          */
+	/* ------------------------------------------------------------------ */
+	CRYPTO_ERROR: 'CRYPTO_ERROR',
 	CRYPTO_INTEGRITY_ERROR: 'CRYPTO_INTEGRITY_ERROR',
 
-	TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
+	/* ------------------------------------------------------------------ */
+	/* 💾 Cache                                                             */
+	/* ------------------------------------------------------------------ */
+	CACHE_ERROR: 'CACHE_ERROR',
+	CACHE_CONNECTION_FAILED: 'CACHE_CONNECTION_FAILED',
 
-	TOKEN_EXPIRED: 'TOKEN_EXPIRED',
-	TOKEN_INVALID: 'TOKEN_INVALID',
-	TOKEN_NOT_PROVIDED: 'TOKEN_NOT_PROVIDED',
-	TOKEN_NOT_FOUND: 'TOKEN_NOT_FOUND',
-	TOKEN_NOT_CREATED: 'TOKEN_NOT_CREATED',
-	TOKEN_NOT_UPDATED: 'TOKEN_NOT_UPDATED',
-	TOKEN_NOT_DELETED: 'TOKEN_NOT_DELETED',
-	TOKEN_NOT_VALIDATED: 'TOKEN_NOT_VALIDATED',
-	TOKEN_NOT_REFRESHED: 'TOKEN_NOT_REFRESHED',
-	TOKEN_NOT_REVOKED: 'TOKEN_NOT_REVOKED',
-	TOKEN_NOT_BLACKLISTED: 'TOKEN_NOT_BLACKLISTED',
-	TOKEN_NOT_WHITELISTED: 'TOKEN_NOT_WHITELISTED',
-	TOKEN_NOT_DECODED: 'TOKEN_NOT_DECODED',
-	TOKEN_NOT_ENCODED: 'TOKEN_NOT_ENCODED',
-	TOKEN_NOT_SIGNED: 'TOKEN_NOT_SIGNED',
-	TOKEN_NOT_VERIFIED: 'TOKEN_NOT_VERIFIED',
-	TOKEN_NOT_DECRYPTED: 'TOKEN_NOT_DECRYPTED',
-	TOKEN_NOT_ENCRYPTED: 'TOKEN_NOT_ENCRYPTED',
-	TOKEN_NOT_GENERATED: 'TOKEN_NOT_GENERATED',
+	/* ------------------------------------------------------------------ */
+	/* 🗄️ Database                                                          */
+	/* ------------------------------------------------------------------ */
+	DATABASE_ERROR: 'DATABASE_ERROR',
+	DATABASE_CONNECTION_FAILED: 'DATABASE_CONNECTION_FAILED',
+	DATABASE_CONSTRAINT_VIOLATION: 'DATABASE_CONSTRAINT_VIOLATION',
+
+	/* ------------------------------------------------------------------ */
+	/* 📩 Messaging / Queues                                                */
+	/* ------------------------------------------------------------------ */
+	MESSAGE_BROKER_ERROR: 'MESSAGE_BROKER_ERROR',
+	MESSAGE_PUBLISH_FAILED: 'MESSAGE_PUBLISH_FAILED',
+
+	/* ------------------------------------------------------------------ */
+	/* 📁 File / Storage                                                    */
+	/* ------------------------------------------------------------------ */
+	FILE_ERROR: 'FILE_ERROR',
+	FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+	FILE_UPLOAD_FAILED: 'FILE_UPLOAD_FAILED',
+	FILE_TOO_LARGE: 'FILE_TOO_LARGE',
+
+	/* ------------------------------------------------------------------ */
+	/* ⚙️ Configuration / Environment                                      */
+	/* ------------------------------------------------------------------ */
+	CONFIG_ERROR: 'CONFIG_ERROR',
+	CONFIG_MISSING: 'CONFIG_MISSING',
+
+	/* ------------------------------------------------------------------ */
+	/* ⏱️ Timeouts / Resources                                              */
+	/* ------------------------------------------------------------------ */
+	TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+	RESOURCE_EXHAUSTED: 'RESOURCE_EXHAUSTED',
 } as const
 
-export type ErrorCode = keyof typeof ERROR_CODES
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES]

package/packages/errors-utils/src/constants/errorMessages.ts

@@ -1,37 +1,94 @@
-import type { ErrorCode } from './errorCodes'
+import { ERROR_CODES, type ErrorCode } from './errorCodes'
+
+/**
+ * Canonical error messages mapped to ERROR_CODES
+ * - Human-readable
+ * - Safe for API responses
+ * - Useful for logs
+ * - Can be overridden by services if needed
+ */
 
 export const ERROR_MESSAGES: Record<ErrorCode, string> = {
-	BAD_REQUEST: 'Bad request',
-	UNAUTHORIZED: 'Unauthorized',
-	FORBIDDEN: 'Forbidden',
-	NOT_FOUND: 'Resource not found',
-	CONFLICT: 'Conflict occurred',
-	VALIDATION_FAILED: 'Validation failed',
-	RATE_LIMIT_EXCEEDED: 'Too many requests',
-
-	INTERNAL_SERVER_ERROR: 'Internal server error',
-
-	CRYPTO_INTEGRITY_ERROR: 'Crypto integrity error',
-
-	TOO_MANY_REQUESTS: 'Too many requests',
-
-	TOKEN_EXPIRED: 'Token expired',
-	TOKEN_INVALID: 'Invalid token',
-	TOKEN_NOT_PROVIDED: 'Token not provided',
-	TOKEN_NOT_FOUND: 'Token not found',
-	TOKEN_NOT_CREATED: 'Token not created',
-	TOKEN_NOT_UPDATED: 'Token not updated',
-	TOKEN_NOT_DELETED: 'Token not deleted',
-	TOKEN_NOT_VALIDATED: 'Token not validated',
-	TOKEN_NOT_REFRESHED: 'Token not refreshed',
-	TOKEN_NOT_REVOKED: 'Token not revoked',
-	TOKEN_NOT_BLACKLISTED: 'Token not blacklisted',
-	TOKEN_NOT_WHITELISTED: 'Token not whitelisted',
-	TOKEN_NOT_DECODED: 'Token not decoded',
-	TOKEN_NOT_ENCODED: 'Token not encoded',
-	TOKEN_NOT_SIGNED: 'Token not signed',
-	TOKEN_NOT_VERIFIED: 'Token not verified',
-	TOKEN_NOT_DECRYPTED: 'Token not decrypted',
-	TOKEN_NOT_ENCRYPTED: 'Token not encrypted',
-	TOKEN_NOT_GENERATED: 'Token not generated',
+	/* ------------------------------------------------------------------ */
+	/* 🧱 Common / Generic                                                  */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.BAD_REQUEST]: 'The request is invalid or malformed.',
+	[ERROR_CODES.VALIDATION_FAILED]: 'Request validation failed.',
+	[ERROR_CODES.UNAUTHORIZED]: 'Authentication is required.',
+	[ERROR_CODES.FORBIDDEN]: 'You do not have permission to perform this action.',
+	[ERROR_CODES.NOT_FOUND]: 'The requested resource was not found.',
+	[ERROR_CODES.CONFLICT]:
+		'The request could not be completed due to a conflict.',
+	[ERROR_CODES.TOO_MANY_REQUESTS]: 'Too many requests. Please try again later.',
+
+	[ERROR_CODES.INTERNAL_SERVER_ERROR]: 'An unexpected internal error occurred.',
+	[ERROR_CODES.SERVICE_UNAVAILABLE]: 'The service is currently unavailable.',
+	[ERROR_CODES.DEPENDENCY_FAILURE]: 'A dependent service failed to respond.',
+
+	/* ------------------------------------------------------------------ */
+	/* 🌐 HTTP / Network                                                    */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.HTTP_ERROR]:
+		'An HTTP error occurred while processing the request.',
+	[ERROR_CODES.HTTP_TIMEOUT]: 'The request timed out.',
+	[ERROR_CODES.UPSTREAM_SERVICE_ERROR]:
+		'An upstream service returned an error.',
+
+	/* ------------------------------------------------------------------ */
+	/* 🔐 Authentication / Authorization                                   */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.AUTH_FAILED]: 'Authentication failed.',
+	[ERROR_CODES.TOKEN_MISSING]: 'Authentication token is missing.',
+	[ERROR_CODES.TOKEN_INVALID]: 'Authentication token is invalid.',
+	[ERROR_CODES.TOKEN_EXPIRED]: 'Authentication token has expired.',
+
+	/* ------------------------------------------------------------------ */
+	/* 🔑 Cryptography / Security                                          */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.CRYPTO_ERROR]: 'A cryptographic operation failed.',
+	[ERROR_CODES.CRYPTO_INTEGRITY_ERROR]: 'Data integrity verification failed.',
+
+	/* ------------------------------------------------------------------ */
+	/* 💾 Cache                                                             */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.CACHE_ERROR]: 'A cache operation failed.',
+	[ERROR_CODES.CACHE_CONNECTION_FAILED]:
+		'Failed to connect to the cache store.',
+
+	/* ------------------------------------------------------------------ */
+	/* 🗄️ Database                                                          */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.DATABASE_ERROR]: 'A database error occurred.',
+	[ERROR_CODES.DATABASE_CONNECTION_FAILED]:
+		'Failed to connect to the database.',
+	[ERROR_CODES.DATABASE_CONSTRAINT_VIOLATION]:
+		'The operation violates a database constraint.',
+
+	/* ------------------------------------------------------------------ */
+	/* 📩 Messaging / Queues                                                */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.MESSAGE_BROKER_ERROR]: 'A message broker error occurred.',
+	[ERROR_CODES.MESSAGE_PUBLISH_FAILED]:
+		'Failed to publish message to the message broker.',
+
+	/* ------------------------------------------------------------------ */
+	/* 📁 File / Storage                                                    */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.FILE_ERROR]: 'A file operation failed.',
+	[ERROR_CODES.FILE_NOT_FOUND]: 'The requested file was not found.',
+	[ERROR_CODES.FILE_UPLOAD_FAILED]: 'File upload failed.',
+	[ERROR_CODES.FILE_TOO_LARGE]: 'The uploaded file exceeds the allowed size.',
+
+	/* ------------------------------------------------------------------ */
+	/* ⚙️ Configuration / Environment                                      */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.CONFIG_ERROR]: 'Configuration error detected.',
+	[ERROR_CODES.CONFIG_MISSING]: 'Required configuration is missing.',
+
+	/* ------------------------------------------------------------------ */
+	/* ⏱️ Timeouts / Resources                                              */
+	/* ------------------------------------------------------------------ */
+	[ERROR_CODES.TIMEOUT_ERROR]: 'The operation timed out.',
+	[ERROR_CODES.RESOURCE_EXHAUSTED]:
+		'The system has exhausted required resources.',
 }

package/packages/errors-utils/src/error/AppError.ts

@@ -1,5 +1,6 @@
 import { HTTP_STATUS } from '@naman_deep_singh/response-utils'
-import { ERROR_MESSAGES, type ErrorCode } from '../constants'
+import { errorMessageRegistry } from 'src'
+import type { ErrorCode } from '../constants'
 
 export class AppError extends Error {
 	public statusCode: number
@@ -14,7 +15,7 @@ export class AppError extends Error {
 		details?: unknown,
 		cause?: Error,
 	) {
-		super(ERROR_MESSAGES[code]) // message comes from mapping
+		super(errorMessageRegistry.resolve(code)) // message comes from mapping
 		this.code = code
 		this.statusCode = statusCode
 		this.isOperational = true

package/packages/errors-utils/src/error/ServiceUnavailableError.ts

@@ -0,0 +1,8 @@
+import { ERROR_CODES } from 'src/constants'
+import { InternalServerError } from './InternalServerError'
+
+export class ServiceUnavailableError extends InternalServerError {
+	constructor(details?: unknown, cause?: Error) {
+		super(ERROR_CODES.SERVICE_UNAVAILABLE, details, cause)
+	}
+}

package/packages/errors-utils/src/error/TokenExpiredError.ts

@@ -1,8 +1,8 @@
 import { HTTP_STATUS } from '@naman_deep_singh/response-utils'
 import { ERROR_CODES } from 'src/constants'
-import { UnauthorizedError } from './UnauthorizedError'
+import { HTTPError } from './HTTPError'
 
-export class TokenExpiredError extends UnauthorizedError {
+export class TokenExpiredError extends HTTPError {
 	constructor(details?: unknown, cause?: Error) {
 		super(
 			ERROR_CODES.TOKEN_EXPIRED,

package/packages/errors-utils/src/error/TokenMalformedError.ts

@@ -1,8 +1,8 @@
 import { HTTP_STATUS } from '@naman_deep_singh/response-utils'
 import { ERROR_CODES } from 'src/constants'
-import { UnauthorizedError } from './UnauthorizedError'
+import { HTTPError } from './HTTPError'
 
-export class TokenMalformedError extends UnauthorizedError {
+export class TokenMalformedError extends HTTPError {
 	constructor(details?: unknown, cause?: Error) {
 		super(
 			ERROR_CODES.TOKEN_INVALID,

package/packages/errors-utils/src/error/UnauthorizedError.ts

@@ -1,14 +1,14 @@
 import { HTTP_STATUS } from '@naman_deep_singh/response-utils'
-import { ERROR_CODES, type ErrorCode } from 'src/constants'
+import { ERROR_CODES } from 'src/constants'
 import { HTTPError } from './HTTPError'
 
 export class UnauthorizedError extends HTTPError {
-	constructor(
-		errorCodes: ErrorCode = ERROR_CODES.UNAUTHORIZED,
-		status: number = HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED,
-		details?: unknown,
-		cause?: Error,
-	) {
-		super(errorCodes, status, details, cause)
+	constructor(details?: unknown, cause?: Error) {
+		super(
+			ERROR_CODES.UNAUTHORIZED,
+			HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED,
+			details,
+			cause,
+		)
 	}
 }

package/packages/errors-utils/src/error/index.ts

@@ -0,0 +1,26 @@
+export * from './AppError'
+export * from './HTTPError'
+
+// =========================
+// 4xx Client Errors
+// =========================
+export * from './BadRequestError'
+export * from './UnauthorizedError'
+export * from './ForbiddenError'
+export * from './NotFoundError'
+export * from './ConflictError'
+export * from './ValidationError'
+export * from './TooManyRequestsError'
+
+// =========================
+// Auth / Token Errors
+// =========================
+export * from './TokenExpiredError'
+export * from './TokenMalformedError'
+
+// =========================
+// 5xx Server Errors
+// =========================
+export * from './InternalServerError'
+export * from './CryptoIntegrityError'
+export * from './ServiceUnavailableError'

package/packages/errors-utils/src/errorRegistry/errorRegistry.ts

@@ -0,0 +1,74 @@
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils'
+import type { ExpressResponder } from '@naman_deep_singh/response-utils'
+import { ERROR_MESSAGES, type ErrorCode } from 'src/constants'
+import type { AppError } from 'src/error/AppError'
+
+export class ErrorMessageRegistry {
+	private static instance: ErrorMessageRegistry
+	private readonly registry = new Map<ErrorCode | string, string>()
+
+	private constructor() {
+		// Initialize with default messages
+		Object.entries(ERROR_MESSAGES).forEach(([code, message]) => {
+			this.registry.set(code, message)
+		})
+	}
+
+	/** Singleton accessor */
+	public static getInstance(): ErrorMessageRegistry {
+		if (!ErrorMessageRegistry.instance) {
+			ErrorMessageRegistry.instance = new ErrorMessageRegistry()
+		}
+		return ErrorMessageRegistry.instance
+	}
+
+	/** Register or override messages */
+	public register(messages: Record<string, string>): void {
+		for (const [code, message] of Object.entries(messages)) {
+			this.registry.set(code, message)
+		}
+	}
+
+	/** Resolve a message for a given error code */
+	public resolve(
+		code: ErrorCode | string,
+		defaultMessage = 'Unexpected error',
+	): string {
+		return this.registry.get(code) ?? defaultMessage
+	}
+
+	/**
+	 * Map an AppError to an ExpressResponder
+	 * Centralizes error-to-HTTP mapping
+	 */
+	public mapAppErrorToResponder(
+		responder: ExpressResponder<unknown>,
+		err: AppError,
+	) {
+		switch (err.statusCode) {
+			case HTTP_STATUS.CLIENT_ERROR.BAD_REQUEST:
+				return responder.badRequest(this.resolve(err.code), {
+					details: err.details,
+				})
+			case HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED:
+				return responder.unauthorized(this.resolve(err.code))
+			case HTTP_STATUS.CLIENT_ERROR.FORBIDDEN:
+				return responder.forbidden(this.resolve(err.code))
+			case HTTP_STATUS.CLIENT_ERROR.NOT_FOUND:
+				return responder.notFound(this.resolve(err.code))
+			case HTTP_STATUS.CLIENT_ERROR.CONFLICT:
+				return responder.conflict(this.resolve(err.code))
+			case HTTP_STATUS.CLIENT_ERROR.UNPROCESSABLE_ENTITY:
+				return responder.unprocessableEntity(this.resolve(err.code), {
+					details: err.details,
+				})
+			case HTTP_STATUS.CLIENT_ERROR.TOO_MANY_REQUESTS:
+				return responder.tooManyRequests(this.resolve(err.code))
+			default:
+				// Any other status maps to generic server error
+				return responder.serverError(this.resolve(err.code), {
+					details: err.details,
+				})
+		}
+	}
+}

package/packages/errors-utils/src/errorRegistry/index.ts

@@ -0,0 +1,4 @@
+import { ErrorMessageRegistry } from './errorRegistry'
+
+/** Singleton export for easy access */
+export const errorMessageRegistry = ErrorMessageRegistry.getInstance()

package/packages/errors-utils/src/index.ts

@@ -1,11 +1,13 @@
-export * from './error/AppError'
-export * from './error/HTTPError'
-export * from './error/BadRequestError'
-export * from './error/UnauthorizedError'
-export * from './error/ForbiddenError'
-export * from './error/NotFoundError'
-export * from './error/ConflictError'
-export * from './error/ValidationError'
-export * from './error/InternalServerError'
-
+export * from './errorRegistry'
+// =========================
+// default errors
+// =========================
+export * from './error'
+// =========================
+// Constants
+// =========================
+export * from './constants'
+// =========================
+// Express Middleware
+// =========================
 export * from './middleware/express'

package/packages/errors-utils/src/middleware/express/{errorHandler.ts → errorHandler.middleware.ts}

@@ -1,8 +1,8 @@
-import { ExpressResponder } from '@naman_deep_singh/response-utils'
+import { ExpressResponder, HTTP_STATUS } from '@naman_deep_singh/response-utils'
 import type { NextFunction, Request, Response } from 'express'
+import { errorMessageRegistry } from 'src/errorRegistry'
 import { ERROR_CODES } from '../../constants'
 import { AppError } from '../../error/AppError'
-import { mapAppErrorToResponder } from '../../utils/mapAppErrorToResponder'
 
 export function expressErrorHandler(
 	err: unknown,
@@ -14,7 +14,7 @@ export function expressErrorHandler(
 
 	// 1. Known operational error
 	if (err instanceof AppError) {
-		return mapAppErrorToResponder(responder, err)
+		return errorMessageRegistry.mapAppErrorToResponder(responder, err)
 	}
 
 	// 2. Log unexpected errors (never expose internals in prod)
@@ -23,10 +23,10 @@ export function expressErrorHandler(
 	// 3. Normalize unknown error → AppError
 	const internalError = new AppError(
 		ERROR_CODES.INTERNAL_SERVER_ERROR,
-		500,
+		HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR,
 		process.env.NODE_ENV === 'production' ? undefined : err,
 		err instanceof Error ? err : undefined,
 	)
 
-	return mapAppErrorToResponder(responder, internalError)
+	return errorMessageRegistry.mapAppErrorToResponder(responder, internalError)
 }

package/packages/errors-utils/src/middleware/express/index.ts

@@ -1,2 +1,2 @@
-export * from './errorHandler'
-export * from './errorConverter'
+export * from './errorHandler.middleware'
+export * from './errorConverter.middleware'