@naman_deep_singh/errors-utils 1.1.1 → 1.3.1

package/README.md

@@ -1,125 +1,200 @@
-# @naman_deep_singh/errors-utils
+@naman_deep_singh/errors-utils
 
-**Version:** 1.1.1
+Version: 1.3.1
 
-Standardized error classes and Express middleware for consistent error handling with TypeScript.
+A standardized, code-driven error handling system for TypeScript and Express applications, providing consistent error identity, responses, and middleware integration.
 
-## 🚀 Features
+🚀 Features
 
-- ✅ **Structured Error Classes** - AppError, HTTPError, ValidationError, etc.
-- ✅ **Express Middleware** - Error converter and handler
-- ✅ **Response Integration** - Works with @naman_deep_singh/response-utils
-- ✅ **TypeScript Support** - Full type safety
-- ✅ **Consistent Responses** - Standardized error format across your API
+✅ Structured Error Classes — AppError, HTTPError, ValidationError, etc.
 
-## 📦 Installation
+✅ Strongly-Typed Error Codes — Centralized error identity via constants
 
-```bash
+✅ 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
+
+📦 Installation
 npm install @naman_deep_singh/errors-utils
-```
 
-## 🔧 Usage
+🧠 Design Philosophy
+
+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
+
+This ensures:
 
-### Error Classes
+Consistency across microservices
 
-```typescript
-import { 
-  AppError, 
-  BadRequestError, 
-  UnauthorizedError, 
+Safe refactoring
+
+Better logging, tracing, and observability
+
+🔧 Usage
+Creating Errors (Recommended)
+import {
+  BadRequestError,
+  UnauthorizedError,
   NotFoundError,
   ValidationError,
-  InternalServerError 
-} from '@naman_deep_singh/errors-utils';
+  InternalServerError,
+  ERROR_CODES,
+} from '@naman_deep_singh/errors-utils'
+
+throw new BadRequestError(ERROR_CODES.BAD_REQUEST)
+
+throw new UnauthorizedError(ERROR_CODES.UNAUTHORIZED)
+
+throw new NotFoundError(ERROR_CODES.NOT_FOUND)
+
+throw new ValidationError(ERROR_CODES.VALIDATION_FAILED, {
+  fields: ['email', 'password'],
+})
+
+throw new InternalServerError(ERROR_CODES.INTERNAL_SERVER_ERROR)
+
+🧾 Error Codes & Messages
+
+The package exposes a strongly-typed error code system.
 
-// Basic usage
-throw new BadRequestError('Invalid input data');
-throw new UnauthorizedError('Authentication required');
-throw new NotFoundError('User not found');
-throw new ValidationError('Email is required');
+import {
+  ERROR_CODES,
+  ERROR_MESSAGES,
+  ErrorCode,
+} from '@naman_deep_singh/errors-utils'
 
-// With details
-throw new BadRequestError('Validation failed', {
-  fields: ['email', 'password']
-});
-```
+Exports
 
-### Express Middleware
+ERROR_CODES — Canonical list of all supported error codes
 
-```typescript
-import express from 'express';
-import { expressErrorHandler, errorConverter } from '@naman_deep_singh/errors-utils';
+ERROR_MESSAGES — Mapping of error codes → user-facing messages
 
-const app = express();
+ErrorCode — Union type of all valid error codes
 
-// Convert unknown errors to AppError
-app.use(errorConverter);
+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()
+
+// Convert unknown / third-party errors → AppError
+app.use(errorConverter)
 
 // Handle all errors consistently
-app.use(expressErrorHandler);
+app.use(expressErrorHandler)
 
-// In your routes
 app.post('/users', (req, res) => {
   if (!req.body.email) {
-    throw new BadRequestError('Email is required');
+    throw new ValidationError(ERROR_CODES.VALIDATION_FAILED)
   }
-  // Error will be caught and formatted automatically
-});
-```
+})
 
-## 🔗 Integration
+Middleware Responsibilities
 
-### With @naman_deep_singh/server-utils
+errorConverter
 
-```typescript
-import { createServer } from '@naman_deep_singh/server-utils';
-import { expressErrorHandler } from '@naman_deep_singh/errors-utils';
+Converts unknown errors into AppError
 
-const server = createServer('My API', '1.0.0');
+Preserves known operational errors
 
-// Replace basic error handler with advanced one
-server.app.use(expressErrorHandler);
-```
+expressErrorHandler
 
-### With @naman_deep_singh/response-utils
+Sends standardized API responses
 
-```typescript
-import { responderMiddleware } from '@naman_deep_singh/response-utils';
+Integrates with @naman_deep_singh/response-utils
 
-server.app.use(responderMiddleware());
-server.app.use(expressErrorHandler); // Uses response-utils for consistent format
-```
+Hides internal errors in production
 
