Resolvers

Clase 28 de 45 • Curso de GraphQL 2016

Contenido del curso

Conceptos Generales de GraphQL

Construyendo Esquemas a través de Tipos

Las Herramientas de GraphQL

Proyecto

Conclusiones

43
¿Cuándo usar GraphQL?
03:43 min

Contenido Bonus

Tomar examen

Comentarios

Julio J Yépez

student•

Los resolvers pueden devolver o bien los datos o bien una Promesa. Lo cual es muy conveniente si dichos datos son a su vez extraídos desde otros servidores o incluso desde otros REST/APIs.

Enzo Aliatis

student•

Si estas viendo este curso en el ultimo trimestre del 2018
te dejo mi repo

API Graph

Néstor Fabián Gonzalez

student•

Como manejar toda la parte de Autenticación de usuarios. 😄

Julio Hurtado

student•

Los resolvers pueden devolver promesas

Gregory Hernandez Abad

student•

Tengo una cuestion y es que puedo poner la lista de cursos en una funcion que tiene un parametro opcional para listar el curso de ID que se le pase. Cuando pido la lista me sale perfectamente, pero cuando le paso un parametro no sale nada. Por que?

const { makeExecutableSchema } = require('graphql-tools');
const typeDefs = `
    # Curso entity
    type Curso {
        id: ID!
        titulo: String!
        # Descripcion field is to put all your comment body
        descripcion: String!
        profesor: Profesor
        rating: Float @deprecated(reason: "We do not longer need rating points")
        comentarios: [Comentario]
    }

    type Profesor {
        id: ID!
        nombre: String!
        nacionalidad: String!
        genero: Genero
        cursos: [Curso]
    }

    enum Genero {
        MASCULINO
        FEMENINO
    }

    type Comentario {
        id: ID!
        userName: String!
        cuerpo: String!
    }

    type Query {
        cursos: [Curso]
        profesores: [Profesor]
        curso(id: Int): Curso
        profesor(id: Int): Profesor
    }
`;

function hardCourses(id = -1) {
    let index = id - 1;
    let lib = [{
        id: 1,
        titulo: "Curso de GraphQl",
        descripcion: "Aprendiendo GraphQL",
    },
    {
        id: 2,
        titulo: "Curso de PHP",
        descripcion: "Aprendiendo PHP",
    }];

    return id == -1 ? lib : lib[index];
}

console.log('tersting something');

const resolvers = {
    Query: {
        cursos: () => {
            return hardCourses()
        },
        curso: (id) => {
            return hardCourses(id);
        },
        profesores: () => {
            return [
                {
                    id: 1,
                    nombre: "Gregory Hernandez",
                    nacionalidad: "Dominicana",
                    cursos: [{
                        id:3,
                        titulo: "Curso PHP Avanzado",
                        descripcion: "Ya no hay que decirte mas"
                    }]
                },
                {
                    id: 2,
                    nombre: "Pablo Medina",
                    nacionalidad: "Dominicana",
                    cursos: [{
                        id:4,
                        titulo: "Curso JavaScript",
                        descripcion: "Ya no hay que decirte mas"
                    }]
                }
            ]
        },
        
    }
}

const schema = makeExecutableSchema ({
    typeDefs,
    resolvers
});

module.exports = schema;

Eddy Arellanes

student•

Ejemplo de resolvers con TypeORM(Llama un BD de Postgres)

import { getRepository } from &quot;typeorm&quot;;
import {Wallet} from '../entities/Wallet';

export const resolvers = {
  async wallets(id) {
    console.log('ID', id);
    let data = [];
    if(id) {
      const response = await getRepository(Wallet).findOne(id); 
      if(response) data.push(response);
    }
    else  data = await getRepository(Wallet).find({order: {name: &quot;ASC&quot;}});
    return data;
  }
};

Julio J Yépez

student•

Al devolver el profesor en resolver, ¿por qué, en el ejemplo, no da error en los campos requeridos?

type Profesor {
    id          : ID!
    nombre      : String!
    nacionalidad: String!
    genero      : Genero
  }

Julio J Yépez

student•

De hecho, a mí sí me está devolviendo un error (como sería lo esperado):

