Implementando la Búsqueda

Clase 38 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

Alexander Velasquez

student•

EL BUSCAR HARDCODEADO??? Noooo… Siento que no se tuvo que haber dejado pasar por alto algo tan importante como era la funcionalidad del BUSCAR, y no simplemente “cablearlo” o “hardcodearlo” ya que es fundamental en este tipo de servicios. El “no profundizar” en un aspecto no quiere decir “dejar pasar cosas importantes”. Así como hubo videos de 40 segundos, creo que se pudo haber explicado en este un poco más de dicha funcionalidad, que en lo personal: la estaba esperando. Creo que en lo que va de curso, este es es el único video donde he quedado con 2000 dudas !.. de resto, todo excelente !.

Steven Anaya

student•

Desde mi punto de vista, esa parte es prescindible en el curso ya que va ligado demasiado a la lógica de negocio. Si quieres no dejarlo Hardcodeado solo cambias por un método que busque por el campo y listo.

Juan Diego Silva Garcia

student•

Si, La parte de búsqueda en los ORM tiene que ver demasiado con la lógica de negocio. Aquí hay un ejemplo muy bueno donde se explica muy bien esta parte y como implementarlo.

Julio J Yépez

student•

No me queda muy claro, cómo es que el key

  ResultadoBusqueda: {
    __resolveType: obj => obj.nombre ? 'Profesor' : 'Curso'
  }

está asociado al union ResultadoBusqueda … y cómo el valor retornado por éste resuelve la dicotomía en buscar …

¿Sólo por llamarse de la misma forma?

Julio J Yépez

student•

Pareciera que es un requerimiento de Apollo … segpun explica Pablo en min 05:43 s

José Iván Sandoya

student•

Por lo visto entendería que GraphQL detecta que has declarado un type Union y espera que en los resolvers describas su __resolveType para cada uno respectivamente.
__resolveType por su parte recibe un parámetro que en la implementación se lo llamó obj el cual contiene data que (para este caso específico al evaluar su atributo nombre) nos permitió resolver la dicotomía.

Julio Hurtado

student•

De esa forma se le dice a GraphQL como resolver la dicotomía; se debe preguntar por una propiedad que diferencie a los Objetos que forman parte de la mutation

Matias Niz

student•

Si no quisiera consultar por un atributo especifico, como por ejemplo aqui el nombre que es un atribuo que tiene profesor y no lo tiene curso, existe una manera de consultar de que type es sin usar sus atributos?

Diego Forero

Team Platzi•

Usando Apollo no es posible, la documentación actualizada se usa como lo indica el profesor en este material.

Jorge Méndez Ortega

student•

entonces como funciona la variable query?, ya que veo que se hace de manera hardcore la busqueda

Diego Forero

Team Platzi•

Se debe cambiar el findById por otro método de búsqueda y recibir el parámetro que llega en args y con esto consultar a la base de datos.

Te dejo la documentación de objection.js donde muestra como hacer queries usando otros parámetros

Fernanda Aragon

student•

Mi implementación para hacer la busqueda fue de esta forma.

Emanuel Villanueva

student•

Error de Graph
"message": “TypeError: Profesor.find is not a function”

Lo mismo para Curso.

Juan Sebastián Contreras

student•

Muy mal lo del hardcodeado. Así no lo explicara pudo haber puesto el código…

ResultadoBusqueda: {
      __resolveType: (obj) => {
        return obj instanceof Curso ? 'Curso': 'Profesor';
      }
    },

Gerson Montenegro

student•

Ya había hecho el Curso básico de GraphQL, que está más actualizado con respecto a fechas, pero quise hacer este para reforzar, teniendo en mente que me encontraría con un contenido desactualizado, y de hecho así fue, pero luego de hacer la configuración inicial actualizando librerías, todo estuve genial, pues este curso sirve como complemento perfectamente.

Y claro, al llegar acá noto que no se hicieron las consultas como esperábamos, pero hurgando un poco en la documentación actual de Objection, terminé con el sgte código que podría servirle a quien quiera terminar esta lección al menos con algo más acorde a lo que esperábamos:

    buscar: async(_, { keyword }) => {
        const profesores = await Profesor.query().where('nombre', 'like', `%${keyword}%`)
        const cursos = await Curso.query().where('titulo', 'like', `%${keyword}%`)
        return [
            ...profesores,
            ...cursos
        ]
    }

Espero le pueda servir a alguien.

Alvaro Gonzalez

student•

Estoy implementando un filtro, queri saber si esta es la mejor forma de hacelo.

const resolvers = {
    Query: {
        entidadesByFilter:(_,args) => { 
            let entity = Entidad.query().eager('[persona,representante]');
            if(args.filter.tipo !=undefined  && args.filter.estado !=undefined)
                return entity.where('tipo',args.filter.tipo).andWhere('estado',args.filter.estado)
            else if (args.filter.tipo != undefined && args.filter.estado === undefined)
                return entity.where('tipo',args.filter.tipo)
            else if(args.filter.tipo === undefined && args.filter.estado != undefined)
                return entity.where('estado',args.filter.estado)
            else 
               return entity; 
         }
   }
}

    buscar: async(_, { keyword }) => {
        const profesores = await Profesor.query().where('nombre', 'like', `%${keyword}%`)
        const cursos = await Curso.query().where('titulo', 'like', `%${keyword}%`)
        return [
            ...profesores,
            ...cursos
        ]
    }

const resolvers = {
    Query: {
        entidadesByFilter:(_,args) => { 
            let entity = Entidad.query().eager('[persona,representante]');
            if(args.filter.tipo !=undefined  && args.filter.estado !=undefined)
                return entity.where('tipo',args.filter.tipo).andWhere('estado',args.filter.estado)
            else if (args.filter.tipo != undefined && args.filter.estado === undefined)
                return entity.where('tipo',args.filter.tipo)
            else if(args.filter.tipo === undefined && args.filter.estado != undefined)
                return entity.where('estado',args.filter.estado)
            else 
               return entity; 
         }
   }
}

Implementando la Búsqueda

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