TypeScript exhaustive checkで型安全を強化｜never型・satisfies・ts-pattern完全比較

type Color = "red" | "green" | "blue";

function getColorCode(color: Color): string {
  switch (color) {
    case "red":
      return "#ff0000";
    case "green":
      return "#00ff00";
    case "blue":
      return "#0000ff";
    default: {
      // すべてのケースを処理済みなので、colorはnever型
      const _: never = color;
      throw new Error(`未対応の色: ${_}`);
    }
  }
}

type Status = "pending" | "approved" | "rejected";

function handleStatus(status: Status): void {
  if (status === "pending") {
    // statusは "pending"
    return;
  }
  if (status === "approved") {
    // statusは "approved"
    return;
  }
  // ここでstatusは "rejected" — never型ではない
  // const _: never = status; // コンパイルエラー！
}

function assertNever(value: never, message?: string): never {
  throw new Error(message ?? `Unexpected value: ${value}`);
}

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rectangle":
      return shape.width * shape.height;
    case "triangle":
      return (shape.base * shape.height) / 2;
    default:
      return assertNever(shape);
  }
}

type Direction = "up" | "down" | "left" | "right";

function move(direction: Direction): void {
  switch (direction) {
    case "up":
      console.log("上に移動");
      break;
    case "down":
      console.log("下に移動");
      break;
    case "left":
      console.log("左に移動");
      break;
    case "right":
      console.log("右に移動");
      break;
    default: {
      const _exhaustiveCheck: never = direction;
      break;
    }
  }
}

type Fruit = "apple" | "banana" | "orange";

function getFruitEmoji(fruit: Fruit): string {
  switch (fruit) {
    case "apple":
      return "🍎";
    case "banana":
      return "🍌";
    case "orange":
      return "🍊";
    default:
      throw new Error(`未対応のフルーツ: ${fruit satisfies never}`);
  }
}

// APIレスポンスを判別可能なUnion型で定義
type ApiResponse =
  | { status: "success"; data: unknown }
  | { status: "error"; code: number; message: string }
  | { status: "loading" }
  | { status: "idle" };

function renderResponse(response: ApiResponse): string {
  switch (response.status) {
    case "success":
      return `データ取得成功: ${JSON.stringify(response.data)}`;
    case "error":
      return `エラー(${response.code}): ${response.message}`;
    case "loading":
      return "読み込み中...";
    case "idle":
      return "待機中";
    default:
      throw new Error(
        `未対応のステータス: ${response satisfies never}`
      );
  }
}

type PaymentMethod =
  | { type: "credit"; brand: "visa" | "mastercard" | "amex" }
  | { type: "bank"; bankCode: string }
  | { type: "wallet"; provider: "paypay" | "merpay" };

function getPaymentLabel(method: PaymentMethod): string {
  switch (method.type) {
    case "credit": {
      switch (method.brand) {
        case "visa":
          return "Visa";
        case "mastercard":
          return "Mastercard";
        case "amex":
          return "American Express";
        default:
          throw new Error(
            `未対応ブランド: ${method.brand satisfies never}`
          );
      }
    }
    case "bank":
      return `銀行振込(${method.bankCode})`;
    case "wallet": {
      switch (method.provider) {
        case "paypay":
          return "PayPay";
        case "merpay":
          return "メルペイ";
        default:
          throw new Error(
            `未対応プロバイダ: ${method.provider satisfies never}`
          );
      }
    }
    default:
      throw new Error(`未対応の決済手段: ${method satisfies never}`);
  }
}

npm install ts-pattern

import { match, P } from "ts-pattern";

type Event =
  | { type: "click"; x: number; y: number }
  | { type: "keydown"; key: string }
  | { type: "scroll"; delta: number };

function handleEvent(event: Event): string {
  return match(event)
    .with({ type: "click" }, (e) => `クリック: (${e.x}, ${e.y})`)
    .with({ type: "keydown" }, (e) => `キー入力: ${e.key}`)
    .with({ type: "scroll" }, (e) => `スクロール: ${e.delta}px`)
    .exhaustive();
}