-## 📚 Error Classes
+🔗 Integration
+With @naman_deep_singh/response-utils
+import { responderMiddleware } from '@naman_deep_singh/response-utils'
+import { expressErrorHandler } from '@naman_deep_singh/errors-utils'
 
-| Class | Status Code | Use Case |
-|-------|-------------|----------|
-| `AppError` | Custom | Base error class |
-| `BadRequestError` | 400 | Invalid input data |
-| `UnauthorizedError` | 401 | Authentication failures |
-| `ForbiddenError` | 403 | Authorization failures |
-| `NotFoundError` | 404 | Resource not found |
-| `ConflictError` | 409 | Resource conflicts |
-| `ValidationError` | 422 | Input validation errors |
-| `InternalServerError` | 500 | Server errors |
+app.use(responderMiddleware())
+app.use(expressErrorHandler)
 
-## 🎯 Response Format
+With @naman_deep_singh/server-utils
+import { createServer } from '@naman_deep_singh/server-utils'
+import { expressErrorHandler } from '@naman_deep_singh/errors-utils'
 
-All errors produce consistent responses:
+const server = createServer('My API', '1.0.0')
+
+server.app.use(expressErrorHandler)
+
+🧠 Custom Errors
+
+You can safely extend existing errors:
+
+import {
+  InternalServerError,
+  ERROR_CODES,
+} from '@naman_deep_singh/errors-utils'
+
+export class CryptoIntegrityError extends InternalServerError {
+  constructor(details?: unknown, cause?: Error) {
+    super(ERROR_CODES.CRYPTO_INTEGRITY_ERROR, details, cause)
+  }
+}
+
+📚 Available Error Classes
+Class	Status Code	Use Case
+AppError	Custom	Base error class
+HTTPError	4xx / 5xx	Base HTTP error
+BadRequestError	400	Invalid input
+UnauthorizedError	401	Authentication failures
+TokenExpiredError	401	Expired tokens
+TokenMalformedError	401	Invalid token format
+ForbiddenError	403	Authorization failures
+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
+🎯 Standard Error Response
+
+All errors resolve to a consistent response shape:
 
-```json
 {
   "success": false,
-  "message": "Error message",
-  "data": undefined,
-  "error": {
-    "message": "Detailed error message",
-    "details": {...}
-  },
-  "meta": null
+  "code": "VALIDATION_FAILED",
+  "message": "Validation failed",
+  "details": {
+    "fields": ["email"]
+  }
 }
-```
 
-## 📄 License
+📄 License
 
 ISC © Naman Deep Singh

package/dist/cjs/constants/errorCodes.d.ts

@@ -0,0 +1,32 @@
+export declare const ERROR_CODES: {
+    readonly BAD_REQUEST: "BAD_REQUEST";
+    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 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";
+};
+export type ErrorCode = keyof typeof ERROR_CODES;

package/dist/cjs/constants/errorCodes.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_CODES = void 0;
+exports.ERROR_CODES = {
+    BAD_REQUEST: 'BAD_REQUEST',
+    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',
+    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',
+};

package/dist/cjs/constants/errorMessages.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorCode } from './errorCodes';
+export declare const ERROR_MESSAGES: Record<ErrorCode, string>;

package/dist/cjs/constants/errorMessages.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_MESSAGES = void 0;
+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',
+};

package/dist/cjs/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './errorCodes';
+export * from './errorMessages';

package/dist/cjs/constants/index.js

@@ -0,0 +1,18 @@
+"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("./errorCodes"), exports);
+__exportStar(require("./errorMessages"), exports);

package/dist/cjs/error/AppError.d.ts

@@ -1,6 +1,15 @@
+import { type ErrorCode } from '../constants';
 export declare class AppError extends Error {
     statusCode: number;
     isOperational: boolean;
+    code: ErrorCode;
     details?: unknown;
-    constructor(message: string, statusCode?: number, details?: unknown);
+    cause?: 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";
+        message: string;
+        details: {} | null;
+    };
 }

package/dist/cjs/error/AppError.js

@@ -1,13 +1,26 @@
 "use strict";
 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");
 class AppError extends Error {
-    constructor(message, statusCode = 500, details) {
-        super(message);
+    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
+        this.code = code;
         this.statusCode = statusCode;
         this.isOperational = true;
         this.details = details;
+        if (cause)
+            this.cause = cause;
         Error.captureStackTrace(this, this.constructor);
     }
+    toJSON() {
+        return {
+            success: false,
+            code: this.code,
+            message: this.message,
+            details: this.details ?? null,
+        };
+    }
 }
 exports.AppError = AppError;

package/dist/cjs/error/BadRequestError.d.ts

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

