ts-packages 2.0.0 → 3.0.0

package/packages/errors-utils/dist/cjs/constants/errorCodes.js

@@ -2,33 +2,68 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ERROR_CODES = void 0;
 exports.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',
-    INTERNAL_SERVER_ERROR: 'INTERNAL_SERVER_ERROR',
-    CRYPTO_INTEGRITY_ERROR: 'CRYPTO_INTEGRITY_ERROR',
     TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
-    TOKEN_EXPIRED: 'TOKEN_EXPIRED',
+    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_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',
+    TOKEN_EXPIRED: 'TOKEN_EXPIRED',
+    /* ------------------------------------------------------------------ */
+    /* 🔑 Cryptography / Security                                          */
+    /* ------------------------------------------------------------------ */
+    CRYPTO_ERROR: 'CRYPTO_ERROR',
+    CRYPTO_INTEGRITY_ERROR: 'CRYPTO_INTEGRITY_ERROR',
+    /* ------------------------------------------------------------------ */
+    /* 💾 Cache                                                             */
+    /* ------------------------------------------------------------------ */
+    CACHE_ERROR: 'CACHE_ERROR',
+    CACHE_CONNECTION_FAILED: 'CACHE_CONNECTION_FAILED',
+    /* ------------------------------------------------------------------ */
+    /* 🗄️ 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',
 };

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

@@ -1,2 +1,9 @@
-import type { ErrorCode } from './errorCodes';
+import { 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 declare const ERROR_MESSAGES: Record<ErrorCode, string>;

package/packages/errors-utils/dist/cjs/constants/errorMessages.js

@@ -1,34 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ERROR_MESSAGES = void 0;
+const errorCodes_1 = require("./errorCodes");
+/**
+ * Canonical error messages mapped to ERROR_CODES
+ * - Human-readable
+ * - Safe for API responses
+ * - Useful for logs
+ * - Can be overridden by services if needed
+ */
 exports.ERROR_MESSAGES = {
-    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                                                  */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.BAD_REQUEST]: 'The request is invalid or malformed.',
+    [errorCodes_1.ERROR_CODES.VALIDATION_FAILED]: 'Request validation failed.',
+    [errorCodes_1.ERROR_CODES.UNAUTHORIZED]: 'Authentication is required.',
+    [errorCodes_1.ERROR_CODES.FORBIDDEN]: 'You do not have permission to perform this action.',
+    [errorCodes_1.ERROR_CODES.NOT_FOUND]: 'The requested resource was not found.',
+    [errorCodes_1.ERROR_CODES.CONFLICT]: 'The request could not be completed due to a conflict.',
+    [errorCodes_1.ERROR_CODES.TOO_MANY_REQUESTS]: 'Too many requests. Please try again later.',
+    [errorCodes_1.ERROR_CODES.INTERNAL_SERVER_ERROR]: 'An unexpected internal error occurred.',
+    [errorCodes_1.ERROR_CODES.SERVICE_UNAVAILABLE]: 'The service is currently unavailable.',
+    [errorCodes_1.ERROR_CODES.DEPENDENCY_FAILURE]: 'A dependent service failed to respond.',
+    /* ------------------------------------------------------------------ */
+    /* 🌐 HTTP / Network                                                    */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.HTTP_ERROR]: 'An HTTP error occurred while processing the request.',
+    [errorCodes_1.ERROR_CODES.HTTP_TIMEOUT]: 'The request timed out.',
+    [errorCodes_1.ERROR_CODES.UPSTREAM_SERVICE_ERROR]: 'An upstream service returned an error.',
+    /* ------------------------------------------------------------------ */
+    /* 🔐 Authentication / Authorization                                   */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.AUTH_FAILED]: 'Authentication failed.',
+    [errorCodes_1.ERROR_CODES.TOKEN_MISSING]: 'Authentication token is missing.',
+    [errorCodes_1.ERROR_CODES.TOKEN_INVALID]: 'Authentication token is invalid.',
+    [errorCodes_1.ERROR_CODES.TOKEN_EXPIRED]: 'Authentication token has expired.',
+    /* ------------------------------------------------------------------ */
+    /* 🔑 Cryptography / Security                                          */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.CRYPTO_ERROR]: 'A cryptographic operation failed.',
+    [errorCodes_1.ERROR_CODES.CRYPTO_INTEGRITY_ERROR]: 'Data integrity verification failed.',
+    /* ------------------------------------------------------------------ */
+    /* 💾 Cache                                                             */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.CACHE_ERROR]: 'A cache operation failed.',
+    [errorCodes_1.ERROR_CODES.CACHE_CONNECTION_FAILED]: 'Failed to connect to the cache store.',
+    /* ------------------------------------------------------------------ */
+    /* 🗄️ Database                                                          */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.DATABASE_ERROR]: 'A database error occurred.',
+    [errorCodes_1.ERROR_CODES.DATABASE_CONNECTION_FAILED]: 'Failed to connect to the database.',
+    [errorCodes_1.ERROR_CODES.DATABASE_CONSTRAINT_VIOLATION]: 'The operation violates a database constraint.',
+    /* ------------------------------------------------------------------ */
+    /* 📩 Messaging / Queues                                                */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.MESSAGE_BROKER_ERROR]: 'A message broker error occurred.',
+    [errorCodes_1.ERROR_CODES.MESSAGE_PUBLISH_FAILED]: 'Failed to publish message to the message broker.',
+    /* ------------------------------------------------------------------ */
+    /* 📁 File / Storage                                                    */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.FILE_ERROR]: 'A file operation failed.',
+    [errorCodes_1.ERROR_CODES.FILE_NOT_FOUND]: 'The requested file was not found.',
+    [errorCodes_1.ERROR_CODES.FILE_UPLOAD_FAILED]: 'File upload failed.',
+    [errorCodes_1.ERROR_CODES.FILE_TOO_LARGE]: 'The uploaded file exceeds the allowed size.',
+    /* ------------------------------------------------------------------ */
+    /* ⚙️ Configuration / Environment                                      */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.CONFIG_ERROR]: 'Configuration error detected.',
+    [errorCodes_1.ERROR_CODES.CONFIG_MISSING]: 'Required configuration is missing.',
+    /* ------------------------------------------------------------------ */
+    /* ⏱️ Timeouts / Resources                                              */
+    /* ------------------------------------------------------------------ */
+    [errorCodes_1.ERROR_CODES.TIMEOUT_ERROR]: 'The operation timed out.',
+    [errorCodes_1.ERROR_CODES.RESOURCE_EXHAUSTED]: 'The system has exhausted required resources.',
 };