// switch文 + satisfies（標準TypeScript）
function describeShape(shape: Shape): string {
  switch (shape.kind) {
    case "circle":
      return `半径${shape.radius}の円`;
    case "rectangle":
      return `${shape.width}×${shape.height}の矩形`;
    case "triangle":
      return `底辺${shape.base}、高さ${shape.height}の三角形`;
    default:
      throw new Error(`未対応: ${shape satisfies never}`);
  }
}

// ts-pattern（ライブラリ使用）
function describeShapeWithPattern(shape: Shape): string {
  return match(shape)
    .with({ kind: "circle" }, (s) => `半径${s.radius}の円`)
    .with({ kind: "rectangle" }, (s) => `${s.width}×${s.height}の矩形`)
    .with({ kind: "triangle" }, (s) => `底辺${s.base}、高さ${s.height}の三角形`)
    .exhaustive();
}

// eslint.config.js（Flat Config形式）
import tseslint from "typescript-eslint";

export default tseslint.config(
  ...tseslint.configs.recommended,
  {
    rules: {
      "@typescript-eslint/switch-exhaustiveness-check": [
        "error",
        {
          allowDefaultCaseForExhaustiveSwitch: false,
          requireDefaultForNonUnion: true,
        },
      ],
    },
  }
);

type CounterAction =
  | { type: "increment" }
  | { type: "decrement" }
  | { type: "reset"; value: number };

type CounterState = { count: number };

function counterReducer(
  state: CounterState,
  action: CounterAction
): CounterState {
  switch (action.type) {
    case "increment":
      return { count: state.count + 1 };
    case "decrement":
      return { count: state.count - 1 };
    case "reset":
      return { count: action.value };
    default:
      throw new Error(
        `未対応のアクション: ${action satisfies never}`
      );
  }
}

type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";

function buildFetchOptions(
  method: HttpMethod,
  body?: unknown
): RequestInit {
  switch (method) {
    case "GET":
      return { method: "GET" };
    case "POST":
      return { method: "POST", body: JSON.stringify(body) };
    case "PUT":
      return { method: "PUT", body: JSON.stringify(body) };
    case "DELETE":
      return { method: "DELETE" };
    case "PATCH":
      return { method: "PATCH", body: JSON.stringify(body) };
    default:
      throw new Error(
        `未対応のHTTPメソッド: ${method satisfies never}`
      );
  }
}

type ValidationError =
  | { kind: "required"; field: string }
  | { kind: "minLength"; field: string; min: number }
  | { kind: "maxLength"; field: string; max: number }
  | { kind: "pattern"; field: string; regex: string };

function formatError(error: ValidationError): string {
  switch (error.kind) {
    case "required":
      return `${error.field}は必須です`;
    case "minLength":
      return `${error.field}は${error.min}文字以上で入力してください`;
    case "maxLength":
      return `${error.field}は${error.max}文字以下で入力してください`;
    case "pattern":
      return `${error.field}の形式が正しくありません`;
    default:
      throw new Error(
        `未対応のバリデーション種別: ${error satisfies never}`
      );
  }
}

// NG: 網羅性チェックになっていない
function toLabel(status: Status): string {
  switch (status) {
    case "pending":
      return "保留中";
    case "approved":
      return "承認済み";
    default:
      return "不明"; // "rejected" の処理漏れに気付けない
  }
}

// NG: asで型を上書きするとexhaustive checkが無効化される
const status = response.status as "pending" | "approved";

{
  "compilerOptions": {
    "strict": true
  }
}

enum Direction {
  Up,    // 0
  Down,  // 1
  Left,  // 2
  Right, // 3
}

function move(d: Direction): void {
  switch (d) {
    case Direction.Up: break;
    case Direction.Down: break;
    case Direction.Left: break;
    case Direction.Right: break;
    default:
      // 数値enum はruntime で任意の数値が渡されうる
      throw new Error(`未対応: ${d satisfies never}`);
  }
}

// 型チェックをすり抜ける例
move(99 as Direction); // コンパイルエラーにならない

{
  "compilerOptions": {
    "strict": true,
    "noFallthroughCasesInSwitch": true,
    "noImplicitReturns": true
  }
}