tRPC End-to-End Type Safe APIs · Aula

Tratando erros do tRPC adequadamente

Implemente as melhores práticas para capturar e responder a erros em procedimentos e middleware do tRPC.

Tratando erros do tRPC adequadamente é uma aula grátis de tRPC End-to-End Type Safe APIs no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de tRPC End-to-End Type Safe APIs, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de tRPC End-to-End Type Safe APIs inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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.

Perguntas Frequentes

A aula “Tratando erros do tRPC adequadamente” é grátis?

Sim — o texto completo de “Tratando erros do tRPC adequadamente” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de tRPC End-to-End Type Safe APIs, atualize para CoddyKit PRO. O curso de tRPC End-to-End Type Safe APIs inclui 4 aulas no total.

O que vou aprender em “Tratando erros do tRPC adequadamente”?

Implemente as melhores práticas para capturar e responder a erros em procedimentos e middleware do tRPC. Você pratica tRPC End-to-End Type Safe APIs com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar tRPC End-to-End Type Safe APIs?

Nenhuma experiência prévia é necessária. tRPC End-to-End Type Safe APIs no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Tratando erros do tRPC adequadamente”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de tRPC End-to-End Type Safe APIs?

Sim. Cada aula de tRPC End-to-End Type Safe APIs inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Tratando erros do tRPC adequadamente
Tipos de erro personalizados
Transformadores de dados para serialização
Formatação de erros e retorno de validação por campo

← Voltar para tRPC End-to-End Type Safe APIs