@geekmidas/errors 0.0.1 → 1.0.0

package/src/index.ts

@@ -14,115 +14,114 @@
  * ```
  */
 export class HttpError extends Error {
-  /** The HTTP status code (e.g., 400, 404, 500) */
-  public readonly statusCode: number;
-  /** The standard HTTP status message (e.g., 'Bad Request', 'Not Found') */
-  public readonly statusMessage: string;
-  /** Type discriminator for runtime type checking */
-  public readonly isHttpError = true;
-  /** Additional error details for debugging or client information */
-  public readonly details?: any;
-  /** Application-specific error code for client-side handling */
-  public readonly code?: string;
-
-  /**
-   * 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: number,
-    message?: string,
-    options?: {
-      statusMessage?: string;
-      details?: any;
-      code?: string;
-      cause?: Error;
-    },
-  ) {
-    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;
-
-    // Set cause if provided (ES2022 feature)
-    if (options?.cause) {
-      this.cause = options.cause;
-    }
-    // @ts-ignore
-    // Maintains proper stack trace for where our error was thrown
-    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
-   */
-  private getDefaultStatusMessage(statusCode: number): string {
-    const statusMessages: Record<number, string> = {
-      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,
-    };
-  }
+	/** The HTTP status code (e.g., 400, 404, 500) */
+	public readonly statusCode: number;
+	/** The standard HTTP status message (e.g., 'Bad Request', 'Not Found') */
+	public readonly statusMessage: string;
+	/** Type discriminator for runtime type checking */
+	public readonly isHttpError = true;
+	/** Additional error details for debugging or client information */
+	public readonly details?: any;
+	/** Application-specific error code for client-side handling */
+	public readonly code?: string;
+
+	/**
+	 * 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: number,
+		message?: string,
+		options?: {
+			statusMessage?: string;
+			details?: any;
+			code?: string;
+			cause?: Error;
+		},
+	) {
+		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;
+
+		// Set cause if provided (ES2022 feature)
+		if (options?.cause) {
+			this.cause = options.cause;
+		}
+		// Maintains proper stack trace for where our error was thrown
+		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
+	 */
+	private getDefaultStatusMessage(statusCode: number): string {
+		const statusMessages: Record<number, string> = {
+			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,
+		};
+	}
 }
 
 // Client Error Classes (4xx)
@@ -139,9 +138,9 @@ export class HttpError extends Error {
  * ```
  */
 export class BadRequestError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(400, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(400, message, { details });
+	}
 }
 
 /**
@@ -156,9 +155,9 @@ export class BadRequestError extends HttpError {
  * ```
  */
 export class UnauthorizedError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(401, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(401, message, { details });
+	}
 }
 
 /**
@@ -173,9 +172,9 @@ export class UnauthorizedError extends HttpError {
  * ```
  */
 export class ForbiddenError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(403, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(403, message, { details });
+	}
 }
 
 /**
@@ -190,9 +189,9 @@ export class ForbiddenError extends HttpError {
  * ```
  */
 export class NotFoundError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(404, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(404, message, { details });
+	}
 }
 
 /**
@@ -207,15 +206,15 @@ export class NotFoundError extends HttpError {
  * ```
  */
 export class MethodNotAllowedError extends HttpError {
-  /**
-   * @param message - Optional error message
-   * @param allowedMethods - Array of allowed HTTP methods for this resource
-   */
-  constructor(message?: string, allowedMethods?: string[]) {
-    super(405, message, {
-      details: allowedMethods ? { allowedMethods } : undefined,
-    });
-  }
+	/**
+	 * @param message - Optional error message
+	 * @param allowedMethods - Array of allowed HTTP methods for this resource
+	 */
+	constructor(message?: string, allowedMethods?: string[]) {
+		super(405, message, {
+			details: allowedMethods ? { allowedMethods } : undefined,
+		});
+	}
 }
 
 /**
@@ -230,9 +229,9 @@ export class MethodNotAllowedError extends HttpError {
  * ```
  */
 export class ConflictError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(409, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(409, message, { details });
+	}
 }
 
 /**
@@ -250,15 +249,15 @@ export class ConflictError extends HttpError {
  * ```
  */
 export class UnprocessableEntityError extends HttpError {
-  /**
-   * @param message - Optional error message
-   * @param validationErrors - Object containing field-specific validation errors
-   */
-  constructor(message?: string, validationErrors?: any) {
-    super(422, message, {
-      details: validationErrors ? { validationErrors } : undefined,
-    });
-  }
+	/**
+	 * @param message - Optional error message
+	 * @param validationErrors - Object containing field-specific validation errors
+	 */
+	constructor(message?: string, validationErrors?: any) {
+		super(422, message, {
+			details: validationErrors ? { validationErrors } : undefined,
+		});
+	}
 }
 
 /**
@@ -273,15 +272,15 @@ export class UnprocessableEntityError extends HttpError {
  * ```
  */
 export class TooManyRequestsError extends HttpError {
-  /**
-   * @param message - Optional error message
-   * @param retryAfter - Number of seconds the client should wait before retrying
-   */
-  constructor(message?: string, retryAfter?: number) {
-    super(429, message, {
-      details: retryAfter ? { retryAfter } : undefined,
-    });
-  }
+	/**
+	 * @param message - Optional error message
+	 * @param retryAfter - Number of seconds the client should wait before retrying
+	 */
+	constructor(message?: string, retryAfter?: number) {
+		super(429, message, {
+			details: retryAfter ? { retryAfter } : undefined,
+		});
+	}
 }
 
 // Server Error Classes (5xx)
