El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Resolvers

Siguiente ►
►

En GraphQL, los resolvers son funciones que se encargan de obtener los datos para cada campo en una consulta. Son una parte fundamental del servidor GraphQL, ya que permiten conectar el esquema de GraphQL con las fuentes de datos subyacentes, como bases de datos, APIs externas, etc.

Conceptos Clave

  1. Resolver: Una función que obtiene el valor de un campo en el esquema de GraphQL.
  2. Parent: El objeto que contiene el campo que está siendo resuelto.
  3. Args: Un objeto que contiene los argumentos pasados a la consulta.
  4. Context: Un objeto compartido entre todos los resolvers que se ejecutan para una operación específica.
  5. Info: Información sobre la ejecución de la consulta, incluyendo el esquema, el campo, etc.

Estructura de un Resolver

Un resolver típico tiene la siguiente estructura:

const resolver = (parent, args, context, info) => {
  // Lógica para obtener el dato
  return data;
};
  • parent: El resultado del resolver del campo padre.
  • args: Los argumentos pasados a la consulta.
  • context: Un objeto que contiene información compartida entre resolvers.
  • info: Información sobre la ejecución de la consulta.

Ejemplo Práctico

Supongamos que tenemos el siguiente esquema de GraphQL:

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

type User {
  id: ID!
  name: String!
  age: Int!
}

Para resolver la consulta user, necesitamos definir un resolver que obtenga el usuario por su ID. Aquí hay un ejemplo de cómo hacerlo:

Definición del Resolver

const resolvers = {
  Query: {
    user: (parent, args, context, info) => {
      // Simulamos una base de datos con un array de usuarios
      const users = [
        { id: '1', name: 'Alice', age: 25 },
        { id: '2', name: 'Bob', age: 30 },
      ];

      // Buscamos el usuario por ID
      return users.find(user => user.id === args.id);
    },
  },
};

Explicación del Código

  1. Query.user: Definimos un resolver para el campo user en el tipo Query.
  2. args: Utilizamos args.id para obtener el ID del usuario que se está buscando.
  3. users.find: Buscamos en el array de usuarios el que tenga el ID correspondiente y lo devolvemos.

Ejercicio Práctico

Ejercicio 1: Resolver para Obtener una Lista de Usuarios

Dado el siguiente esquema, define un resolver para obtener una lista de usuarios.

type Query {
  users: [User]
}

type User {
  id: ID!
  name: String!
  age: Int!
}

Solución

const resolvers = {
  Query: {
    users: (parent, args, context, info) => {
      // Simulamos una base de datos con un array de usuarios
      const users = [
        { id: '1', name: 'Alice', age: 25 },
        { id: '2', name: 'Bob', age: 30 },
      ];

      // Devolvemos la lista de usuarios
      return users;
    },
  },
};

Ejercicio 2: Resolver para Obtener un Usuario por Nombre

Dado el siguiente esquema, define un resolver para obtener un usuario por su nombre.

type Query {
  userByName(name: String!): User
}

type User {
  id: ID!
  name: String!
  age: Int!
}

Solución

const resolvers = {
  Query: {
    userByName: (parent, args, context, info) => {
      // Simulamos una base de datos con un array de usuarios
      const users = [
        { id: '1', name: 'Alice', age: 25 },
        { id: '2', name: 'Bob', age: 30 },
      ];

      // Buscamos el usuario por nombre
      return users.find(user => user.name === args.name);
    },
  },
};

Errores Comunes y Consejos

  1. No manejar errores: Asegúrate de manejar posibles errores, como cuando no se encuentra un usuario.

    user: (parent, args, context, info) => {
  const user = users.find(user => user.id === args.id);
  if (!user) {
    throw new Error('User not found');
  }
  return user;
}

  2. No usar el contexto adecuadamente: Utiliza el contexto para pasar información compartida, como la conexión a la base de datos.

    user: (parent, args, context, info) => {
  return context.db.findUserById(args.id);
}

Conclusión

Los resolvers son el puente entre el esquema de GraphQL y las fuentes de datos. Entender cómo funcionan y cómo implementarlos correctamente es crucial para construir aplicaciones GraphQL robustas y eficientes. En el siguiente tema, exploraremos los diferentes tipos de datos que puedes definir en GraphQL, lo que te permitirá crear esquemas más complejos y útiles.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados