@naman_deep_singh/errors-utils 1.0.1 → 1.3.1

package/dist/cjs/error/TokenExpiredError.js

@@ -0,0 +1,12 @@
+"use strict";
+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 {
+    constructor(details, cause) {
+        super(constants_1.ERROR_CODES.TOKEN_EXPIRED, response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause);
+    }
+}
+exports.TokenExpiredError = TokenExpiredError;

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

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

package/dist/cjs/error/TokenMalformedError.js

@@ -0,0 +1,12 @@
+"use strict";
+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 {
+    constructor(details, cause) {
+        super(constants_1.ERROR_CODES.TOKEN_INVALID, response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause);
+    }
+}
+exports.TokenMalformedError = TokenMalformedError;

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

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

package/dist/cjs/error/TooManyRequestsError.js

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

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

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

package/dist/cjs/error/UnauthorizedError.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnauthorizedError = void 0;
+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(message = "Unauthorized", details) {
-        super(message, 401, details);
+    constructor(errorCodes = constants_1.ERROR_CODES.UNAUTHORIZED, status = response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause) {
+        super(errorCodes, status, details, cause);
     }
 }
 exports.UnauthorizedError = UnauthorizedError;

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

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

package/dist/cjs/error/ValidationError.js

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

package/dist/cjs/index.d.ts

@@ -1,10 +1,10 @@
-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 "./middleware/express";
+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 './middleware/express';

package/dist/cjs/middleware/express/errorConverter.d.ts

@@ -1,2 +1,2 @@
-import { Request, Response, NextFunction } from "express";
-export declare function errorConverter(err: any, req: Request, res: Response, next: NextFunction): void;
+import type { NextFunction, Request, Response } from 'express';
+export declare function errorConverter(err: unknown, _req: Request, _res: Response, next: NextFunction): void;

package/dist/cjs/middleware/express/errorConverter.js

@@ -1,11 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorConverter = errorConverter;
+const response_utils_1 = require("@naman_deep_singh/response-utils");
+const constants_1 = require("../../constants");
 const AppError_1 = require("../../error/AppError");
