Error Handling & Validation

🛡️ Error Handling & Validation

⚠️ Custom Error Classes: Structured Errors

Extend Error to create domain-specific error types:

Copyclass ValidationError extends Error {
  constructor(public field: string, message: string) {
    super(message);
    this.name = "ValidationError";
  }
}

class NetworkError extends Error {
  constructor(public statusCode: number, message: string) {
    super(message);
    this.name = "NetworkError";
  }
}

class DatabaseError extends Error {
  constructor(public query: string, message: string) {
    super(message);
    this.name = "DatabaseError";
  }
}

// Usage: throw with context
throw new ValidationError("email", "Invalid email format");
throw new NetworkError(404, "User not found");

🎯 Handling Errors: Try-Catch Patterns

Copytry {
  // Risky operation
  const user = await fetchUser(id);
} catch (error) {
  // Always type-guard: error could be anything
  if (error instanceof ValidationError) {
    console.error(`Field validation failed: ${error.field}`);
  } else if (error instanceof NetworkError) {
    console.error(`Server error: ${error.statusCode}`);
  } else if (error instanceof Error) {
    console.error(`Unexpected: ${error.message}`);
  } else {
    console.error("Unknown error");
  }
}

✅ Validation: Fail Fast or Collect All?

Copyfunction validate(data: User) {
  if (!data.email) {
    throw new ValidationError("email", "Required");
  }
  if (data.age < 18) {
    throw new ValidationError("age", "Must be 18+");
  }
}

Copyfunction validate(data: User): ValidationError[] {
  const errors: ValidationError[] = [];

  if (!data.email) {
    errors.push(new ValidationError("email", "Required"));
  }
  if (data.age < 18) {
    errors.push(new ValidationError("age", "Must be 18+"));
  }

  return errors;
}

🔄 Result Type: No Exceptions

Instead of throwing, return success or error as data:

Copytype Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E };

async function parseJSON<T>(text: string): Result<T, SyntaxError> {
  try {
    const value = JSON.parse(text) as T;
    return { ok: true, value };
  } catch (error) {
    return { ok: false, error: error as SyntaxError };
  }
}

// Usage: no try-catch needed
const result = parseJSON<User>(jsonString);

if (result.ok) {
  console.log("Parsed:", result.value);  // ✅ User type
} else {
  console.error("Parse failed:", result.error.message);
}

🔍 Exhaustiveness: Catch Missing Cases

Use discriminated unions + the never type to ensure all cases are handled:

Copytype FileOperation =
  | { type: "read"; path: string }
  | { type: "write"; path: string; content: string }
  | { type: "delete"; path: string };

function handleOperation(op: FileOperation): void {
  switch (op.type) {
    case "read":
      console.log(`Reading ${op.path}`);
      break;
    case "write":
      console.log(`Writing to ${op.path}`);
      break;
    case "delete":
      console.log(`Deleting ${op.path}`);
      break;
    default:
      // If you forget a case, TypeScript errors here
      const _exhaustive: never = op;
      return _exhaustive;
  }
}

The trick: If you add a new case to the union but don't handle it, the op value has type never, which causes a compile error. Forces you to update all handlers.

🏗️ Real-World Pattern: Robust API Call

Copyasync function fetchUserSafe(id: number) {
  try {
    // 1. Validate input
    if (id <= 0) {
      throw new ValidationError("id", "Must be positive");
    }

    // 2. Network call with timeout
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), 5000);

    const response = await fetch(`/api/users/${id}`, {
      signal: controller.signal
    });

    clearTimeout(timeout);

    // 3. Check status
    if (!response.ok) {
      throw new NetworkError(response.status, response.statusText);
    }

    // 4. Parse and validate
    const data = await response.json();
    if (!data.id || !data.name) {
      throw new Error("Invalid response shape");
    }

    return { ok: true, data };
  } catch (error) {
    if (error instanceof ValidationError) {
      return { ok: false, reason: "validation", error };
    } else if (error instanceof NetworkError) {
      return { ok: false, reason: "network", error };
    } else {
      return { ok: false, reason: "unknown", error };
    }
  }
}

💻 Coding Challenges

🎯 What's Next

With error handling mastered, we'll explore the final chapter: Design Patterns in TypeScript — bringing together everything you've learned to build robust, scalable applications.