package/packages/errors-utils/dist/cjs/error/AppError.d.ts

@@ -1,4 +1,4 @@
-import { type ErrorCode } from '../constants';
+import type { ErrorCode } from '../constants';
 export declare class AppError extends Error {
     statusCode: number;
     isOperational: boolean;
@@ -8,7 +8,7 @@ export declare class AppError extends Error {
     constructor(code: ErrorCode, statusCode?: number, details?: unknown, cause?: Error);
     toJSON(): {
         success: boolean;
-        code: "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "CONFLICT" | "VALIDATION_FAILED" | "RATE_LIMIT_EXCEEDED" | "INTERNAL_SERVER_ERROR" | "CRYPTO_INTEGRITY_ERROR" | "TOO_MANY_REQUESTS" | "TOKEN_EXPIRED" | "TOKEN_INVALID" | "TOKEN_NOT_PROVIDED" | "TOKEN_NOT_FOUND" | "TOKEN_NOT_CREATED" | "TOKEN_NOT_UPDATED" | "TOKEN_NOT_DELETED" | "TOKEN_NOT_VALIDATED" | "TOKEN_NOT_REFRESHED" | "TOKEN_NOT_REVOKED" | "TOKEN_NOT_BLACKLISTED" | "TOKEN_NOT_WHITELISTED" | "TOKEN_NOT_DECODED" | "TOKEN_NOT_ENCODED" | "TOKEN_NOT_SIGNED" | "TOKEN_NOT_VERIFIED" | "TOKEN_NOT_DECRYPTED" | "TOKEN_NOT_ENCRYPTED" | "TOKEN_NOT_GENERATED";
+        code: ErrorCode;
         message: string;
         details: {} | null;
     };

package/packages/errors-utils/dist/cjs/error/AppError.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppError = void 0;
 const response_utils_1 = require("@naman_deep_singh/response-utils");
-const constants_1 = require("../constants");
+const src_1 = require("src");
 class AppError extends Error {
     constructor(code, statusCode = response_utils_1.HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR, details, cause) {
-        super(constants_1.ERROR_MESSAGES[code]); // message comes from mapping
+        super(src_1.errorMessageRegistry.resolve(code)); // message comes from mapping
         this.code = code;
         this.statusCode = statusCode;
         this.isOperational = true;

package/packages/errors-utils/dist/cjs/error/ServiceUnavailableError.d.ts

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

package/packages/errors-utils/dist/cjs/error/ServiceUnavailableError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceUnavailableError = void 0;
+const constants_1 = require("src/constants");
+const InternalServerError_1 = require("./InternalServerError");
+class ServiceUnavailableError extends InternalServerError_1.InternalServerError {
+    constructor(details, cause) {
+        super(constants_1.ERROR_CODES.SERVICE_UNAVAILABLE, details, cause);
+    }
+}
+exports.ServiceUnavailableError = ServiceUnavailableError;

package/packages/errors-utils/dist/cjs/error/TokenExpiredError.d.ts

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

package/packages/errors-utils/dist/cjs/error/TokenExpiredError.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenExpiredError = void 0;
 const response_utils_1 = require("@naman_deep_singh/response-utils");
 const constants_1 = require("src/constants");
-const UnauthorizedError_1 = require("./UnauthorizedError");
-class TokenExpiredError extends UnauthorizedError_1.UnauthorizedError {
+const HTTPError_1 = require("./HTTPError");
+class TokenExpiredError extends HTTPError_1.HTTPError {
     constructor(details, cause) {
         super(constants_1.ERROR_CODES.TOKEN_EXPIRED, response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause);
     }

package/packages/errors-utils/dist/cjs/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/cjs/error/TokenMalformedError.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenMalformedError = void 0;
 const response_utils_1 = require("@naman_deep_singh/response-utils");
 const constants_1 = require("src/constants");
-const UnauthorizedError_1 = require("./UnauthorizedError");
-class TokenMalformedError extends UnauthorizedError_1.UnauthorizedError {
+const HTTPError_1 = require("./HTTPError");
+class TokenMalformedError extends HTTPError_1.HTTPError {
     constructor(details, cause) {
         super(constants_1.ERROR_CODES.TOKEN_INVALID, response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause);
     }

package/packages/errors-utils/dist/cjs/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/cjs/error/UnauthorizedError.js

@@ -5,8 +5,8 @@ const response_utils_1 = require("@naman_deep_singh/response-utils");
 const constants_1 = require("src/constants");
 const HTTPError_1 = require("./HTTPError");
 class UnauthorizedError extends HTTPError_1.HTTPError {
-    constructor(errorCodes = constants_1.ERROR_CODES.UNAUTHORIZED, status = response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause) {
-        super(errorCodes, status, details, cause);
+    constructor(details, cause) {
+        super(constants_1.ERROR_CODES.UNAUTHORIZED, response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause);
     }
 }
 exports.UnauthorizedError = UnauthorizedError;

package/packages/errors-utils/dist/cjs/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/cjs/error/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AppError"), exports);
+__exportStar(require("./HTTPError"), exports);
+// =========================
+// 4xx Client Errors
+// =========================
+__exportStar(require("./BadRequestError"), exports);
+__exportStar(require("./UnauthorizedError"), exports);
+__exportStar(require("./ForbiddenError"), exports);
+__exportStar(require("./NotFoundError"), exports);
+__exportStar(require("./ConflictError"), exports);
+__exportStar(require("./ValidationError"), exports);
+__exportStar(require("./TooManyRequestsError"), exports);
+// =========================
+// Auth / Token Errors
+// =========================
+__exportStar(require("./TokenExpiredError"), exports);
+__exportStar(require("./TokenMalformedError"), exports);
+// =========================
+// 5xx Server Errors
+// =========================
+__exportStar(require("./InternalServerError"), exports);
+__exportStar(require("./CryptoIntegrityError"), exports);
+__exportStar(require("./ServiceUnavailableError"), exports);

package/packages/errors-utils/dist/cjs/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/cjs/errorRegistry/errorRegistry.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorMessageRegistry = void 0;
+const response_utils_1 = require("@naman_deep_singh/response-utils");
+const constants_1 = require("src/constants");
+class ErrorMessageRegistry {
+    constructor() {
+        this.registry = new Map();
+        // Initialize with default messages
+        Object.entries(constants_1.ERROR_MESSAGES).forEach(([code, message]) => {
+            this.registry.set(code, message);
+        });
+    }
+    /** Singleton accessor */
+    static getInstance() {
+        if (!ErrorMessageRegistry.instance) {
+            ErrorMessageRegistry.instance = new ErrorMessageRegistry();
+        }
+        return ErrorMessageRegistry.instance;
+    }
+    /** Register or override messages */
+    register(messages) {
+        for (const [code, message] of Object.entries(messages)) {
+            this.registry.set(code, message);
+        }
+    }
+    /** Resolve a message for a given error code */
+    resolve(code, defaultMessage = 'Unexpected error') {
+        return this.registry.get(code) ?? defaultMessage;
+    }
+    /**
+     * Map an AppError to an ExpressResponder
+     * Centralizes error-to-HTTP mapping
+     */
+    mapAppErrorToResponder(responder, err) {
+        switch (err.statusCode) {
+            case response_utils_1.HTTP_STATUS.CLIENT_ERROR.BAD_REQUEST:
+                return responder.badRequest(this.resolve(err.code), {
+                    details: err.details,
+                });
+            case response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED:
+                return responder.unauthorized(this.resolve(err.code));
+            case response_utils_1.HTTP_STATUS.CLIENT_ERROR.FORBIDDEN:
+                return responder.forbidden(this.resolve(err.code));
+            case response_utils_1.HTTP_STATUS.CLIENT_ERROR.NOT_FOUND:
+                return responder.notFound(this.resolve(err.code));
+            case response_utils_1.HTTP_STATUS.CLIENT_ERROR.CONFLICT:
+                return responder.conflict(this.resolve(err.code));
+            case response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNPROCESSABLE_ENTITY:
+                return responder.unprocessableEntity(this.resolve(err.code), {
+                    details: err.details,
+                });
+            case response_utils_1.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,
+                });
+        }
+    }
+}
+exports.ErrorMessageRegistry = ErrorMessageRegistry;

package/packages/errors-utils/dist/cjs/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/cjs/errorRegistry/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMessageRegistry = void 0;
+const errorRegistry_1 = require("./errorRegistry");
+/** Singleton export for easy access */
+exports.errorMessageRegistry = errorRegistry_1.ErrorMessageRegistry.getInstance();

package/packages/errors-utils/dist/cjs/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/cjs/index.js

@@ -14,13 +14,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./error/AppError"), exports);
-__exportStar(require("./error/HTTPError"), exports);
-__exportStar(require("./error/BadRequestError"), exports);
-__exportStar(require("./error/UnauthorizedError"), exports);
-__exportStar(require("./error/ForbiddenError"), exports);
-__exportStar(require("./error/NotFoundError"), exports);
-__exportStar(require("./error/ConflictError"), exports);
-__exportStar(require("./error/ValidationError"), exports);
-__exportStar(require("./error/InternalServerError"), exports);
+__exportStar(require("./errorRegistry"), exports);
+// =========================
+// default errors
+// =========================
+__exportStar(require("./error"), exports);
+// =========================
+// Constants
+// =========================
+__exportStar(require("./constants"), exports);
+// =========================
+// Express Middleware
+// =========================
 __exportStar(require("./middleware/express"), exports);

package/packages/errors-utils/dist/cjs/middleware/express/{errorHandler.js → errorHandler.middleware.js}

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expressErrorHandler = expressErrorHandler;
 const response_utils_1 = require("@naman_deep_singh/response-utils");
+const errorRegistry_1 = require("src/errorRegistry");
 const constants_1 = require("../../constants");
 const AppError_1 = require("../../error/AppError");
-const mapAppErrorToResponder_1 = require("../../utils/mapAppErrorToResponder");
 function expressErrorHandler(err, _req, res, _next) {
     const responder = new response_utils_1.ExpressResponder({}, res);
     // 1. Known operational error
     if (err instanceof AppError_1.AppError) {
-        return (0, mapAppErrorToResponder_1.mapAppErrorToResponder)(responder, err);
+        return errorRegistry_1.errorMessageRegistry.mapAppErrorToResponder(responder, err);
     }
     // 2. Log unexpected errors (never expose internals in prod)
     console.error('UNEXPECTED ERROR:', err);
     // 3. Normalize unknown error → AppError
-    const internalError = new AppError_1.AppError(constants_1.ERROR_CODES.INTERNAL_SERVER_ERROR, 500, process.env.NODE_ENV === 'production' ? undefined : err, err instanceof Error ? err : undefined);
-    return (0, mapAppErrorToResponder_1.mapAppErrorToResponder)(responder, internalError);
+    const internalError = new AppError_1.AppError(constants_1.ERROR_CODES.INTERNAL_SERVER_ERROR, response_utils_1.HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR, process.env.NODE_ENV === 'production' ? undefined : err, err instanceof Error ? err : undefined);
+    return errorRegistry_1.errorMessageRegistry.mapAppErrorToResponder(responder, internalError);
 }

package/packages/errors-utils/dist/cjs/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/dist/cjs/middleware/express/index.js

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./errorHandler"), exports);
-__exportStar(require("./errorConverter"), exports);
+__exportStar(require("./errorHandler.middleware"), exports);
+__exportStar(require("./errorConverter.middleware"), exports);

package/packages/errors-utils/dist/esm/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];