-function errorConverter(err, req, res, next) {
+function errorConverter(err, _req, _res, next) {
+    // 1. Already a known AppError → pass through
     if (err instanceof AppError_1.AppError) {
         return next(err);
     }
-    const convertedError = new AppError_1.AppError(err.message || "Internal Error", err.statusCode || 500, err.details || undefined);
+    let code = constants_1.ERROR_CODES.INTERNAL_SERVER_ERROR;
+    let statusCode = response_utils_1.HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR;
+    let details = undefined;
+    let cause = undefined;
+    // 2. Handle unknown objects safely
+    if (typeof err === 'object' && err !== null) {
+        const e = err;
+        if (typeof e.code === 'string' && e.code in constants_1.ERROR_CODES) {
+            code = e.code;
+        }
+        if (typeof e.statusCode === 'number') {
+            statusCode = e.statusCode;
+        }
+        if ('details' in e) {
+            details = e.details;
+        }
+        if (err instanceof Error) {
+            cause = err;
+        }
+    }
+    // 3. Handle string errors
+    if (typeof err === 'string') {
+        details = err;
+    }
+    // 4. Convert to AppError
+    const convertedError = new AppError_1.AppError(code, statusCode, details, cause);
     next(convertedError);
 }

package/dist/cjs/middleware/express/errorHandler.d.ts

@@ -1,2 +1,2 @@
-import type { Request, Response, NextFunction } from "express";
-export declare function expressErrorHandler(err: unknown, req: Request, res: Response, next: NextFunction): any;
+import type { NextFunction, Request, Response } from 'express';
+export declare function expressErrorHandler(err: unknown, _req: Request, res: Response, _next: NextFunction): any;

package/dist/cjs/middleware/express/errorHandler.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expressErrorHandler = expressErrorHandler;
-const AppError_1 = require("../../error/AppError");
 const response_utils_1 = require("@naman_deep_singh/response-utils");
+const constants_1 = require("../../constants");
+const AppError_1 = require("../../error/AppError");
 const mapAppErrorToResponder_1 = require("../../utils/mapAppErrorToResponder");
-function expressErrorHandler(err, req, res, next) {
+function expressErrorHandler(err, _req, res, _next) {
     const responder = new response_utils_1.ExpressResponder({}, res);
-    // AppError → known operational error
+    // 1. Known operational error
     if (err instanceof AppError_1.AppError) {
         return (0, mapAppErrorToResponder_1.mapAppErrorToResponder)(responder, err);
     }
-    // Unexpected / programming / unknown error
-    console.error("UNEXPECTED ERROR:", err);
-    return responder.serverError("Internal server error", {
-        details: process.env.NODE_ENV === "production" ? undefined : 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);
 }

package/dist/cjs/utils/mapAppErrorToResponder.d.ts

@@ -1,3 +1,3 @@
-import { ExpressResponder } from "@naman_deep_singh/response-utils";
-import { AppError } from "src/error/AppError";
-export declare function mapAppErrorToResponder(responder: ExpressResponder<any>, err: AppError): any;
+import type { ExpressResponder } from '@naman_deep_singh/response-utils';
+import type { AppError } from 'src/error/AppError';
+export declare function mapAppErrorToResponder(responder: ExpressResponder<unknown>, err: AppError): any;

package/dist/cjs/utils/mapAppErrorToResponder.js

@@ -15,7 +15,9 @@ function mapAppErrorToResponder(responder, err) {
         case response_utils_1.HTTP_STATUS.CLIENT_ERROR.CONFLICT:
             return responder.conflict(err.message);
         case response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNPROCESSABLE_ENTITY:
-            return responder.unprocessableEntity(err.message, { details: err.details });
+            return responder.unprocessableEntity(err.message, {
+                details: err.details,
+            });
         case response_utils_1.HTTP_STATUS.CLIENT_ERROR.TOO_MANY_REQUESTS:
             return responder.tooManyRequests(err.message);
         default:

package/dist/esm/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/esm/constants/errorCodes.js

@@ -0,0 +1,31 @@
+export const 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/esm/constants/errorMessages.d.ts

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

package/dist/esm/constants/errorMessages.js

@@ -0,0 +1,31 @@
+export const 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/esm/constants/index.d.ts

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

package/dist/esm/constants/index.js

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

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

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

@@ -1,9 +1,22 @@
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_MESSAGES } from '../constants';
 export class AppError extends Error {
-    constructor(message, statusCode = 500, details) {
-        super(message);
+    constructor(code, statusCode = HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR, details, cause) {
+        super(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,
+        };
+    }
 }

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

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

package/dist/esm/error/BadRequestError.js

@@ -1,6 +1,8 @@
-import { HTTPError } from "./HTTPError";
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from '../constants';
+import { HTTPError } from './HTTPError';
 export class BadRequestError extends HTTPError {
-    constructor(message = "Bad Request", details) {
-        super(message, 400, details);
+    constructor(details, cause) {
+        super(ERROR_CODES.BAD_REQUEST, HTTP_STATUS.CLIENT_ERROR.BAD_REQUEST, details, cause);
     }
 }

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

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

package/dist/esm/error/ConflictError.js

@@ -1,6 +1,8 @@
-import { HTTPError } from "./HTTPError";
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from 'src/constants';
+import { HTTPError } from './HTTPError';
 export class ConflictError extends HTTPError {
-    constructor(message = "Conflict", details) {
-        super(message, 409, details);
+    constructor(details, cause) {
+        super(ERROR_CODES.CONFLICT, HTTP_STATUS.CLIENT_ERROR.CONFLICT, details, cause);
     }
 }

package/dist/esm/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/esm/error/CryptoIntegrityError.js

@@ -0,0 +1,7 @@
+import { ERROR_CODES } from 'src/constants';
+import { InternalServerError } from './InternalServerError';
+export class CryptoIntegrityError extends InternalServerError {
+    constructor(details, cause) {
+        super(ERROR_CODES.CRYPTO_INTEGRITY_ERROR, details, cause);
+    }
+}

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

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

package/dist/esm/error/ForbiddenError.js

@@ -1,6 +1,8 @@
-import { HTTPError } from "./HTTPError";
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from 'src/constants';
+import { HTTPError } from './HTTPError';
 export class ForbiddenError extends HTTPError {
-    constructor(message = "Forbidden", details) {
-        super(message, 403, details);
+    constructor(details, cause) {
+        super(ERROR_CODES.FORBIDDEN, HTTP_STATUS.CLIENT_ERROR.FORBIDDEN, details, cause);
     }
 }

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

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

package/dist/esm/error/HTTPError.js

@@ -1,7 +1,7 @@
-import { AppError } from "./AppError";
+import { AppError } from './AppError';
 export class HTTPError extends 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';
     }
 }

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

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

package/dist/esm/error/InternalServerError.js

@@ -1,6 +1,8 @@
-import { HTTPError } from "./HTTPError";
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from 'src/constants';
+import { HTTPError } from './HTTPError';
 export class InternalServerError extends HTTPError {
-    constructor(message = "Internal Server Error", details) {
-        super(message, 500, details);
+    constructor(errorCode = ERROR_CODES.INTERNAL_SERVER_ERROR, details, cause) {
+        super(errorCode, HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR, details, cause);
     }
 }

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

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

package/dist/esm/error/NotFoundError.js

@@ -1,6 +1,8 @@
-import { HTTPError } from "./HTTPError";
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from 'src/constants';
+import { HTTPError } from './HTTPError';
 export class NotFoundError extends HTTPError {
-    constructor(message = "Not Found", details) {
-        super(message, 404, details);
+    constructor(details, cause) {
+        super(ERROR_CODES.NOT_FOUND, HTTP_STATUS.CLIENT_ERROR.NOT_FOUND, details, cause);
     }
 }

package/dist/esm/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/esm/error/RateLimitError.js

@@ -0,0 +1,7 @@
+import { ERROR_CODES } from 'src/constants';
+import { TooManyRequestsError } from './TooManyRequestsError';
+export class RateLimitError extends TooManyRequestsError {
+    constructor(details, cause) {
+        super(ERROR_CODES.RATE_LIMIT_EXCEEDED, details, cause);
+    }
+}

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

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

package/dist/esm/error/TokenExpiredError.js

@@ -0,0 +1,8 @@
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from 'src/constants';
+import { UnauthorizedError } from './UnauthorizedError';
+export class TokenExpiredError extends UnauthorizedError {
+    constructor(details, cause) {
+        super(ERROR_CODES.TOKEN_EXPIRED, HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause);
+    }
+}

package/dist/esm/error/TokenMalformedError.d.ts

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

package/dist/esm/error/TokenMalformedError.js

@@ -0,0 +1,8 @@
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from 'src/constants';
+import { UnauthorizedError } from './UnauthorizedError';
+export class TokenMalformedError extends UnauthorizedError {
+    constructor(details, cause) {
+        super(ERROR_CODES.TOKEN_INVALID, HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause);
+    }
+}

package/dist/esm/error/TooManyRequestsError.d.ts

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

package/dist/esm/error/TooManyRequestsError.js

@@ -0,0 +1,8 @@
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from 'src/constants';
+import { HTTPError } from './HTTPError';
+export class TooManyRequestsError extends HTTPError {
+    constructor(errorCode = ERROR_CODES.TOO_MANY_REQUESTS, details, cause) {
+        super(errorCode, HTTP_STATUS.CLIENT_ERROR.TOO_MANY_REQUESTS, details, cause);
+    }
+}

package/dist/esm/error/UnauthorizedError.d.ts

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

package/dist/esm/error/UnauthorizedError.js

@@ -1,6 +1,8 @@
-import { HTTPError } from "./HTTPError";
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+import { ERROR_CODES } from 'src/constants';
+import { HTTPError } from './HTTPError';
 export class UnauthorizedError extends HTTPError {
-    constructor(message = "Unauthorized", details) {
-        super(message, 401, details);
+    constructor(errorCodes = ERROR_CODES.UNAUTHORIZED, status = HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, details, cause) {
+        super(errorCodes, status, details, cause);
     }
 }