API GraphQL con TypeScript: tutorial paso a paso — parte 3

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

API GraphQL con TypeScript: Tutorial paso a paso — Parte 3

En las partes anteriores del tutorial, cubrimos los conceptos básicos para crear un servidor GraphQL en TypeScript y aprendimos a configurar consultas simples. En esta parte final, profundizaremos en técnicas avanzadas: mutaciones, suscripciones y manejo de errores. Si estás aprendiendo TypeScript para principiantes y quieres dominar la programación moderna de APIs, este material será un gran paso adelante. Todo el aprendizaje se basa en ejemplos prácticos que podrás aplicar inmediatamente en tus proyectos.

1. Implementación de mutaciones con TypeScript

Las mutaciones son operaciones que modifican datos (crear, actualizar, eliminar). En GraphQL se indican con la palabra clave mutation. Vamos a crear una mutación para añadir un nuevo usuario.

Primero, definimos el tipo en el esquema GraphQL:

type Mutation {  addUser(name: String!, email: String!): User!}

Ahora implementamos el resolver en TypeScript. Observa la tipificación estricta:

import { Resolver, Mutation, Arg } from 'type-graphql';import { User } from '../entities/User';

@Resolver()export class UserResolver {  @Mutation(() => User)  async addUser(    @Arg('name') name: string,    @Arg('email') email: string  ): Promise<User> {    const user = new User();    user.name = name;    user.email = email;    await user.save();    return user;  }}

Importante: en TypeScript usamos los decoradores @Mutation y @Arg de la librería type-graphql, lo que hace que el código sea limpio y seguro en cuanto a tipos. Esto es especialmente útil para la programación de proyectos grandes, donde la previsibilidad es clave.

2. Suscripciones (Subscriptions) para tiempo real

Las suscripciones permiten a los clientes recibir actualizaciones en tiempo real a través de WebSocket. En TypeScript, su implementación requiere una configuración adicional del servidor.

Añadimos una suscripción para nuevos mensajes:

import { Subscription, Root } from 'type-graphql';

@Resolver()export class MessageResolver {  @Subscription(() => Message, {    topics: 'NEW_MESSAGE',  })  newMessage(@Root() message: Message): Message {    return message;  }}

Para publicar el evento usamos pubSub.publish('NEW_MESSAGE', message). Esto permite crear un chat o notificaciones en tiempo real. Las suscripciones son una herramienta poderosa en el arsenal de la programación, y TypeScript hace que su implementación sea segura gracias a la tipificación estática.

3. Manejo de errores y validación

Un manejo adecuado de errores es clave para una API confiable. En TypeScript podemos usar clases de error personalizadas:

import { ApolloError } from 'apollo-server-express';

export class UserInputError extends ApolloError {  constructor(message: string) {    super(message, 'USER_INPUT_ERROR');    Object.defineProperty(this, 'name', { value: 'UserInputError' });  }}

En los resolvers validamos los datos de entrada:

@Mutation(() => User)async createUser(@Arg('email') email: string) {  if (!email.includes('@')) {    throw new UserInputError('Formato de email inválido');  }  // ... lógica de creación}

También podemos usar decoradores de validación de class-validator:

import { IsEmail, Length } from 'class-validator';

class CreateUserInput {  @Length(2, 50)  name: string;

  @IsEmail()  email: string;}

Este enfoque lo recomiendo especialmente para TypeScript para principiantes, ya que automatiza la verificación de datos y reduce la cantidad de errores.