tRPC End-to-End Type Safe APIs · Leçon

Gérer les erreurs tRPC avec élégance

Appliquez les bonnes pratiques pour intercepter les erreurs et y répondre dans les procédures et les intergiciels tRPC.

Gérer les erreurs tRPC avec élégance est une leçon tRPC End-to-End Type Safe APIs gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage tRPC End-to-End Type Safe APIs, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours tRPC End-to-End Type Safe APIs comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

API Errors: A Necessary Evil

In any robust API, errors are inevitable. Users might send invalid data, resources might not exist, or external services could fail.

Implementing graceful error handling is crucial for creating stable and user-friendly applications. It allows your API to respond predictably and informatively.

How tRPC Handles Errors

By default, tRPC automatically catches any JavaScript errors thrown within your procedures or middleware. It serializes them and sends them to the client.

Generic errors are often mapped to an INTERNAL_SERVER_ERROR (HTTP 500) status on the client side if not explicitly handled. Try running this example to see a generic error.

function fetchData(shouldFail: boolean) {
  if (shouldFail) {
    throw new Error("Something went wrong on the server!");
  }
  return "Data fetched successfully.";
}

function main() {
  try {
    console.log("Attempting to fetch (success):");
    console.log(fetchData(false));
  } catch (error: any) {
    // This catch block demonstrates local error handling
    // tRPC server would catch and serialize if not handled here
    console.log(`Caught error: ${error.message}`);
  }

  try {
    console.log("\nAttempting to fetch (fail):");
    fetchData(true);
  } catch (error: any) {
    console.log(`Caught error: ${error.message}`);
  }
}

main();

Standardizing with TRPCError

To provide structured and predictable error responses, tRPC offers the TRPCError class. This is tRPC's dedicated way to throw API-specific errors.

TRPCError allows you to specify a code (like an HTTP status) and a human-readable message.
It ensures consistent error payloads, making it easier for clients to interpret and react to different error types.

Anatomy of TRPCError

When you create a TRPCError, you pass an object with a code and a message. The code maps to standard HTTP status codes (e.g., NOT_FOUND, UNAUTHORIZED).

This example shows how to throw different TRPCError types based on conditions.

import { TRPCError } from '@trpc/server';

function simulateError(type: string) {
  if (type === 'not_found') {
    throw new TRPCError({
      code: 'NOT_FOUND',
      message: 'Resource does not exist.'
    });
  }
  if (type === 'bad_input') {
    throw new TRPCError({
      code: 'BAD_REQUEST',
      message: 'Invalid input provided.'
    });
  }
  return 'No error was simulated.';
}

function main() {
  try {
    console.log("Simulating 'not_found' error:");
    simulateError('not_found');
  } catch (error: any) {
    if (error instanceof TRPCError) {
      console.log(`TRPC Error Code: ${error.code}`);
      console.log(`TRPC Error Message: ${error.message}`);
    } else {
      console.log(`Generic Error: ${error.message}`);
    }
  }
}

Handling Errors in Procedures

Your tRPC procedures contain the core business logic. It's good practice to wrap operations that might fail (like database calls or API requests) in try...catch blocks.

Inside the catch block, you can translate generic errors into specific TRPCError instances, providing clear feedback to the client.

Example: Procedure Error Handling

This example simulates a procedure trying to fetch a user from a database. It handles both a missing user and a database connection error, converting them into appropriate TRPCError types.

import { TRPCError } from '@trpc/server';

// Simulate a database call
function fetchUserFromDB(id: string) {
  if (id === 'db_error') {
    throw new Error("Database connection failed!");
  }
  if (id === '123') {
    return { id: '123', name: 'Alice' };
  }
  return null;
}

// Simulate a tRPC query procedure
function getUserQuery(userId: string) {
  try {
    const user = fetchUserFromDB(userId);
    if (!user) {
      throw new TRPCError({
        code: 'NOT_FOUND',
        message: 'User not found.'
      });
    }
    return user;
  } catch (error: any) {
    if (error instanceof TRPCError) {
      throw error; // Re-throw tRPC errors directly
    }
    // Catch generic errors and convert them to TRPCError
    throw new TRPCError({
      code: 'INTERNAL_SERVER_ERROR',
      message: `Failed to fetch user: ${error.message}`
    });
  }
}

