ts-packages 1.0.0 → 2.0.0

package/packages/cache/tsconfig.esm.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "rootDir": "./src",
+    "outDir": "./dist/esm"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/errors-utils/README.md

@@ -0,0 +1,200 @@
+@naman_deep_singh/errors-utils
+
+Version: 1.3.1
+
+A standardized, code-driven error handling system for TypeScript and Express applications, providing consistent error identity, responses, and middleware integration.
+
+🚀 Features
+
+✅ Structured Error Classes — AppError, HTTPError, ValidationError, etc.
+
+✅ Strongly-Typed Error Codes — Centralized error identity via constants
+
+✅ Centralized Error Messages — One source of truth for user-facing messages
+
+✅ Express Middleware — Error converter & global handler
+
+✅ Response Integration — Works seamlessly with @naman_deep_singh/response-utils
+
+✅ TypeScript First — Full type safety & IntelliSense
+
+✅ Consistent API Responses — Unified error shape across services
+
+📦 Installation
+npm install @naman_deep_singh/errors-utils
+
+🧠 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:
+
+Consistency across microservices
+
+Safe refactoring
+
+Better logging, tracing, and observability
+
+🔧 Usage
+Creating Errors (Recommended)
+import {
+  BadRequestError,
+  UnauthorizedError,
+  NotFoundError,
+  ValidationError,
+  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.
+
+import {
+  ERROR_CODES,
+  ERROR_MESSAGES,
+  ErrorCode,
+} from '@naman_deep_singh/errors-utils'
+
+Exports
+
+ERROR_CODES — Canonical list of all supported error codes
+
+ERROR_MESSAGES — Mapping of error codes → user-facing messages
+
+ErrorCode — Union type of all valid error codes
+
+Why Error Codes?
+
+✅ Consistent error identity across services
+
+✅ Centralized message management
+
+✅ Safer API contracts
+
+✅ Improved logging & observability
+
+🌐 Express Middleware
+
+This package provides Express-specific middleware under the hood
+and exposes a clean public API.
+
+import express from 'express'
+import {
+  errorConverter,
+  expressErrorHandler,
+  ValidationError,
+  ERROR_CODES,
+} from '@naman_deep_singh/errors-utils'
+
+const app = express()
+
+// Convert unknown / third-party errors → AppError
+app.use(errorConverter)
+
+// Handle all errors consistently
+app.use(expressErrorHandler)
+
+app.post('/users', (req, res) => {
+  if (!req.body.email) {
+    throw new ValidationError(ERROR_CODES.VALIDATION_FAILED)
+  }
+})
+
+Middleware Responsibilities
+
+errorConverter
+
+Converts unknown errors into AppError
+
+Preserves known operational errors
+
+expressErrorHandler
+
+Sends standardized API responses
+
+Integrates with @naman_deep_singh/response-utils
+
+Hides internal errors in production
+
+🔗 Integration
+With @naman_deep_singh/response-utils
+import { responderMiddleware } from '@naman_deep_singh/response-utils'
+import { expressErrorHandler } from '@naman_deep_singh/errors-utils'
+
+app.use(responderMiddleware())
+app.use(expressErrorHandler)
+
+With @naman_deep_singh/server-utils
+import { createServer } from '@naman_deep_singh/server-utils'
+import { expressErrorHandler } from '@naman_deep_singh/errors-utils'
+
+const server = createServer('My API', '1.0.0')
+
+server.app.use(expressErrorHandler)
+
+🧠 Custom Errors
+
+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:
+
+{
+  "success": false,
+  "code": "VALIDATION_FAILED",
+  "message": "Validation failed",
+  "details": {
+    "fields": ["email"]
+  }
+}
+
+📄 License
+
+ISC © Naman Deep Singh

package/packages/errors-utils/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/packages/errors-utils/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/packages/errors-utils/dist/cjs/constants/errorMessages.d.ts

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

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

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

package/packages/errors-utils/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/packages/errors-utils/dist/cjs/error/AppError.d.ts

@@ -0,0 +1,15 @@
+import { type ErrorCode } from '../constants';
+export declare class AppError extends Error {
+    statusCode: number;
+    isOperational: boolean;
+    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/packages/errors-utils/dist/cjs/error/AppError.js

@@ -0,0 +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(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/packages/errors-utils/dist/cjs/error/BadRequestError.d.ts

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

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

@@ -0,0 +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(details, cause) {
+        super(constants_1.ERROR_CODES.BAD_REQUEST, response_utils_1.HTTP_STATUS.CLIENT_ERROR.BAD_REQUEST, details, cause);
+    }
+}
+exports.BadRequestError = BadRequestError;

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

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

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

@@ -0,0 +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(details, cause) {
+        super(constants_1.ERROR_CODES.CONFLICT, response_utils_1.HTTP_STATUS.CLIENT_ERROR.CONFLICT, details, cause);
+    }
+}
+exports.ConflictError = ConflictError;

package/packages/errors-utils/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/packages/errors-utils/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/packages/errors-utils/dist/cjs/error/ForbiddenError.d.ts

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

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

@@ -0,0 +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(details, cause) {
+        super(constants_1.ERROR_CODES.FORBIDDEN, response_utils_1.HTTP_STATUS.CLIENT_ERROR.FORBIDDEN, details, cause);
+    }
+}
+exports.ForbiddenError = ForbiddenError;

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

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

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

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

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

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

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

@@ -0,0 +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(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/packages/errors-utils/dist/cjs/error/NotFoundError.d.ts

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

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

@@ -0,0 +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(details, cause) {
+        super(constants_1.ERROR_CODES.NOT_FOUND, response_utils_1.HTTP_STATUS.CLIENT_ERROR.NOT_FOUND, details, cause);
+    }
+}
+exports.NotFoundError = NotFoundError;

package/packages/errors-utils/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/packages/errors-utils/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/packages/errors-utils/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);
+}

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

@@ -0,0 +1,5 @@
+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);
+}

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

@@ -0,0 +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(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/packages/errors-utils/dist/cjs/error/ValidationError.d.ts

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

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

@@ -0,0 +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(details, cause) {
+        super(constants_1.ERROR_CODES.VALIDATION_FAILED, response_utils_1.HTTP_STATUS.CLIENT_ERROR.UNPROCESSABLE_ENTITY, details, cause);
+    }
+}
+exports.ValidationError = ValidationError;