Implémentation d'un type Result léger en TypeScript

La gestion des erreurs pour les opérations asynchrones est souvent écrite avec try-catch, mais l’endroit où les exceptions se produisent et l’endroit où elles sont gérées ont tendance à diverger. Avec le pattern du type Result, vous pouvez séparer explicitement le succès et l’échec en tant que valeurs de retour.

Prérequis : Conversion vers le type Error

Un helper pour convertir de manière fiable les erreurs de type unknown en type Error.

export function toError(error: unknown): Error {
  if (error instanceof Error) return error;
  return new Error(error as never);
}

Définition du type Result

interface Failure {
  data: undefined;
  error: Error;
}

interface Success<T> {
  data: T;
  error: undefined;
}

type Result<T> = Success<T> | Failure;

Exemple d’implémentation du wrapper fetch

import { toError } from './toError.js'

export async function fetcher<T>(
  url: RequestInfo,
  init?: RequestInit
): Promise<Result<T>> {
  const UNDEF = undefined;

  // Lorsque fetch échoue (erreurs réseau, etc.)
  const response = await fetch(url, init).catch(toError);
  if (response instanceof Error) {
    return { data: UNDEF, error: response };
  }

  // Réponses d'erreur HTTP
  if (!response.ok) {
    return {
      data: UNDEF,
      error: new Error(`HTTP ${response.status}: ${response.statusText}`)
    };
  }

  // Succès
  const data = await response.json();
  return { data, error: UNDEF };
}

Exemple d’utilisation

const result = await fetcher<User>("/api/user/123");

if (result.error) {
  console.error("Échec de la récupération:", result.error.message);
  return;
}

// Lorsque result.error est undefined, TypeScript infère result.data comme T
console.log(result.data.name);

Avantages et considérations

Avantages:

• Le succès et l’échec deviennent clairs grâce au type de retour
• Moins de blocs try-catch améliorent la lisibilité
• La gestion des erreurs peut être imposée (l’omission provoque des erreurs de type)

Considérations:

• Si la proposition ECMAScript Safe Assignment Operator est standardisée, une fonctionnalité similaire intégrée pourrait devenir disponible
• Pas aussi complet que les types Result intégrés au langage de Go ou Rust
• La gestion détaillée des erreurs comme les erreurs de validation nécessite une implémentation séparée

L’implémentation est simple, mais elle est efficace lorsque vous souhaitez gérer les erreurs de manière type-safe dans des projets de petite taille.