package/dist/cjs/error/BadRequestError.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BadRequestError = void 0;
+const response_utils_1 = require("@naman_deep_singh/response-utils");
+const constants_1 = require("../constants");
 const HTTPError_1 = require("./HTTPError");
 class BadRequestError extends HTTPError_1.HTTPError {
-    constructor(message = 'Bad Request', details) {
-        super(message, 400, details);
+    constructor(details, cause) {
+        super(constants_1.ERROR_CODES.BAD_REQUEST, response_utils_1.HTTP_STATUS.CLIENT_ERROR.BAD_REQUEST, details, cause);
     }
 }
 exports.BadRequestError = BadRequestError;

package/dist/cjs/error/ConflictError.d.ts

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

package/dist/cjs/error/ConflictError.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConflictError = void 0;
+const response_utils_1 = require("@naman_deep_singh/response-utils");
+const constants_1 = require("src/constants");
 const HTTPError_1 = require("./HTTPError");
 class ConflictError extends HTTPError_1.HTTPError {
-    constructor(message = 'Conflict', details) {
-        super(message, 409, details);
+    constructor(details, cause) {
+        super(constants_1.ERROR_CODES.CONFLICT, response_utils_1.HTTP_STATUS.CLIENT_ERROR.CONFLICT, details, cause);
     }
 }
 exports.ConflictError = ConflictError;

package/dist/cjs/error/CryptoIntegrityError.d.ts

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

package/dist/cjs/error/CryptoIntegrityError.js

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

package/dist/cjs/error/ForbiddenError.d.ts

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

package/dist/cjs/error/ForbiddenError.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForbiddenError = void 0;
+const response_utils_1 = require("@naman_deep_singh/response-utils");
+const constants_1 = require("src/constants");
 const HTTPError_1 = require("./HTTPError");
 class ForbiddenError extends HTTPError_1.HTTPError {
-    constructor(message = 'Forbidden', details) {
-        super(message, 403, details);
+    constructor(details, cause) {
+        super(constants_1.ERROR_CODES.FORBIDDEN, response_utils_1.HTTP_STATUS.CLIENT_ERROR.FORBIDDEN, details, cause);
     }
 }
 exports.ForbiddenError = ForbiddenError;

package/dist/cjs/error/HTTPError.d.ts

@@ -1,5 +1,6 @@
+import type { ErrorCode } from '../constants';
 import { AppError } from './AppError';
 export declare class HTTPError extends AppError {
-    status: string;
-    constructor(message: string, statusCode: number, details?: unknown);
+    status: 'fail' | 'error';
+    constructor(errorCode: ErrorCode, statusCode: number, details?: unknown, cause?: Error);
 }

package/dist/cjs/error/HTTPError.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HTTPError = void 0;
 const AppError_1 = require("./AppError");
 class HTTPError extends AppError_1.AppError {
-    constructor(message, statusCode, details) {
-        super(message, statusCode, details);
-        this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
+    constructor(errorCode, statusCode, details, cause) {
+        super(errorCode, statusCode, details, cause);
+        this.status = statusCode >= 400 && statusCode < 500 ? 'fail' : 'error';
     }
 }
 exports.HTTPError = HTTPError;

package/dist/cjs/error/InternalServerError.d.ts

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

package/dist/cjs/error/InternalServerError.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalServerError = void 0;
+const response_utils_1 = require("@naman_deep_singh/response-utils");
+const constants_1 = require("src/constants");
 const HTTPError_1 = require("./HTTPError");
 class InternalServerError extends HTTPError_1.HTTPError {
-    constructor(message = 'Internal Server Error', details) {
-        super(message, 500, details);
+    constructor(errorCode = constants_1.ERROR_CODES.INTERNAL_SERVER_ERROR, details, cause) {
+        super(errorCode, response_utils_1.HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR, details, cause);
     }
 }
 exports.InternalServerError = InternalServerError;

package/dist/cjs/error/NotFoundError.d.ts

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

package/dist/cjs/error/NotFoundError.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotFoundError = void 0;
+const response_utils_1 = require("@naman_deep_singh/response-utils");
+const constants_1 = require("src/constants");
 const HTTPError_1 = require("./HTTPError");
 class NotFoundError extends HTTPError_1.HTTPError {
-    constructor(message = 'Not Found', details) {
-        super(message, 404, details);
+    constructor(details, cause) {
+        super(constants_1.ERROR_CODES.NOT_FOUND, response_utils_1.HTTP_STATUS.CLIENT_ERROR.NOT_FOUND, details, cause);
     }
 }
 exports.NotFoundError = NotFoundError;

package/dist/cjs/error/RateLimitError.d.ts

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

package/dist/cjs/error/RateLimitError.js

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

package/dist/cjs/error/TokenExpiredError.d.ts

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