Безпечна обробка помилок у TypeScript

try {
  // Код, який може завершитися помилкою
} catch (error) {
  // error має тип unknown
}

try {
  throw new Error("Не вдалося завантажити дані");
} catch (error) {
  // Помилка компіляції:
  // console.log(error.message);

  if (error instanceof Error) {
    console.log(error.message);
  }
}

try {
  throw "Помилка";
} catch (error: any) {
  // TypeScript не повідомить про проблему,
  // хоча у рядка немає властивості message.
  console.log(error.message);
}

try {
  throw "Помилка";
} catch (error: unknown) {
  if (typeof error === "string") {
    console.log(error);
  }
}

function readConfiguration(): void {
  throw new Error("Файл конфігурації не знайдено");
}

try {
  readConfiguration();
} catch (error: unknown) {
  if (error instanceof Error) {
    console.error(`Сталася помилка: ${error.message}`);
  } else {
    console.error("Отримано невідомий формат помилки");
  }
}

try {
  JSON.parse("некоректний JSON");
} catch (error: unknown) {
  if (error instanceof SyntaxError) {
    console.error("Помилка синтаксису JSON:", error.message);
  } else if (error instanceof Error) {
    console.error("Інша помилка:", error.message);
  }
}

function getErrorMessage(error: unknown): string {
  if (error instanceof Error) {
    return error.message;
  }

  if (typeof error === "string") {
    return error;
  }

  if (typeof error === "number") {
    return `Код помилки: ${error}`;
  }

  return "Невідома помилка";
}

{
  "code": "USER_NOT_FOUND",
  "message": "Користувача не знайдено"
}

interface ApiError {
  code: string;
  message: string;
}

const error = value as ApiError;

type ApiError = {
  code: string;
  message: string;
};

function isApiError(value: unknown): value is ApiError {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const record = value as Record<string, unknown>;

  return (
    typeof record.code === "string" &&
    typeof record.message === "string"
  );
}

try {
  throw {
    code: "USER_NOT_FOUND",
    message: "Користувача не знайдено",
  };
} catch (error: unknown) {
  if (isApiError(error)) {
    console.error(`[${error.code}] ${error.message}`);
  }
}

type NormalizedError = {
  message: string;
  code?: string;
};

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null;
}

function normalizeError(error: unknown): NormalizedError {
  if (error instanceof Error) {
    return {
      message: error.message,
    };
  }

  if (typeof error === "string") {
    return {
      message: error,
    };
  }

  if (isRecord(error)) {
    const message =
      typeof error.message === "string"
        ? error.message
        : "Невідома помилка";

    const code =
      typeof error.code === "string"
        ? error.code
        : undefined;

    return {
      message,
      code,
    };
  }

  return {
    message: "Невідома помилка",
  };
}

function executeTask(type: "standard" | "api" | "string" | "number"): void {
  switch (type) {
    case "standard":
      throw new Error("Не вдалося виконати операцію");

    case "api":
      throw {
        code: "LIMIT_EXCEEDED",
        message: "Перевищено ліміт запитів",
      };

    case "string":
      throw "Сервер тимчасово недоступний";

    case "number":
      throw 503;
  }
}

const taskTypes = ["standard", "api", "string", "number"] as const;

for (const taskType of taskTypes) {
  try {
    executeTask(taskType);
  } catch (error: unknown) {
    const normalized = normalizeError(error);
    const prefix = normalized.code
      ? `[${normalized.code}] `
      : "";

    console.error(`${taskType}: ${prefix}${normalized.message}`);
  }
}

tsc error-handling.ts --strict --target ES2020 --module commonjs
node error-handling.js

type ApiError = {
  code: string;
  message: string;
};

function isApiError(value: unknown): value is ApiError {
  if (!isRecord(value)) {
    return false;
  }

  return (
    typeof value.code === "string" &&
    typeof value.message === "string"
  );
}

async function requestData(): Promise<unknown> {
  throw {
    code: "SERVICE_UNAVAILABLE",
    message: "Сервіс тимчасово недоступний",
  };
}

async function loadData(): Promise<void> {
  try {
    await requestData();
  } catch (error: unknown) {
    if (isApiError(error)) {
      console.error(`Помилка API ${error.code}: ${error.message}`);
      return;
    }

    if (error instanceof Error) {
      console.error(`Помилка виконання: ${error.message}`);
      return;
    }

    console.error("Отримано непередбачений формат помилки");
  }
}

void loadData();

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

function validateUsername(username: string): void {
  if (username.length < 3) {
    throw new ValidationError(
      "Ім’я користувача має містити щонайменше 3 символи",
      "username",
    );
  }
}

try {
  validateUsername("ab");
} catch (error: unknown) {
  if (error instanceof ValidationError) {
    console.error(`Поле ${error.field}: ${error.message}`);
  } else if (error instanceof Error) {
    console.error(error.message);
  } else {
    console.error("Невідома помилка");
  }
}

try {
  doSomething();
} catch (error) {
  console.log((error as Error).message);
}

try {
  doSomething();
} catch (error: unknown) {
  if (error instanceof Error) {
    console.log(error.message);
  }
}

if (typeof error === "object" && error !== null) {
  const message = (error as { message: string }).message;
  console.log(message);
}

if (isRecord(error) && typeof error.message === "string") {
  console.log(error.message);
}

try {
  performOperation();
} catch (error: unknown) {
  if (error instanceof ValidationError) {
    // Обробка помилки валідації
  } else if (error instanceof Error) {
    // Обробка стандартної помилки
  } else if (isApiError(error)) {
    // Обробка помилки API
  } else {
    // Обробка невідомого значення
  }
}