@@ -298,9 +297,9 @@ export class TooManyRequestsError extends HttpError {
  * ```
  */
 export class InternalServerError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(500, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(500, message, { details });
+	}
 }
 
 /**
@@ -315,9 +314,9 @@ export class InternalServerError extends HttpError {
  * ```
  */
 export class NotImplementedError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(501, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(501, message, { details });
+	}
 }
 
 /**
@@ -332,9 +331,9 @@ export class NotImplementedError extends HttpError {
  * ```
  */
 export class BadGatewayError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(502, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(502, message, { details });
+	}
 }
 
 /**
@@ -349,15 +348,15 @@ export class BadGatewayError extends HttpError {
  * ```
  */
 export class ServiceUnavailableError extends HttpError {
-  /**
-   * @param message - Optional error message
-   * @param retryAfter - Number of seconds the client should wait before retrying
-   */
-  constructor(message?: string, retryAfter?: number) {
-    super(503, message, {
-      details: retryAfter ? { retryAfter } : undefined,
-    });
-  }
+	/**
+	 * @param message - Optional error message
+	 * @param retryAfter - Number of seconds the client should wait before retrying
+	 */
+	constructor(message?: string, retryAfter?: number) {
+		super(503, message, {
+			details: retryAfter ? { retryAfter } : undefined,
+		});
+	}
 }
 
 /**
@@ -372,9 +371,9 @@ export class ServiceUnavailableError extends HttpError {
  * ```
  */
 export class GatewayTimeoutError extends HttpError {
-  constructor(message?: string, details?: any) {
-    super(504, message, { details });
-  }
+	constructor(message?: string, details?: any) {
+		super(504, message, { details });
+	}
 }
 
 // Type definitions for different error factory signatures