(...)
  "errors": [
    {
      "message": "Cannot return null for non-nullable field Profesor.id.",
(...)

Ya que sólo se le está suministrando al esquema el dato “nombre” y no todos los requeridos …

Julio J Yépez

student•

Ya ví lo que pasa.
El error es devuelto únicamente si alguno de los campos requeridos es solicitado al endpoint … de lo contrario, no se mostrará el error.

Me mostró el error antes porque mi consulta al endpoint fue:

{
  cursos {
    id
    titulo
    profesor {
      id
    }
  }
}

Carlos Rojas Latorre

student•

Hola Pablo, una consulta ¿como puedo pasarle al resolver lo que me llego en el request de express? me explico, quiero hacer la consulta a la base de datos solo por los atributos del schema que me piden en el JSON, esto para no traer toda la tabla entera

Saludos!

Pablo Chiappetti

teacher•

Hola! La manera recomendada para hacer eso es utilizando lo que en Apollo Server se denomina context. Es una de las opciones que le pasas a graphqlExpress() y que luego recibirás en los resolvers como tercer parámetro. Puedes pasar lo que quieras como context, así que lo recomendado para tu caso es utilizar un objeto similar a { user: ... } lo cual deja lugar a futuras modificaciones.

José Carlos Quichiz Santome

student•

El concepto de resolvers me suena mas a el concepto de Modelo que a Controlador, pues es la data que estamos usando

Diego Forero

Team Platzi•

Es el controlador ya que es el que resuelve la lógica de que mostrar dependiendo de la query que recibe, ademas en los resolvers puedes tener lógica que permita por ejemplo mostrar tu email solo si la petición la haces tu como usuario logueado, o mostrarlo solo a usuarios logueados.

Billi Ramirez

student•

En el modelo se definen los atributos de las entidades y sus relaciones con otras entidades. En el controlador aplica mas la logica del negocio.

const { makeExecutableSchema } = require('graphql-tools');
const typeDefs = `
    # Curso entity
    type Curso {
        id: ID!
        titulo: String!
        # Descripcion field is to put all your comment body
        descripcion: String!
        profesor: Profesor
        rating: Float @deprecated(reason: "We do not longer need rating points")
        comentarios: [Comentario]
    }

    type Profesor {
        id: ID!
        nombre: String!
        nacionalidad: String!
        genero: Genero
        cursos: [Curso]
    }

    enum Genero {
        MASCULINO
        FEMENINO
    }

    type Comentario {
        id: ID!
        userName: String!
        cuerpo: String!
    }

    type Query {
        cursos: [Curso]
        profesores: [Profesor]
        curso(id: Int): Curso
        profesor(id: Int): Profesor
    }
`;

function hardCourses(id = -1) {
    let index = id - 1;
    let lib = [{
        id: 1,
        titulo: "Curso de GraphQl",
        descripcion: "Aprendiendo GraphQL",
    },
    {
        id: 2,
        titulo: "Curso de PHP",
        descripcion: "Aprendiendo PHP",
    }];

    return id == -1 ? lib : lib[index];
}

console.log('tersting something');

const resolvers = {
    Query: {
        cursos: () => {
            return hardCourses()
        },
        curso: (id) => {
            return hardCourses(id);
        },
        profesores: () => {
            return [
                {
                    id: 1,
                    nombre: "Gregory Hernandez",
                    nacionalidad: "Dominicana",
                    cursos: [{
                        id:3,
                        titulo: "Curso PHP Avanzado",
                        descripcion: "Ya no hay que decirte mas"
                    }]
                },
                {
                    id: 2,
                    nombre: "Pablo Medina",
                    nacionalidad: "Dominicana",
                    cursos: [{
                        id:4,
                        titulo: "Curso JavaScript",
                        descripcion: "Ya no hay que decirte mas"
                    }]
                }
            ]
        },
        
    }
}

const schema = makeExecutableSchema ({
    typeDefs,
    resolvers
});

module.exports = schema;

import { getRepository } from &quot;typeorm&quot;;
import {Wallet} from '../entities/Wallet';

export const resolvers = {
  async wallets(id) {
    console.log('ID', id);
    let data = [];
    if(id) {
      const response = await getRepository(Wallet).findOne(id); 
      if(response) data.push(response);
    }
    else  data = await getRepository(Wallet).find({order: {name: &quot;ASC&quot;}});
    return data;
  }
};

Resolvers

Conceptos Generales de GraphQL

Por qué aprender GraphQL

Orígenes de GraphQL

GraphQL vs REST

Construyendo Esquemas a través de Tipos

El Schema - Types

Scalars

Objects

Enum

Interface

Union

Modificadores de tipo

Root Type: Query

Root Type: Mutation

Las Herramientas de GraphQL

Aclaración antes de empezar éste modulo

La Interfaz de GraphiQL

Queries

Argumentos

Variables

Aliases

Fragments

Inline Fragments

Directives

Mutations

Input Types

Proyecto

Presentación del Proyecto

Inicialización del Proyecto

Creación del Esquema

Deprecación de Campos

Resolvers

Desafío: Terminar los Resolvers

Mocking

Implementación de Bases de Datos

Resolviendo a Base de Datos

Modularización del Esquema

Mutaciones: Creando Registros

Mutaciones: Editando Registros

Mutaciones: Eliminando Registros

Desafío: Terminar de Crear las Mutaciones

Implementando la Búsqueda

Manejo de Errores

Usando GraphQl fuera de GraphiQL

Los Clientes de GraphQL: Apollo vs Relay

Implementación de Apollo Client

Conclusiones

¿Cuándo usar GraphQL?

Contenido Bonus

Herramientas de la Comunidad

GraphQL Real Time con Subscriptions