GraphQL API com TypeScript: tutorial passo a passo — parte 3

Nas partes anteriores do tutorial, abordamos os fundamentos da criação de um servidor GraphQL em TypeScript e aprendemos a configurar consultas simples. Nesta parte final, vamos nos aprofundar em técnicas avançadas: mutações, subscrições e tratamento de erros. Se você está estudando TypeScript para iniciantes e quer dominar a programação moderna de APIs, este material será um ótimo passo adiante. Todo o aprendizado é baseado em exemplos práticos que você pode aplicar imediatamente em seus projetos.

1. Implementação de mutações com TypeScript

Mutações são operações de modificação de dados (criação, atualização, exclusão). Em GraphQL, elas são indicadas pela palavra-chave mutation. Vamos criar uma mutação para adicionar um novo usuário.

Primeiro, definimos o tipo no esquema GraphQL:

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

Agora implementamos o resolver em TypeScript. Observe a tipagem estrita:

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: em TypeScript, usamos os decoradores @Mutation e @Arg da biblioteca type-graphql, o que torna o código limpo e type-safe. Isso é especialmente útil para programação de grandes projetos, onde a previsibilidade é essencial.

2. Subscrições (Subscriptions) para tempo real

Subscrições permitem que os clientes recebam atualizações em tempo real via WebSocket. Em TypeScript, sua implementação requer configuração adicional do servidor.

Vamos adicionar uma subscrição para novas mensagens:

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

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

Para publicar o evento, usamos pubSub.publish('NEW_MESSAGE', message). Isso permite criar um chat ou notificações em tempo real. Subscrições são uma ferramenta poderosa no arsenal da programação, e o TypeScript torna sua implementação segura graças à tipagem estática.

3. Tratamento de erros e validação

Um tratamento adequado de erros é a chave para uma API confiável. Em TypeScript, podemos usar classes de erro 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' });  }}

Nos resolvers, validamos os dados de entrada:

@Mutation(() => User)async createUser(@Arg('email') email: string) {  if (!email.includes('@')) {    throw new UserInputError('Invalid email format');  }  // ... lógica de criação}

Também podemos usar decoradores de validação do class-validator:

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

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

  @IsEmail()  email: string;}

Recomendo especialmente essa abordagem para TypeScript para iniciantes, pois ela automatiza a verificação de dados e reduz a quantidade de bugs.

4. Otimização de desempenho

Para projetos em produção, é importante evitar o problema N+1. Use DataLoader para