Enhancing Safety in TypeScript: Exhaustive Checks for Switch Cases

This article reviews how you can enforce switch case exhaustiveness by either using a global Eslint rule or explicitly enforcing it via the usage of assertNever.

assertNever approach

While you can use ESLINT rule that is type aware like switch-exhaustiveness-check

You can also make this approach more explicit allowing better control to when you want to make the switch-case strict or not.

/**
 * The `assertNever` function is used for exhaustiveness checks in TypeScript.
 * It acts as a safeguard in switch statements where all possible cases of an enum are meant to be handled.
 * If a new case is added to the enum and not handled in the switch, calling this function will cause a TypeScript
 * compile-time error, alerting the developer that a case has been missed.
 *
 * Usage:
 * In a switch statement, use the `assertNever` function in the default case. Pass the variable being switched on
 * to the function. If all enum cases are handled, the function will never be called. If an unhandled case exists,
 * TypeScript will throw an error because the function expects a type of `never`, which indicates an unreachable code
 * segment under normal circumstances.
 *
 * Example:
 * switch (myEnumValue) {
 *   case MyEnum.FirstCase:
 *     // Handle first case
 *     break;
 *   case MyEnum.SecondCase:
 *     // Handle second case
 *     break;
 *   default:
 *     assertNever(myEnumValue); // TypeScript will error if a new MyEnum case is not handled.
 * }
 */
export function assertNever(x: never): never {
	throw new Error(`Unexpected object: ${x}`);
}

Examples

This forces the switch-case to handle all cases.

switch (transferType) {
    case 'withdrawal':
    case 'deposit':
      currency = {
        code: transfer?.amount?.currency,
        type: 'fiat' as CurrencyType,
      };
      break;
    default:
      assertNever(transferType);

Even when you are returning something, you can return assertNever to ensure there is always a valid return.

return useMemo(() => {
	switch (execution) {
		case "allowTaker":
			return formatMessage(messages.executionTrayOptionAllowTaker);
		case "postOnly":
			return formatMessage(messages.executionTrayOptionPostOnly);
		default:
			return assertNever(execution);
	}
}, [execution, formatMessage]);

This also allows you to explicitly opt out by returning undefined instead. Particularly nice to keep the return type consistent and not imply undefined.

switch (tradeType) {
	case "Buy":
	case "Sell":
		return Analytics.track("convert_tapped_source_asset", params);
	case "ConvertTo":
		return Analytics.track("convert_tapped_target_asset", params);
	default:
		return undefined;
}

Use this paired with the default-case lint rule to enforce everyone to always handle a default case intentionally.