function main() {
  try {
    console.log("Fetching user '123':");
    console.log(getUserQuery('123'));
  } catch (error: any) {
    console.log(`Error: ${error.code} - ${error.message}`);
  }

  try {
    console.log("\nFetching user 'db_error':");
    getUserQuery('db_error');
  } catch (error: any) {
    console.log(`Error: ${error.code} - ${error.message}`);
  }
}

Error Handling in Middleware

tRPC middleware functions are executed before procedures. They are ideal for global checks like authentication, authorization, or logging.

If a middleware function throws a TRPCError, the procedure it guards will not execute, and the error will be immediately propagated to the client. This is powerful for protecting your API.

Example: Middleware Authorization Error

This middleware checks if the user has an 'admin' role. If not, it throws an UNAUTHORIZED error, preventing any subsequent procedure from running.

This ensures only authorized users can proceed.

import { TRPCError } from '@trpc/server';

// Simulate a tRPC middleware logic
// In a real tRPC app, `ctx` would contain user info
function authMiddleware(userRole: string) {
  if (userRole !== 'admin') {
    throw new TRPCError({
      code: 'UNAUTHORIZED',
      message: 'You are not authorized to perform this action.'
    });
  }
  return { success: true, message: 'Authorized' }; // Simulates `next()`
}

function main() {
  console.log("Attempting with 'user' role:");
  try {
    authMiddleware('user');
  } catch (error: any) {
    if (error instanceof TRPCError) {
      console.log(`Middleware Error: ${error.code} - ${error.message}`);
    }
  }

  console.log("\nAttempting with 'admin' role:");
  try {
    authMiddleware('admin');
    console.log("Middleware passed: User is an admin!");
  } catch (error: any) {
    console.log("This block should not be reached for admin.");
  }
}

main();

Client-Side Error Propagation

When your tRPC server throws a TRPCError, the tRPC client receives a structured error object. This object typically contains:

code: The tRPC error code (e.g., 'NOT_FOUND').
message: The descriptive error message.
data: Additional error data, including the HTTP status code.

This allows your frontend to react specifically to different error types, improving user experience.

Error Handling Check

Consider a tRPC procedure that fetches a blog post. If the user making the request is authenticated but does not have the necessary permissions to view that specific post, what TRPCError code would be most appropriate to throw?

Recap: Graceful Errors

You've learned how to handle errors gracefully in tRPC!

tRPC automatically catches generic errors, but TRPCError provides structure.
Use TRPCError with specific codes (like NOT_FOUND, UNAUTHORIZED) and messages.
Implement try...catch in procedures to convert generic errors into TRPCErrors.
Leverage middleware to enforce global checks (e.g., authentication) by throwing TRPCErrors early.
Clients receive structured error objects, enabling better frontend error handling.

Questions Fréquemment Posées

La leçon « Gérer les erreurs tRPC avec élégance » est-elle gratuite ?

Oui — le texte complet de « Gérer les erreurs tRPC avec élégance » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours tRPC End-to-End Type Safe APIs, passe à CoddyKit PRO. Le cours tRPC End-to-End Type Safe APIs comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gérer les erreurs tRPC avec élégance » ?

Appliquez les bonnes pratiques pour intercepter les erreurs et y répondre dans les procédures et les intergiciels tRPC. Tu pratiques tRPC End-to-End Type Safe APIs avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer tRPC End-to-End Type Safe APIs ?

Aucune expérience préalable n'est requise. tRPC End-to-End Type Safe APIs sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Gérer les erreurs tRPC avec élégance » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon tRPC End-to-End Type Safe APIs ?

Oui. Chaque leçon tRPC End-to-End Type Safe APIs inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Gérer les erreurs tRPC avec élégance
Types d’erreurs personnalisés
Transformateurs de données pour la sérialisation
Mise en forme des erreurs et retours de validation au niveau des champs

← Retour à tRPC End-to-End Type Safe APIs