@@ -383,78 +382,78 @@ export class GatewayTimeoutError extends HttpError {
 type StandardErrorFactory = (message?: string, details?: any) => HttpError;
 /** Factory function for Method Not Allowed errors with allowed methods */
 type MethodNotAllowedFactory = (
-  message?: string,
-  allowedMethods?: string[],
+	message?: string,
+	allowedMethods?: string[],
 ) => MethodNotAllowedError;
 /** Factory function for errors that include retry-after information */
 type RetryAfterFactory = (message?: string, retryAfter?: number) => HttpError;
 /** Factory function for validation errors with field-specific errors */
 type ValidationErrorFactory = (
-  message?: string,
-  validationErrors?: any,
+	message?: string,
+	validationErrors?: any,
 ) => UnprocessableEntityError;
 
 /** Discriminated union for all factory types */
 type ErrorFactory =
-  | { type: 'standard'; factory: StandardErrorFactory }
-  | { type: 'methodNotAllowed'; factory: MethodNotAllowedFactory }
-  | { type: 'retryAfter'; factory: RetryAfterFactory }
-  | { type: 'validation'; factory: ValidationErrorFactory };
+	| { type: 'standard'; factory: StandardErrorFactory }
+	| { type: 'methodNotAllowed'; factory: MethodNotAllowedFactory }
+	| { type: 'retryAfter'; factory: RetryAfterFactory }
+	| { type: 'validation'; factory: ValidationErrorFactory };
 
 /** Type-safe error registry mapping status codes to their factory functions */
 const errorRegistry = {
-  400: {
-    type: 'standard',
-    factory: (m: string, d: any) => new BadRequestError(m, d),
-  },
-  401: {
-    type: 'standard',
-    factory: (m: string, d: any) => new UnauthorizedError(m, d),
-  },
-  403: {
-    type: 'standard',
-    factory: (m: string, d: any) => new ForbiddenError(m, d),
-  },
-  404: {
-    type: 'standard',
-    factory: (m: string, d: any) => new NotFoundError(m, d),
-  },
-  405: {
-    type: 'methodNotAllowed',
-    factory: (m: string, am: string[]) => new MethodNotAllowedError(m, am),
-  },
-  409: {
-    type: 'standard',
-    factory: (m: string, d: any) => new ConflictError(m, d),
-  },
-  422: {
-    type: 'validation',
-    factory: (m: string, ve: any) => new UnprocessableEntityError(m, ve),
-  },
-  429: {
-    type: 'retryAfter',
-    factory: (m: string, ra: number) => new TooManyRequestsError(m, ra),
-  },
-  500: {
-    type: 'standard',
-    factory: (m: string, d: any) => new InternalServerError(m, d),
-  },
-  501: {
-    type: 'standard',
-    factory: (m: string, d: any) => new NotImplementedError(m, d),
-  },
-  502: {
-    type: 'standard',
-    factory: (m: string, d: any) => new BadGatewayError(m, d),
-  },
-  503: {
-    type: 'retryAfter',
-    factory: (m: string, ra: number) => new ServiceUnavailableError(m, ra),
-  },
-  504: {
-    type: 'standard',
-    factory: (m: string, d: any) => new GatewayTimeoutError(m, d),
-  },
+	400: {
+		type: 'standard',
+		factory: (m: string, d: any) => new BadRequestError(m, d),
+	},
+	401: {
+		type: 'standard',
+		factory: (m: string, d: any) => new UnauthorizedError(m, d),
+	},
+	403: {
+		type: 'standard',
+		factory: (m: string, d: any) => new ForbiddenError(m, d),
+	},
+	404: {
+		type: 'standard',
+		factory: (m: string, d: any) => new NotFoundError(m, d),
+	},
+	405: {
+		type: 'methodNotAllowed',
+		factory: (m: string, am: string[]) => new MethodNotAllowedError(m, am),
+	},
+	409: {
+		type: 'standard',
+		factory: (m: string, d: any) => new ConflictError(m, d),
+	},
+	422: {
+		type: 'validation',
+		factory: (m: string, ve: any) => new UnprocessableEntityError(m, ve),
+	},
+	429: {
+		type: 'retryAfter',
+		factory: (m: string, ra: number) => new TooManyRequestsError(m, ra),
+	},
+	500: {
+		type: 'standard',
+		factory: (m: string, d: any) => new InternalServerError(m, d),
+	},
+	501: {
+		type: 'standard',
+		factory: (m: string, d: any) => new NotImplementedError(m, d),
+	},
+	502: {
+		type: 'standard',
+		factory: (m: string, d: any) => new BadGatewayError(m, d),
+	},
+	503: {
+		type: 'retryAfter',
+		factory: (m: string, ra: number) => new ServiceUnavailableError(m, ra),
+	},
+	504: {
+		type: 'standard',
+		factory: (m: string, d: any) => new GatewayTimeoutError(m, d),
+	},
 } as const;
 
 /** Valid status codes that have registered error factories */
@@ -462,26 +461,26 @@ type ValidStatusCode = keyof typeof errorRegistry;
 
 /** Type-safe options based on status code, ensuring correct parameters for each error type */
 type ErrorOptions<T extends number> = T extends 405
-  ? { allowedMethods?: string[]; code?: string; cause?: Error }
-  : T extends 422
-    ? { validationErrors?: any; code?: string; cause?: Error }
-    : T extends 429 | 503
-      ? { retryAfter?: number; code?: string; cause?: Error }
-      : { details?: any; code?: string; cause?: Error };
+	? { allowedMethods?: string[]; code?: string; cause?: Error }
+	: T extends 422
+		? { validationErrors?: any; code?: string; cause?: Error }
+		: T extends 429 | 503
+			? { retryAfter?: number; code?: string; cause?: Error }
+			: { details?: any; code?: string; cause?: Error };
 
 /** Handler functions for each factory type */
 const factoryHandlers: Record<
-  ErrorFactory['type'],
-  (entry: any, message?: string, options?: any) => HttpError
+	ErrorFactory['type'],
+	(entry: any, message?: string, options?: any) => HttpError
 > = {
-  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),
+	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),
 };
 
 /**
@@ -504,29 +503,29 @@ const factoryHandlers: Record<
  * ```
  */
 export function createHttpError<T extends ValidStatusCode>(
-  statusCode: T,
-  message?: string,
-  options?: ErrorOptions<T>,
+	statusCode: T,
+	message?: string,
+	options?: ErrorOptions<T>,
 ): HttpError;
 export function createHttpError(
-  statusCode: number,
-  message?: string,
-  options?: HttpErrorOptions,
+	statusCode: number,
+	message?: string,
+	options?: HttpErrorOptions,
 ): HttpError;
 export function createHttpError(
-  statusCode: number,
-  message?: string,
-  options?: any,
+	statusCode: number,
+	message?: string,
+	options?: any,
 ): HttpError {
-  const entry = errorRegistry[statusCode as ValidStatusCode];
+	const entry = errorRegistry[statusCode as ValidStatusCode];
 
-  if (entry) {
-    const handler = factoryHandlers[entry.type];
-    return handler(entry, message, options);
-  }
+	if (entry) {
+		const handler = factoryHandlers[entry.type];
+		return handler(entry, message, options);
+	}
 
-  // Fallback to generic HttpError for unknown status codes
-  return new HttpError(statusCode, message, options);
+	// Fallback to generic HttpError for unknown status codes
+	return new HttpError(statusCode, message, options);
 }
 
 /**
@@ -541,44 +540,44 @@ export function createHttpError(
  * ```
  */
 export const createError = {
-  badRequest: (message?: string, details?: any) =>
-    new BadRequestError(message, details),
+	badRequest: (message?: string, details?: any) =>
+		new BadRequestError(message, details),
 
-  unauthorized: (message?: string, details?: any) =>
-    new UnauthorizedError(message, details),
+	unauthorized: (message?: string, details?: any) =>
+		new UnauthorizedError(message, details),
 
-  forbidden: (message?: string, details?: any) =>
-    new ForbiddenError(message, details),
+	forbidden: (message?: string, details?: any) =>
+		new ForbiddenError(message, details),
 
-  notFound: (message?: string, details?: any) =>
-    new NotFoundError(message, details),
+	notFound: (message?: string, details?: any) =>
+		new NotFoundError(message, details),
 
-  methodNotAllowed: (message?: string, allowedMethods?: string[]) =>
-    new MethodNotAllowedError(message, allowedMethods),
+	methodNotAllowed: (message?: string, allowedMethods?: string[]) =>
+		new MethodNotAllowedError(message, allowedMethods),
 
-  conflict: (message?: string, details?: any) =>
-    new ConflictError(message, details),
+	conflict: (message?: string, details?: any) =>
+		new ConflictError(message, details),
 
-  unprocessableEntity: (message?: string, validationErrors?: any) =>
-    new UnprocessableEntityError(message, validationErrors),
+	unprocessableEntity: (message?: string, validationErrors?: any) =>
+		new UnprocessableEntityError(message, validationErrors),
 
-  tooManyRequests: (message?: string, retryAfter?: number) =>
-    new TooManyRequestsError(message, retryAfter),
+	tooManyRequests: (message?: string, retryAfter?: number) =>
+		new TooManyRequestsError(message, retryAfter),
 
-  internalServerError: (message?: string, details?: any) =>
-    new InternalServerError(message, details),
+	internalServerError: (message?: string, details?: any) =>
+		new InternalServerError(message, details),
 
-  notImplemented: (message?: string, details?: any) =>
-    new NotImplementedError(message, details),
+	notImplemented: (message?: string, details?: any) =>
+		new NotImplementedError(message, details),
 
-  badGateway: (message?: string, details?: any) =>
-    new BadGatewayError(message, details),
+	badGateway: (message?: string, details?: any) =>
+		new BadGatewayError(message, details),
 
-  serviceUnavailable: (message?: string, retryAfter?: number) =>
-    new ServiceUnavailableError(message, retryAfter),
+	serviceUnavailable: (message?: string, retryAfter?: number) =>
+		new ServiceUnavailableError(message, retryAfter),
 
-  gatewayTimeout: (message?: string, details?: any) =>
-    new GatewayTimeoutError(message, details),
+	gatewayTimeout: (message?: string, details?: any) =>
+		new GatewayTimeoutError(message, details),
 } as const;
 
 // Type guards
