error-handling

---

name: ErrorHandlingStandards type: Auto Attached description: Enforce comprehensive error handling patterns, custom error types, and robust failure recovery mechanisms across all code implementations glob: **/*.{js,ts,tsx,jsx,py,java,go,rb,php,swift,kt} priority: high

Error Handling Standards

Implement robust, typed error handling with proper abstraction levels, meaningful messages, and comprehensive recovery mechanisms. This rule ensures consistent error handling patterns across the entire codebase.

Core Error Handling Principles

When writing any code, I will:

1. Fail Fast with Context: Detect and report errors immediately with rich contextual information
2. Type-Safe Error Handling: Use typed errors instead of generic Error objects
3. Proper Abstraction: Handle errors at the appropriate level in the application architecture
4. Never Silence: Always handle errors explicitly - never swallow them without proper logging/recovery
5. Graceful Degradation: Implement fallback mechanisms for critical functionality
6. User-Friendly Messages: Provide clear, actionable error messages for users

Implementation Patterns

1. Custom Error Classes Architecture

Always implement a structured error hierarchy:

// Base error class with required properties
abstract class AppError extends Error {
  abstract readonly code: string;
  abstract readonly statusCode: number;
  abstract readonly severity: 'low' | 'medium' | 'high' | 'critical';
  
  constructor(
    message: string,
    public readonly context?: Record<string, unknown>,
    public readonly userMessage?: string
  ) {
    super(message);
    this.name = this.constructor.name;
    Error.captureStackTrace(this, this.constructor);
  }

  toJSON() {
    return {
      name: this.name,
      message: this.message,
      code: this.code,
      statusCode: this.statusCode,
      severity: this.severity,
      context: this.context,
      userMessage: this.userMessage
    };
  }
}

// Specific error implementations
class ValidationError extends AppError {
  readonly code = 'VALIDATION_ERROR';
  readonly statusCode = 400;
  readonly severity = 'medium' as const;
}

class NotFoundError extends AppError {
  readonly code = 'NOT_FOUND';
  readonly statusCode = 404;
  readonly severity = 'low' as const;
}

class DatabaseError extends AppError {
  readonly code = 'DATABASE_ERROR';
  readonly statusCode = 500;
  readonly severity = 'high' as const;
}