@geekmidas/errors 0.0.1

package/dist/index.cjs

@@ -0,0 +1,586 @@
+
+//#region src/index.ts
+/**
+* Base HTTP Error class that extends the native Error.
+* Provides a foundation for all HTTP-specific errors with status codes and structured error responses.
+*
+* @extends Error
+*
+* @example
+* ```typescript
+* throw new HttpError(400, 'Bad Request', {
+*   details: { field: 'email', message: 'Invalid format' }
+* });
+* ```
+*/
+var HttpError = class extends Error {
+	/** The HTTP status code (e.g., 400, 404, 500) */
+	statusCode;
+	/** The standard HTTP status message (e.g., 'Bad Request', 'Not Found') */
+	statusMessage;
+	/** Type discriminator for runtime type checking */
+	isHttpError = true;
+	/** Additional error details for debugging or client information */
+	details;
+	/** Application-specific error code for client-side handling */
+	code;
+	/**
+	* Creates a new HttpError instance.
+	*
+	* @param statusCode - The HTTP status code
+	* @param message - Optional error message for the client
+	* @param options - Optional configuration object
+	* @param options.statusMessage - Override the default status message
+	* @param options.details - Additional error details or context
+	* @param options.code - Application-specific error code
+	* @param options.cause - The underlying error that caused this error (ES2022)
+	*/
+	constructor(statusCode, message, options) {
+		super(message || options?.statusMessage || "HTTP Error");
+		this.name = this.constructor.name;
+		this.statusCode = statusCode;
+		this.statusMessage = options?.statusMessage || this.getDefaultStatusMessage(statusCode);
+		this.details = options?.details;
+		this.code = options?.code;
+		if (options?.cause) this.cause = options.cause;
+		Error.captureStackTrace(this, this.constructor);
+	}
+	/**
+	* Gets the error response body as a JSON string.
+	* Used for sending the error response to clients.
+	*
+	* @returns JSON string containing message, code, and error details
+	*/
+	get body() {
+		return JSON.stringify({
+			message: this.message,
+			code: this.code,
+			error: this.details
+		});
+	}
+	/**
+	* Gets the default HTTP status message for a given status code.
+	*
+	* @param statusCode - The HTTP status code
+	* @returns The standard HTTP status message or 'Unknown Error' if not found
+	* @private
+	*/
+	getDefaultStatusMessage(statusCode) {
+		const statusMessages = {
+			400: "Bad Request",
+			401: "Unauthorized",
+			403: "Forbidden",
+			404: "Not Found",
+			405: "Method Not Allowed",
+			406: "Not Acceptable",
+			408: "Request Timeout",
+			409: "Conflict",
+			410: "Gone",
+			422: "Unprocessable Entity",
+			429: "Too Many Requests",
+			500: "Internal Server Error",
+			501: "Not Implemented",
+			502: "Bad Gateway",
+			503: "Service Unavailable",
+			504: "Gateway Timeout"
+		};
+		return statusMessages[statusCode] || "Unknown Error";
+	}
+	/**
+	* Serializes the error to a JSON-compatible object.
+	* Useful for logging and debugging purposes.
+	*
+	* @returns Object representation of the error including stack trace
+	*/
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			statusCode: this.statusCode,
+			statusMessage: this.statusMessage,
+			code: this.code,
+			details: this.details,
+			stack: this.stack
+		};
+	}
+};
+/**
+* Represents a 400 Bad Request error.
+* Used when the client sends a malformed or invalid request.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new BadRequestError('Invalid JSON', { line: 5, column: 12 });
+* ```
+*/
+var BadRequestError = class extends HttpError {
+	constructor(message, details) {
+		super(400, message, { details });
+	}
+};
+/**
+* Represents a 401 Unauthorized error.
+* Used when authentication is required but not provided or invalid.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new UnauthorizedError('Invalid token');
+* ```
+*/
+var UnauthorizedError = class extends HttpError {
+	constructor(message, details) {
+		super(401, message, { details });
+	}
+};
+/**
+* Represents a 403 Forbidden error.
+* Used when the client is authenticated but lacks permission for the resource.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new ForbiddenError('Insufficient permissions', { required: 'admin' });
+* ```
+*/
+var ForbiddenError = class extends HttpError {
+	constructor(message, details) {
+		super(403, message, { details });
+	}
+};
+/**
+* Represents a 404 Not Found error.
+* Used when the requested resource doesn't exist.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new NotFoundError('User not found', { userId: '123' });
+* ```
+*/
+var NotFoundError = class extends HttpError {
+	constructor(message, details) {
+		super(404, message, { details });
+	}
+};
+/**
+* Represents a 405 Method Not Allowed error.
+* Used when the HTTP method is not supported for the requested resource.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new MethodNotAllowedError('DELETE not supported', ['GET', 'POST', 'PUT']);
+* ```
+*/
+var MethodNotAllowedError = class extends HttpError {
+	/**
+	* @param message - Optional error message
+	* @param allowedMethods - Array of allowed HTTP methods for this resource
+	*/
+	constructor(message, allowedMethods) {
+		super(405, message, { details: allowedMethods ? { allowedMethods } : void 0 });
+	}
+};
+/**
+* Represents a 409 Conflict error.
+* Used when the request conflicts with the current state of the resource.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new ConflictError('Email already exists', { email: 'user@example.com' });
+* ```
+*/
+var ConflictError = class extends HttpError {
+	constructor(message, details) {
+		super(409, message, { details });
+	}
+};
+/**
+* Represents a 422 Unprocessable Entity error.
+* Used when the request is well-formed but contains semantic errors.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new UnprocessableEntityError('Validation failed', {
+*   email: 'Invalid format',
+*   age: 'Must be 18 or older'
+* });
+* ```
+*/
+var UnprocessableEntityError = class extends HttpError {
+	/**
+	* @param message - Optional error message
+	* @param validationErrors - Object containing field-specific validation errors
+	*/
+	constructor(message, validationErrors) {
+		super(422, message, { details: validationErrors ? { validationErrors } : void 0 });
+	}
+};
+/**
+* Represents a 429 Too Many Requests error.
+* Used when the client has exceeded rate limits.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new TooManyRequestsError('Rate limit exceeded', 60); // retry after 60 seconds
+* ```
+*/
+var TooManyRequestsError = class extends HttpError {
+	/**
+	* @param message - Optional error message
+	* @param retryAfter - Number of seconds the client should wait before retrying
+	*/
+	constructor(message, retryAfter) {
+		super(429, message, { details: retryAfter ? { retryAfter } : void 0 });
+	}
+};
+/**
+* Represents a 500 Internal Server Error.
+* Used for unexpected server-side errors.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new InternalServerError('Database connection failed');
+* ```
+*/
+var InternalServerError = class extends HttpError {
+	constructor(message, details) {
+		super(500, message, { details });
+	}
+};
+/**
+* Represents a 501 Not Implemented error.
+* Used when the server doesn't support the requested functionality.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new NotImplementedError('WebSocket support not implemented');
+* ```
+*/
+var NotImplementedError = class extends HttpError {
+	constructor(message, details) {
+		super(501, message, { details });
+	}
+};
+/**
+* Represents a 502 Bad Gateway error.
+* Used when the server receives an invalid response from an upstream server.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new BadGatewayError('Upstream server error');
+* ```
+*/
+var BadGatewayError = class extends HttpError {
+	constructor(message, details) {
+		super(502, message, { details });
+	}
+};
+/**
+* Represents a 503 Service Unavailable error.
+* Used when the server is temporarily unable to handle requests.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new ServiceUnavailableError('Maintenance in progress', 300); // retry after 5 minutes
+* ```
+*/
+var ServiceUnavailableError = class extends HttpError {
+	/**
+	* @param message - Optional error message
+	* @param retryAfter - Number of seconds the client should wait before retrying
+	*/
+	constructor(message, retryAfter) {
+		super(503, message, { details: retryAfter ? { retryAfter } : void 0 });
+	}
+};
+/**
+* Represents a 504 Gateway Timeout error.
+* Used when the server doesn't receive a timely response from an upstream server.
+*
+* @extends HttpError
+*
+* @example
+* ```typescript
+* throw new GatewayTimeoutError('Upstream server timeout');
+* ```
+*/
+var GatewayTimeoutError = class extends HttpError {
+	constructor(message, details) {
+		super(504, message, { details });
+	}
+};
+/** Type-safe error registry mapping status codes to their factory functions */
+const errorRegistry = {
+	400: {
+		type: "standard",
+		factory: (m, d) => new BadRequestError(m, d)
+	},
+	401: {
+		type: "standard",
+		factory: (m, d) => new UnauthorizedError(m, d)
+	},
+	403: {
+		type: "standard",
+		factory: (m, d) => new ForbiddenError(m, d)
+	},
+	404: {
+		type: "standard",
+		factory: (m, d) => new NotFoundError(m, d)
+	},
+	405: {
+		type: "methodNotAllowed",
+		factory: (m, am) => new MethodNotAllowedError(m, am)
+	},
+	409: {
+		type: "standard",
+		factory: (m, d) => new ConflictError(m, d)
+	},
+	422: {
+		type: "validation",
+		factory: (m, ve) => new UnprocessableEntityError(m, ve)
+	},
+	429: {
+		type: "retryAfter",
+		factory: (m, ra) => new TooManyRequestsError(m, ra)
+	},
+	500: {
+		type: "standard",
+		factory: (m, d) => new InternalServerError(m, d)
+	},
+	501: {
+		type: "standard",
+		factory: (m, d) => new NotImplementedError(m, d)
+	},
+	502: {
+		type: "standard",
+		factory: (m, d) => new BadGatewayError(m, d)
+	},
+	503: {
+		type: "retryAfter",
+		factory: (m, ra) => new ServiceUnavailableError(m, ra)
+	},
+	504: {
+		type: "standard",
+		factory: (m, d) => new GatewayTimeoutError(m, d)
+	}
+};
+/** Handler functions for each factory type */
+const factoryHandlers = {
+	standard: (entry, message, options) => entry.factory(message, options?.details),
+	methodNotAllowed: (entry, message, options) => entry.factory(message, options?.allowedMethods),
+	retryAfter: (entry, message, options) => entry.factory(message, options?.retryAfter),
+	validation: (entry, message, options) => entry.factory(message, options?.validationErrors)
+};
+function createHttpError(statusCode, message, options) {
+	const entry = errorRegistry[statusCode];
+	if (entry) {
+		const handler = factoryHandlers[entry.type];
+		return handler(entry, message, options);
+	}
+	return new HttpError(statusCode, message, options);
+}
+/**
+* Type-safe error creation utilities with descriptive method names.
+* Provides a fluent API for creating specific HTTP errors.
+*
+* @example
+* ```typescript
+* createError.notFound('User not found');
+* createError.badRequest('Invalid input', { field: 'email' });
+* createError.methodNotAllowed('DELETE not supported', ['GET', 'POST']);
+* ```
+*/
+const createError = {
+	badRequest: (message, details) => new BadRequestError(message, details),
+	unauthorized: (message, details) => new UnauthorizedError(message, details),
+	forbidden: (message, details) => new ForbiddenError(message, details),
+	notFound: (message, details) => new NotFoundError(message, details),
+	methodNotAllowed: (message, allowedMethods) => new MethodNotAllowedError(message, allowedMethods),
+	conflict: (message, details) => new ConflictError(message, details),
+	unprocessableEntity: (message, validationErrors) => new UnprocessableEntityError(message, validationErrors),
+	tooManyRequests: (message, retryAfter) => new TooManyRequestsError(message, retryAfter),
+	internalServerError: (message, details) => new InternalServerError(message, details),
+	notImplemented: (message, details) => new NotImplementedError(message, details),
+	badGateway: (message, details) => new BadGatewayError(message, details),
+	serviceUnavailable: (message, retryAfter) => new ServiceUnavailableError(message, retryAfter),
+	gatewayTimeout: (message, details) => new GatewayTimeoutError(message, details)
+};
+/**
+* Type guard to check if an error is an HttpError.
+* Works with both instanceof checks and duck typing.
+*
+* @param error - The error to check
+* @returns True if the error is an HttpError
+*
+* @example
+* ```typescript
+* try {
+*   // some code
+* } catch (error) {
+*   if (isHttpError(error)) {
+*     console.log(`HTTP ${error.statusCode}: ${error.message}`);
+*   }
+* }
+* ```
+*/
+function isHttpError(error) {
+	return error instanceof HttpError || error !== null && typeof error === "object" && "isHttpError" in error && error.isHttpError === true;
+}
+/**
+* Type guard to check if an error is a client error (4xx status code).
+*
+* @param error - The error to check
+* @returns True if the error is an HttpError with a 4xx status code
+*
+* @example
+* ```typescript
+* if (isClientError(error)) {
+*   // Log client error metrics
+* }
+* ```
+*/
+function isClientError(error) {
+	return isHttpError(error) && error.statusCode >= 400 && error.statusCode < 500;
+}
+/**
+* Type guard to check if an error is a server error (5xx status code).
+*
+* @param error - The error to check
+* @returns True if the error is an HttpError with a 5xx status code
+*
+* @example
+* ```typescript
+* if (isServerError(error)) {
+*   // Trigger alerts for server errors
+* }
+* ```
+*/
+function isServerError(error) {
+	return isHttpError(error) && error.statusCode >= 500 && error.statusCode < 600;
+}
+/**
+* Wraps an unknown error into an HttpError.
+* If the error is already an HttpError, returns it unchanged.
+*
+* @param error - The error to wrap
+* @param statusCode - The HTTP status code to use (defaults to 500)
+* @param message - Optional message to override the original error message
+* @returns An HttpError instance
+*
+* @example
+* ```typescript
+* try {
+*   await someOperation();
+* } catch (error) {
+*   throw wrapError(error, 503, 'Service temporarily unavailable');
+* }
+* ```
+*/
+function wrapError(error, statusCode = 500, message) {
+	if (isHttpError(error)) return error;
+	if (error instanceof HttpError) return error;
+	return new HttpError(statusCode, message || "An unknown error occurred", { details: { originalError: error } });
+}
+/**
+* HTTP status code enum for type-safe status code usage.
+* Includes common 2xx, 3xx, 4xx, and 5xx status codes.
+*/
+let HttpStatusCode = /* @__PURE__ */ function(HttpStatusCode$1) {
+	HttpStatusCode$1[HttpStatusCode$1["OK"] = 200] = "OK";
+	HttpStatusCode$1[HttpStatusCode$1["CREATED"] = 201] = "CREATED";
+	HttpStatusCode$1[HttpStatusCode$1["ACCEPTED"] = 202] = "ACCEPTED";
+	HttpStatusCode$1[HttpStatusCode$1["NO_CONTENT"] = 204] = "NO_CONTENT";
+	HttpStatusCode$1[HttpStatusCode$1["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+	HttpStatusCode$1[HttpStatusCode$1["FOUND"] = 302] = "FOUND";
+	HttpStatusCode$1[HttpStatusCode$1["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+	HttpStatusCode$1[HttpStatusCode$1["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+	HttpStatusCode$1[HttpStatusCode$1["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+	HttpStatusCode$1[HttpStatusCode$1["FORBIDDEN"] = 403] = "FORBIDDEN";
+	HttpStatusCode$1[HttpStatusCode$1["NOT_FOUND"] = 404] = "NOT_FOUND";
+	HttpStatusCode$1[HttpStatusCode$1["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+	HttpStatusCode$1[HttpStatusCode$1["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+	HttpStatusCode$1[HttpStatusCode$1["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+	HttpStatusCode$1[HttpStatusCode$1["CONFLICT"] = 409] = "CONFLICT";
+	HttpStatusCode$1[HttpStatusCode$1["GONE"] = 410] = "GONE";
+	HttpStatusCode$1[HttpStatusCode$1["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+	HttpStatusCode$1[HttpStatusCode$1["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+	HttpStatusCode$1[HttpStatusCode$1["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+	HttpStatusCode$1[HttpStatusCode$1["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+	HttpStatusCode$1[HttpStatusCode$1["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+	HttpStatusCode$1[HttpStatusCode$1["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+	HttpStatusCode$1[HttpStatusCode$1["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+	return HttpStatusCode$1;
+}({});
+/**
+* Namespace containing all HTTP error classes.
+* Useful for importing all error types at once.
+*
+* @example
+* ```typescript
+* import { HttpErrors } from '@geekmidas/errors';
+* throw new HttpErrors.NotFoundError('Resource not found');
+* ```
+*/
+const HttpErrors = {
+	HttpError,
+	BadRequestError,
+	UnauthorizedError,
+	ForbiddenError,
+	NotFoundError,
+	MethodNotAllowedError,
+	ConflictError,
+	UnprocessableEntityError,
+	TooManyRequestsError,
+	InternalServerError,
+	NotImplementedError,
+	BadGatewayError,
+	ServiceUnavailableError,
+	GatewayTimeoutError
+};
+
+//#endregion
+exports.BadGatewayError = BadGatewayError;
+exports.BadRequestError = BadRequestError;
+exports.ConflictError = ConflictError;
+exports.ForbiddenError = ForbiddenError;
+exports.GatewayTimeoutError = GatewayTimeoutError;
+exports.HttpError = HttpError;
+exports.HttpErrors = HttpErrors;
+exports.HttpStatusCode = HttpStatusCode;
+exports.InternalServerError = InternalServerError;
+exports.MethodNotAllowedError = MethodNotAllowedError;
+exports.NotFoundError = NotFoundError;
+exports.NotImplementedError = NotImplementedError;
+exports.ServiceUnavailableError = ServiceUnavailableError;
+exports.TooManyRequestsError = TooManyRequestsError;
+exports.UnauthorizedError = UnauthorizedError;
+exports.UnprocessableEntityError = UnprocessableEntityError;
+exports.createError = createError;
+exports.createHttpError = createHttpError;
+exports.isClientError = isClientError;
+exports.isHttpError = isHttpError;
+exports.isServerError = isServerError;
+exports.wrapError = wrapError;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["statusCode: number","message?: string","options?: {\n      statusMessage?: string;\n      details?: any;\n      code?: string;\n      cause?: Error;\n    }","statusMessages: Record<number, string>","details?: any","allowedMethods?: string[]","validationErrors?: any","retryAfter?: number","m: string","d: any","am: string[]","ve: any","ra: number","factoryHandlers: Record<\n  ErrorFactory['type'],\n  (entry: any, message?: string, options?: any) => HttpError\n>","options?: any","error: unknown"],"sources":["../src/index.ts"],"sourcesContent":["// http-errors.ts - Core HTTP Error Classes and Types\n\n/**\n * Base HTTP Error class that extends the native Error.\n * Provides a foundation for all HTTP-specific errors with status codes and structured error responses.\n *\n * @extends Error\n *\n * @example\n * ```typescript\n * throw new HttpError(400, 'Bad Request', {\n *   details: { field: 'email', message: 'Invalid format' }\n * });\n * ```\n */\nexport class HttpError extends Error {\n  /** The HTTP status code (e.g., 400, 404, 500) */\n  public readonly statusCode: number;\n  /** The standard HTTP status message (e.g., 'Bad Request', 'Not Found') */\n  public readonly statusMessage: string;\n  /** Type discriminator for runtime type checking */\n  public readonly isHttpError = true;\n  /** Additional error details for debugging or client information */\n  public readonly details?: any;\n  /** Application-specific error code for client-side handling */\n  public readonly code?: string;\n\n  /**\n   * Creates a new HttpError instance.\n   *\n   * @param statusCode - The HTTP status code\n   * @param message - Optional error message for the client\n   * @param options - Optional configuration object\n   * @param options.statusMessage - Override the default status message\n   * @param options.details - Additional error details or context\n   * @param options.code - Application-specific error code\n   * @param options.cause - The underlying error that caused this error (ES2022)\n   */\n  constructor(\n    statusCode: number,\n    message?: string,\n    options?: {\n      statusMessage?: string;\n      details?: any;\n      code?: string;\n      cause?: Error;\n    },\n  ) {\n    super(message || options?.statusMessage || 'HTTP Error');\n    this.name = this.constructor.name;\n    this.statusCode = statusCode;\n    this.statusMessage =\n      options?.statusMessage || this.getDefaultStatusMessage(statusCode);\n    this.details = options?.details;\n    this.code = options?.code;\n\n    // Set cause if provided (ES2022 feature)\n    if (options?.cause) {\n      this.cause = options.cause;\n    }\n    // @ts-ignore\n    // Maintains proper stack trace for where our error was thrown\n    Error.captureStackTrace(this, this.constructor);\n  }\n\n  /**\n   * Gets the error response body as a JSON string.\n   * Used for sending the error response to clients.\n   *\n   * @returns JSON string containing message, code, and error details\n   */\n  get body() {\n    return JSON.stringify({\n      message: this.message,\n      code: this.code,\n      error: this.details,\n    });\n  }\n\n  /**\n   * Gets the default HTTP status message for a given status code.\n   *\n   * @param statusCode - The HTTP status code\n   * @returns The standard HTTP status message or 'Unknown Error' if not found\n   * @private\n   */\n  private getDefaultStatusMessage(statusCode: number): string {\n    const statusMessages: Record<number, string> = {\n      400: 'Bad Request',\n      401: 'Unauthorized',\n      403: 'Forbidden',\n      404: 'Not Found',\n      405: 'Method Not Allowed',\n      406: 'Not Acceptable',\n      408: 'Request Timeout',\n      409: 'Conflict',\n      410: 'Gone',\n      422: 'Unprocessable Entity',\n      429: 'Too Many Requests',\n      500: 'Internal Server Error',\n      501: 'Not Implemented',\n      502: 'Bad Gateway',\n      503: 'Service Unavailable',\n      504: 'Gateway Timeout',\n    };\n    return statusMessages[statusCode] || 'Unknown Error';\n  }\n\n  /**\n   * Serializes the error to a JSON-compatible object.\n   * Useful for logging and debugging purposes.\n   *\n   * @returns Object representation of the error including stack trace\n   */\n  toJSON() {\n    return {\n      name: this.name,\n      message: this.message,\n      statusCode: this.statusCode,\n      statusMessage: this.statusMessage,\n      code: this.code,\n      details: this.details,\n      stack: this.stack,\n    };\n  }\n}\n\n// Client Error Classes (4xx)\n\n/**\n * Represents a 400 Bad Request error.\n * Used when the client sends a malformed or invalid request.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new BadRequestError('Invalid JSON', { line: 5, column: 12 });\n * ```\n */\nexport class BadRequestError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(400, message, { details });\n  }\n}\n\n/**\n * Represents a 401 Unauthorized error.\n * Used when authentication is required but not provided or invalid.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new UnauthorizedError('Invalid token');\n * ```\n */\nexport class UnauthorizedError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(401, message, { details });\n  }\n}\n\n/**\n * Represents a 403 Forbidden error.\n * Used when the client is authenticated but lacks permission for the resource.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new ForbiddenError('Insufficient permissions', { required: 'admin' });\n * ```\n */\nexport class ForbiddenError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(403, message, { details });\n  }\n}\n\n/**\n * Represents a 404 Not Found error.\n * Used when the requested resource doesn't exist.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new NotFoundError('User not found', { userId: '123' });\n * ```\n */\nexport class NotFoundError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(404, message, { details });\n  }\n}\n\n/**\n * Represents a 405 Method Not Allowed error.\n * Used when the HTTP method is not supported for the requested resource.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new MethodNotAllowedError('DELETE not supported', ['GET', 'POST', 'PUT']);\n * ```\n */\nexport class MethodNotAllowedError extends HttpError {\n  /**\n   * @param message - Optional error message\n   * @param allowedMethods - Array of allowed HTTP methods for this resource\n   */\n  constructor(message?: string, allowedMethods?: string[]) {\n    super(405, message, {\n      details: allowedMethods ? { allowedMethods } : undefined,\n    });\n  }\n}\n\n/**\n * Represents a 409 Conflict error.\n * Used when the request conflicts with the current state of the resource.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new ConflictError('Email already exists', { email: 'user@example.com' });\n * ```\n */\nexport class ConflictError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(409, message, { details });\n  }\n}\n\n/**\n * Represents a 422 Unprocessable Entity error.\n * Used when the request is well-formed but contains semantic errors.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new UnprocessableEntityError('Validation failed', {\n *   email: 'Invalid format',\n *   age: 'Must be 18 or older'\n * });\n * ```\n */\nexport class UnprocessableEntityError extends HttpError {\n  /**\n   * @param message - Optional error message\n   * @param validationErrors - Object containing field-specific validation errors\n   */\n  constructor(message?: string, validationErrors?: any) {\n    super(422, message, {\n      details: validationErrors ? { validationErrors } : undefined,\n    });\n  }\n}\n\n/**\n * Represents a 429 Too Many Requests error.\n * Used when the client has exceeded rate limits.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new TooManyRequestsError('Rate limit exceeded', 60); // retry after 60 seconds\n * ```\n */\nexport class TooManyRequestsError extends HttpError {\n  /**\n   * @param message - Optional error message\n   * @param retryAfter - Number of seconds the client should wait before retrying\n   */\n  constructor(message?: string, retryAfter?: number) {\n    super(429, message, {\n      details: retryAfter ? { retryAfter } : undefined,\n    });\n  }\n}\n\n// Server Error Classes (5xx)\n\n/**\n * Represents a 500 Internal Server Error.\n * Used for unexpected server-side errors.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new InternalServerError('Database connection failed');\n * ```\n */\nexport class InternalServerError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(500, message, { details });\n  }\n}\n\n/**\n * Represents a 501 Not Implemented error.\n * Used when the server doesn't support the requested functionality.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new NotImplementedError('WebSocket support not implemented');\n * ```\n */\nexport class NotImplementedError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(501, message, { details });\n  }\n}\n\n/**\n * Represents a 502 Bad Gateway error.\n * Used when the server receives an invalid response from an upstream server.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new BadGatewayError('Upstream server error');\n * ```\n */\nexport class BadGatewayError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(502, message, { details });\n  }\n}\n\n/**\n * Represents a 503 Service Unavailable error.\n * Used when the server is temporarily unable to handle requests.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new ServiceUnavailableError('Maintenance in progress', 300); // retry after 5 minutes\n * ```\n */\nexport class ServiceUnavailableError extends HttpError {\n  /**\n   * @param message - Optional error message\n   * @param retryAfter - Number of seconds the client should wait before retrying\n   */\n  constructor(message?: string, retryAfter?: number) {\n    super(503, message, {\n      details: retryAfter ? { retryAfter } : undefined,\n    });\n  }\n}\n\n/**\n * Represents a 504 Gateway Timeout error.\n * Used when the server doesn't receive a timely response from an upstream server.\n *\n * @extends HttpError\n *\n * @example\n * ```typescript\n * throw new GatewayTimeoutError('Upstream server timeout');\n * ```\n */\nexport class GatewayTimeoutError extends HttpError {\n  constructor(message?: string, details?: any) {\n    super(504, message, { details });\n  }\n}\n\n// Type definitions for different error factory signatures\n\n/** Factory function for standard HTTP errors with optional details */\ntype StandardErrorFactory = (message?: string, details?: any) => HttpError;\n/** Factory function for Method Not Allowed errors with allowed methods */\ntype MethodNotAllowedFactory = (\n  message?: string,\n  allowedMethods?: string[],\n) => MethodNotAllowedError;\n/** Factory function for errors that include retry-after information */\ntype RetryAfterFactory = (message?: string, retryAfter?: number) => HttpError;\n/** Factory function for validation errors with field-specific errors */\ntype ValidationErrorFactory = (\n  message?: string,\n  validationErrors?: any,\n) => UnprocessableEntityError;\n\n/** Discriminated union for all factory types */\ntype ErrorFactory =\n  | { type: 'standard'; factory: StandardErrorFactory }\n  | { type: 'methodNotAllowed'; factory: MethodNotAllowedFactory }\n  | { type: 'retryAfter'; factory: RetryAfterFactory }\n  | { type: 'validation'; factory: ValidationErrorFactory };\n\n/** Type-safe error registry mapping status codes to their factory functions */\nconst errorRegistry = {\n  400: {\n    type: 'standard',\n    factory: (m: string, d: any) => new BadRequestError(m, d),\n  },\n  401: {\n    type: 'standard',\n    factory: (m: string, d: any) => new UnauthorizedError(m, d),\n  },\n  403: {\n    type: 'standard',\n    factory: (m: string, d: any) => new ForbiddenError(m, d),\n  },\n  404: {\n    type: 'standard',\n    factory: (m: string, d: any) => new NotFoundError(m, d),\n  },\n  405: {\n    type: 'methodNotAllowed',\n    factory: (m: string, am: string[]) => new MethodNotAllowedError(m, am),\n  },\n  409: {\n    type: 'standard',\n    factory: (m: string, d: any) => new ConflictError(m, d),\n  },\n  422: {\n    type: 'validation',\n    factory: (m: string, ve: any) => new UnprocessableEntityError(m, ve),\n  },\n  429: {\n    type: 'retryAfter',\n    factory: (m: string, ra: number) => new TooManyRequestsError(m, ra),\n  },\n  500: {\n    type: 'standard',\n    factory: (m: string, d: any) => new InternalServerError(m, d),\n  },\n  501: {\n    type: 'standard',\n    factory: (m: string, d: any) => new NotImplementedError(m, d),\n  },\n  502: {\n    type: 'standard',\n    factory: (m: string, d: any) => new BadGatewayError(m, d),\n  },\n  503: {\n    type: 'retryAfter',\n    factory: (m: string, ra: number) => new ServiceUnavailableError(m, ra),\n  },\n  504: {\n    type: 'standard',\n    factory: (m: string, d: any) => new GatewayTimeoutError(m, d),\n  },\n} as const;\n\n/** Valid status codes that have registered error factories */\ntype ValidStatusCode = keyof typeof errorRegistry;\n\n/** Type-safe options based on status code, ensuring correct parameters for each error type */\ntype ErrorOptions<T extends number> = T extends 405\n  ? { allowedMethods?: string[]; code?: string; cause?: Error }\n  : T extends 422\n    ? { validationErrors?: any; code?: string; cause?: Error }\n    : T extends 429 | 503\n      ? { retryAfter?: number; code?: string; cause?: Error }\n      : { details?: any; code?: string; cause?: Error };\n\n/** Handler functions for each factory type */\nconst factoryHandlers: Record<\n  ErrorFactory['type'],\n  (entry: any, message?: string, options?: any) => HttpError\n> = {\n  standard: (entry, message, options) =>\n    entry.factory(message, options?.details),\n  methodNotAllowed: (entry, message, options) =>\n    entry.factory(message, options?.allowedMethods),\n  retryAfter: (entry, message, options) =>\n    entry.factory(message, options?.retryAfter),\n  validation: (entry, message, options) =>\n    entry.factory(message, options?.validationErrors),\n};\n\n/**\n * Creates an HTTP error with type-safe options based on the status code.\n * Provides IntelliSense support for status-code-specific options.\n *\n * @overload For known status codes with specific options\n * @param statusCode - A valid HTTP status code from the registry\n * @param message - Optional error message\n * @param options - Status-code-specific options\n * @returns The appropriate HttpError subclass\n *\n * @example\n * ```typescript\n * // TypeScript knows allowedMethods is valid for 405\n * createHttpError(405, 'Method not allowed', { allowedMethods: ['GET', 'POST'] });\n *\n * // TypeScript knows retryAfter is valid for 429\n * createHttpError(429, 'Rate limited', { retryAfter: 60 });\n * ```\n */\nexport function createHttpError<T extends ValidStatusCode>(\n  statusCode: T,\n  message?: string,\n  options?: ErrorOptions<T>,\n): HttpError;\nexport function createHttpError(\n  statusCode: number,\n  message?: string,\n  options?: HttpErrorOptions,\n): HttpError;\nexport function createHttpError(\n  statusCode: number,\n  message?: string,\n  options?: any,\n): HttpError {\n  const entry = errorRegistry[statusCode as ValidStatusCode];\n\n  if (entry) {\n    const handler = factoryHandlers[entry.type];\n    return handler(entry, message, options);\n  }\n\n  // Fallback to generic HttpError for unknown status codes\n  return new HttpError(statusCode, message, options);\n}\n\n/**\n * Type-safe error creation utilities with descriptive method names.\n * Provides a fluent API for creating specific HTTP errors.\n *\n * @example\n * ```typescript\n * createError.notFound('User not found');\n * createError.badRequest('Invalid input', { field: 'email' });\n * createError.methodNotAllowed('DELETE not supported', ['GET', 'POST']);\n * ```\n */\nexport const createError = {\n  badRequest: (message?: string, details?: any) =>\n    new BadRequestError(message, details),\n\n  unauthorized: (message?: string, details?: any) =>\n    new UnauthorizedError(message, details),\n\n  forbidden: (message?: string, details?: any) =>\n    new ForbiddenError(message, details),\n\n  notFound: (message?: string, details?: any) =>\n    new NotFoundError(message, details),\n\n  methodNotAllowed: (message?: string, allowedMethods?: string[]) =>\n    new MethodNotAllowedError(message, allowedMethods),\n\n  conflict: (message?: string, details?: any) =>\n    new ConflictError(message, details),\n\n  unprocessableEntity: (message?: string, validationErrors?: any) =>\n    new UnprocessableEntityError(message, validationErrors),\n\n  tooManyRequests: (message?: string, retryAfter?: number) =>\n    new TooManyRequestsError(message, retryAfter),\n\n  internalServerError: (message?: string, details?: any) =>\n    new InternalServerError(message, details),\n\n  notImplemented: (message?: string, details?: any) =>\n    new NotImplementedError(message, details),\n\n  badGateway: (message?: string, details?: any) =>\n    new BadGatewayError(message, details),\n\n  serviceUnavailable: (message?: string, retryAfter?: number) =>\n    new ServiceUnavailableError(message, retryAfter),\n\n  gatewayTimeout: (message?: string, details?: any) =>\n    new GatewayTimeoutError(message, details),\n} as const;\n\n// Type guards\n\n/**\n * Type guard to check if an error is an HttpError.\n * Works with both instanceof checks and duck typing.\n *\n * @param error - The error to check\n * @returns True if the error is an HttpError\n *\n * @example\n * ```typescript\n * try {\n *   // some code\n * } catch (error) {\n *   if (isHttpError(error)) {\n *     console.log(`HTTP ${error.statusCode}: ${error.message}`);\n *   }\n * }\n * ```\n */\nexport function isHttpError(error: unknown): error is HttpError {\n  return (\n    error instanceof HttpError ||\n    (error !== null &&\n      typeof error === 'object' &&\n      'isHttpError' in error &&\n      error.isHttpError === true)\n  );\n}\n\n/**\n * Type guard to check if an error is a client error (4xx status code).\n *\n * @param error - The error to check\n * @returns True if the error is an HttpError with a 4xx status code\n *\n * @example\n * ```typescript\n * if (isClientError(error)) {\n *   // Log client error metrics\n * }\n * ```\n */\nexport function isClientError(error: unknown): error is HttpError {\n  return (\n    isHttpError(error) && error.statusCode >= 400 && error.statusCode < 500\n  );\n}\n\n/**\n * Type guard to check if an error is a server error (5xx status code).\n *\n * @param error - The error to check\n * @returns True if the error is an HttpError with a 5xx status code\n *\n * @example\n * ```typescript\n * if (isServerError(error)) {\n *   // Trigger alerts for server errors\n * }\n * ```\n */\nexport function isServerError(error: unknown): error is HttpError {\n  return (\n    isHttpError(error) && error.statusCode >= 500 && error.statusCode < 600\n  );\n}\n\n// Utility functions\n\n/**\n * Wraps an unknown error into an HttpError.\n * If the error is already an HttpError, returns it unchanged.\n *\n * @param error - The error to wrap\n * @param statusCode - The HTTP status code to use (defaults to 500)\n * @param message - Optional message to override the original error message\n * @returns An HttpError instance\n *\n * @example\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   throw wrapError(error, 503, 'Service temporarily unavailable');\n * }\n * ```\n */\nexport function wrapError(\n  error: unknown,\n  statusCode = 500,\n  message?: string,\n): HttpError {\n  if (isHttpError(error)) {\n    return error;\n  }\n\n  if (error instanceof HttpError) {\n    return error;\n  }\n\n  return new HttpError(statusCode, message || 'An unknown error occurred', {\n    details: { originalError: error },\n  });\n}\n\n// Types for better TypeScript support\n\n/**\n * Options for creating an HttpError.\n */\nexport interface HttpErrorOptions {\n  statusMessage?: string;\n  details?: any;\n  code?: string;\n  cause?: Error;\n}\n\n/**\n * Constructor type for HttpError classes.\n * Useful for factory patterns and dependency injection.\n */\nexport type HttpErrorConstructor = new (\n  message?: string,\n  options?: HttpErrorOptions,\n) => HttpError;\n\n/**\n * HTTP status code enum for type-safe status code usage.\n * Includes common 2xx, 3xx, 4xx, and 5xx status codes.\n */\nexport enum HttpStatusCode {\n  // 2xx Success\n  OK = 200,\n  CREATED = 201,\n  ACCEPTED = 202,\n  NO_CONTENT = 204,\n\n  // 3xx Redirection\n  MOVED_PERMANENTLY = 301,\n  FOUND = 302,\n  NOT_MODIFIED = 304,\n\n  // 4xx Client Error\n  BAD_REQUEST = 400,\n  UNAUTHORIZED = 401,\n  FORBIDDEN = 403,\n  NOT_FOUND = 404,\n  METHOD_NOT_ALLOWED = 405,\n  NOT_ACCEPTABLE = 406,\n  REQUEST_TIMEOUT = 408,\n  CONFLICT = 409,\n  GONE = 410,\n  UNPROCESSABLE_ENTITY = 422,\n  TOO_MANY_REQUESTS = 429,\n\n  // 5xx Server Error\n  INTERNAL_SERVER_ERROR = 500,\n  NOT_IMPLEMENTED = 501,\n  BAD_GATEWAY = 502,\n  SERVICE_UNAVAILABLE = 503,\n  GATEWAY_TIMEOUT = 504,\n}\n\n/**\n * Namespace containing all HTTP error classes.\n * Useful for importing all error types at once.\n *\n * @example\n * ```typescript\n * import { HttpErrors } from '@geekmidas/errors';\n * throw new HttpErrors.NotFoundError('Resource not found');\n * ```\n */\nexport const HttpErrors = {\n  HttpError,\n  BadRequestError,\n  UnauthorizedError,\n  ForbiddenError,\n  NotFoundError,\n  MethodNotAllowedError,\n  ConflictError,\n  UnprocessableEntityError,\n  TooManyRequestsError,\n  InternalServerError,\n  NotImplementedError,\n  BadGatewayError,\n  ServiceUnavailableError,\n  GatewayTimeoutError,\n};\n\n// Usage examples:\n/*\n// Basic usage\nthrow new NotFoundError('User not found');\nthrow new BadRequestError('Invalid email format', { field: 'email' });\n\n// With validation errors\nthrow new UnprocessableEntityError('Validation failed', {\n  email: 'Invalid email format',\n  password: 'Password must be at least 8 characters',\n});\n\n// Type-safe factory function with IntelliSense support\nthrow createHttpError(405, 'Method not allowed', { \n  allowedMethods: ['GET', 'POST'] // TypeScript knows this is the correct option!\n});\n\nthrow createHttpError(429, 'Too many requests', { \n  retryAfter: 60 // TypeScript knows this needs retryAfter, not details!\n});\n\nthrow createHttpError(422, 'Validation failed', {\n  validationErrors: { // TypeScript knows this is for validation errors\n    email: 'Invalid format',\n    age: 'Must be 18+'\n  }\n});\n\n// Using the type-safe createError object\nthrow createError.methodNotAllowed('DELETE not supported', ['GET', 'POST']);\nthrow createError.tooManyRequests('Rate limit exceeded', 60);\nthrow createError.unprocessableEntity('Invalid input', {\n  field: 'email',\n  message: 'Invalid format'\n});\n\n// TypeScript will show errors for incorrect usage:\n// throw createHttpError(404, 'Not found', { retryAfter: 60 }); // ❌ Type error!\n// throw createError.notFound('User not found', 60); // ❌ Type error!\n\n// Wrapping unknown errors\ntry {\n  await someAsyncOperation();\n} catch (error) {\n  throw wrapError(error, 500, 'Failed to process request');\n}\n\n// In Express middleware\napp.use(expressErrorHandler);\n\n// Type checking\nif (isClientError(error)) {\n  console.log('Client made a bad request');\n}\n*/\n"],"mappings":"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"}