@@ -602,13 +601,13 @@ export const createError = {
  * ```
  */
 export function isHttpError(error: unknown): error is HttpError {
-  return (
-    error instanceof HttpError ||
-    (error !== null &&
-      typeof error === 'object' &&
-      'isHttpError' in error &&
-      error.isHttpError === true)
-  );
+	return (
+		error instanceof HttpError ||
+		(error !== null &&
+			typeof error === 'object' &&
+			'isHttpError' in error &&
+			error.isHttpError === true)
+	);
 }
 
 /**
@@ -625,9 +624,9 @@ export function isHttpError(error: unknown): error is HttpError {
  * ```
  */
 export function isClientError(error: unknown): error is HttpError {
-  return (
-    isHttpError(error) && error.statusCode >= 400 && error.statusCode < 500
-  );
+	return (
+		isHttpError(error) && error.statusCode >= 400 && error.statusCode < 500
+	);
 }
 
 /**
@@ -644,9 +643,9 @@ export function isClientError(error: unknown): error is HttpError {
  * ```
  */
 export function isServerError(error: unknown): error is HttpError {
-  return (
-    isHttpError(error) && error.statusCode >= 500 && error.statusCode < 600
-  );
+	return (
+		isHttpError(error) && error.statusCode >= 500 && error.statusCode < 600
+	);
 }
 
 // Utility functions
@@ -670,21 +669,21 @@ export function isServerError(error: unknown): error is HttpError {
  * ```
  */
 export function wrapError(
-  error: unknown,
-  statusCode = 500,
-  message?: string,
+	error: unknown,
+	statusCode = 500,
+	message?: string,
 ): HttpError {
-  if (isHttpError(error)) {
-    return error;
-  }
+	if (isHttpError(error)) {
+		return error;
+	}
 
-  if (error instanceof HttpError) {
-    return error;
-  }
+	if (error instanceof HttpError) {
+		return error;
+	}
 
-  return new HttpError(statusCode, message || 'An unknown error occurred', {
-    details: { originalError: error },
-  });
+	return new HttpError(statusCode, message || 'An unknown error occurred', {
+		details: { originalError: error },
+	});
 }
 
 // Types for better TypeScript support
@@ -693,10 +692,10 @@ export function wrapError(
  * Options for creating an HttpError.
  */
 export interface HttpErrorOptions {
-  statusMessage?: string;
-  details?: any;
-  code?: string;
-  cause?: Error;
+	statusMessage?: string;
+	details?: any;
+	code?: string;
+	cause?: Error;
 }
 
 /**
@@ -704,8 +703,8 @@ export interface HttpErrorOptions {
  * Useful for factory patterns and dependency injection.
  */
 export type HttpErrorConstructor = new (
-  message?: string,
-  options?: HttpErrorOptions,
+	message?: string,
+	options?: HttpErrorOptions,
 ) => HttpError;
 
 /**
@@ -713,36 +712,36 @@ export type HttpErrorConstructor = new (
  * Includes common 2xx, 3xx, 4xx, and 5xx status codes.
  */
 export enum HttpStatusCode {
-  // 2xx Success
-  OK = 200,
-  CREATED = 201,
-  ACCEPTED = 202,
-  NO_CONTENT = 204,
-
-  // 3xx Redirection
-  MOVED_PERMANENTLY = 301,
-  FOUND = 302,
-  NOT_MODIFIED = 304,
-
-  // 4xx Client Error
-  BAD_REQUEST = 400,
-  UNAUTHORIZED = 401,
-  FORBIDDEN = 403,
-  NOT_FOUND = 404,
-  METHOD_NOT_ALLOWED = 405,
-  NOT_ACCEPTABLE = 406,
-  REQUEST_TIMEOUT = 408,
-  CONFLICT = 409,
-  GONE = 410,
-  UNPROCESSABLE_ENTITY = 422,
-  TOO_MANY_REQUESTS = 429,
-
-  // 5xx Server Error
-  INTERNAL_SERVER_ERROR = 500,
-  NOT_IMPLEMENTED = 501,
-  BAD_GATEWAY = 502,
-  SERVICE_UNAVAILABLE = 503,
-  GATEWAY_TIMEOUT = 504,
+	// 2xx Success
+	OK = 200,
+	CREATED = 201,
+	ACCEPTED = 202,
+	NO_CONTENT = 204,
+
+	// 3xx Redirection
+	MOVED_PERMANENTLY = 301,
+	FOUND = 302,
+	NOT_MODIFIED = 304,
+
+	// 4xx Client Error
+	BAD_REQUEST = 400,
+	UNAUTHORIZED = 401,
+	FORBIDDEN = 403,
+	NOT_FOUND = 404,
+	METHOD_NOT_ALLOWED = 405,
+	NOT_ACCEPTABLE = 406,
+	REQUEST_TIMEOUT = 408,
+	CONFLICT = 409,
+	GONE = 410,
+	UNPROCESSABLE_ENTITY = 422,
+	TOO_MANY_REQUESTS = 429,
+
+	// 5xx Server Error
+	INTERNAL_SERVER_ERROR = 500,
+	NOT_IMPLEMENTED = 501,
+	BAD_GATEWAY = 502,
+	SERVICE_UNAVAILABLE = 503,
+	GATEWAY_TIMEOUT = 504,
 }
 
 /**
@@ -756,20 +755,20 @@ export enum HttpStatusCode {
  * ```
  */
 export const HttpErrors = {
-  HttpError,
-  BadRequestError,
-  UnauthorizedError,
-  ForbiddenError,
-  NotFoundError,
-  MethodNotAllowedError,
-  ConflictError,
-  UnprocessableEntityError,
-  TooManyRequestsError,
-  InternalServerError,
-  NotImplementedError,
-  BadGatewayError,
-  ServiceUnavailableError,
-  GatewayTimeoutError,
+	HttpError,
+	BadRequestError,
+	UnauthorizedError,
+	ForbiddenError,
+	NotFoundError,
+	MethodNotAllowedError,
+	ConflictError,
+	UnprocessableEntityError,
+	TooManyRequestsError,
+	InternalServerError,
+	NotImplementedError,
+	BadGatewayError,
+	ServiceUnavailableError,
+	GatewayTimeoutError,
 };
 
 // Usage examples: