GraphQL vs REST: Cuándo Usar Cada Uno

Comparativa Completa: GraphQL vs REST

Ambas tecnologías tienen sus ventajas. Aprende cuándo usar cada una para tomar la mejor decisión arquitectónica.

REST API

Ventajas

• Simple y bien entendido
• Caching HTTP nativo
• Herramientas maduras
• Fácil de debuggear

Ejemplo REST

// Obtener usuario
GET /api/users/123

// Obtener posts del usuario (requiere otra petición)
GET /api/users/123/posts

// Obtener comentarios de un post (otra petición más)
GET /api/posts/456/comments

GraphQL

Ventajas

• Una sola petición para datos relacionados
• Cliente pide exactamente lo que necesita
• Tipado fuerte
• Introspección automática

Ejemplo GraphQL

query {
  user(id: "123") {
    name
    email
    posts {
      title
      comments {
        text
        author {
          name
        }
      }
    }
  }
}

Cuándo Usar REST

• APIs públicas simples
• Necesitas caching HTTP agresivo
• Operaciones CRUD básicas
• Equipo sin experiencia en GraphQL
• Microservicios independientes

Cuándo Usar GraphQL

• Aplicaciones con datos altamente relacionados
• Múltiples clientes con necesidades diferentes
• Necesitas reducir over-fetching/under-fetching
• Desarrollo rápido de features
• Real-time con subscriptions

Implementación GraphQL con Apollo

// Schema
type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
  comments: [Comment!]!
}

type Query {
  user(id: ID!): User
  users: [User!]!
}

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

// Resolvers
const resolvers = {
  Query: {
    user: (_, { id }) => getUserById(id),
    users: () => getAllUsers()
  },
  Mutation: {
    createUser: (_, { name, email }) => createUser({ name, email })
  },
  User: {
    posts: (user) => getPostsByUserId(user.id)
  },
  Post: {
    author: (post) => getUserById(post.authorId),
    comments: (post) => getCommentsByPostId(post.id)
  }
};

Cliente GraphQL en Angular

import { Apollo, gql } from 'apollo-angular';

const GET_USER = gql`
  query GetUser($id: ID!) {
    user(id: $id) {
      name
      email
      posts {
        title
      }
    }
  }
`;

export class UserComponent {
  user$ = this.apollo.query({
    query: GET_USER,
    variables: { id: '123' }
  }).pipe(
    map(result => result.data.user)
  );
  
  constructor(private apollo: Apollo) {}
}

Problemas Comunes de GraphQL

1. N+1 Problem

// ❌ Problema: Una query por cada post
Post: {
  author: (post) => getUserById(post.authorId)
}

// ✅ Solución: DataLoader
import DataLoader from 'dataloader';

const userLoader = new DataLoader(async (ids) => {
  const users = await getUsersByIds(ids);
  return ids.map(id => users.find(u => u.id === id));
});

Post: {
  author: (post) => userLoader.load(post.authorId)
}

2. Query Complexity

// Limitar profundidad de queries
import { createComplexityLimitRule } from 'graphql-validation-complexity';

const server = new ApolloServer({
  schema,
  validationRules: [
    createComplexityLimitRule(1000)
  ]
});

Hybrid Approach

Puedes usar ambos:

// REST para operaciones simples
GET /api/health
POST /api/auth/login

// GraphQL para queries complejas
POST /graphql
{
  query: "..."
}

Conclusión

No hay una respuesta única. REST es excelente para APIs simples y públicas. GraphQL brilla en aplicaciones complejas con datos relacionados. Evalúa tus necesidades específicas antes de decidir.