Desafío: Terminar de Crear las Mutaciones

Clase 37 de 45 • Curso de GraphQL 2016

Jorge Méndez Ortega

student•

Para resolver el reto de crear las Mutaciones genere un clase generica como esta

class BuildMutation {
    /**
     * Configuracion inicial
     *
     * @param  {Object} modelo Modelo de la tabla.
     * @param  {Object} params Campos.
     *
     * @return self Fluent interface
     */
    static query(modelo, params) {
        this.modelo = modelo;
        this.params = Object.values(params);
        return this;
    }

    /**
     * Permite borrar un registro.
     *
     * @return entidad.
     */
    static get delete() {
        return (
            this.modelo
                .query()
                .findById(...this.params)
                .then(data => this.modelo
                    .query()
                    .deleteById(...this.params)
                    .then(() => data))
        );
    }

    /**
     * Permite agregar un nuevo registro.
     *
     * @return entidad.
     */
    static get save() {
        return (
            this.modelo
                .query()
                .insert(...this.params)
        );
    }

    /**
     * Permite editar un nuevo registro.
     *
     * @return entidad.
     */
    static get edit() {
        return (
            this.modelo
                .query()
                .patchAndFetchById(...this.params)
        );
    }
}

export default BuildMutation;

del lado de de los resolvers genere algo como esto

// Importacion de modelos referentes a la base de datos.
import { ModeloCurso, ModeloProfesor, ModeloComentario } from "../../DB/models";
import BuildMutation from "./BuildMutation";

/**
 * Declarando la capa de datos que utilizara para resoler los querys.
 */
const RESOLVERS = {
    Query: {
        // permite extraer los datos de la DB y
        // con eager se le indica que relaciones tiene cada tabla.
        cursos: () => ModeloCurso.query().eager("[profesor, comentarios]"),
        profesores: () => ModeloProfesor.query().eager("cursos"),
        comentarios: () => ModeloComentario.query().eager(),
        curso: (rootValue, args) => ModeloCurso.query().findById(args.id),
        profesor: (rootValue, args) => ModeloProfesor.query().findById(args.id),
    },
    Mutation: {
        profesorAdd: (_, args) => BuildMutation.query(ModeloProfesor, args).save,
        profesorEdit: (_, args) => BuildMutation.query(ModeloProfesor, args).edit,
        profesorDelete: (_, args) => BuildMutation.query(ModeloProfesor, args).delete,
        cursoAdd: (_, args) => BuildMutation.query(ModeloCurso, args).save,
        cursoEdit: (_, args) => BuildMutation.query(ModeloCurso, args).edit,
        cursoDelete: (_, args) => BuildMutation.query(ModeloCurso, args).delete,
        comentarioAdd: (_, args) => BuildMutation.query(ModeloComentario, args).save,
        comentarioEdit: (_, args) => BuildMutation.query(ModeloComentario, args).edit,
        comentarioDelete: (_, args) => BuildMutation.query(ModeloComentario, args).delete,
    },
};

export default RESOLVERS;

Julio Hurtado

student•

Los inputs

input NuevoCurso {
    titulo: String!
    descripcion: String!
  }
  
  input CursoEditable {
    titulo: String
    descripcion: String
  }

En resolvers

cursoAdd: (_, args) => Curso.query().insert(args.curso),
    cursoEdit: (_, args) => Curso.query().patchAndFetchById(args.cursoId, args.curso),
    cursoDelete: (_, args) => Curso.query().findById(args.cursoId).then(curso => Curso.query().deleteById(args.cursoId).then(() => curso))

Y en el schema

cursoAdd(curso: NuevoCurso): Curso
    cursoEdit(cursoId: Int!, curso: CursoEditable): Curso
    cursoDelete(cursoId: Int!): Curso```

Anahi Zentella Aguirre

company_admin•

Les comparto mis archivos del curso

Juan Diego Silva Garcia

student•

Es normal que haciendo las mutación de cursoAdd Por ejemplo se dupliquen 2 registros?

La Opinión Digital

student•

Alguien pudo hacer las relaciones con Profesor y cursos al agregar un nuevo profesor ?¡

Valentina Rúa Carrillo

student•

SOLUCIÓN DEL RETO

schema

 type Mutation {
        cursoAdd(curso: NuevoCurso):Curso
        cursoEdit(cursoId: Int!, curso: CursoEditable): Curso
        cursoDelete(cursoId: Int!):Curso
    }`;

inputs

input NuevoCurso{
    titulo: String!
    descripcion: String
}
input CursoEditable{
    titulo: String!
    descripcion: String
}
`

resolvers

 Mutation: {
    //CURSOS
    cursoAdd: (_,args) =>{
      return Curso.query().insert(args.curso)
    },
    cursoEdit: (_,args) =>{
      return Curso.query().patchAndFetchById(args.cursoId,args.curso)
    },
    cursoDelete: (_,args) => {
      return Curso.query().findById(args.cursoId).then((curso) => {
        return Curso.query().deleteById(args.cursoId).then(() => curso)
      })
    }
  }

Julio J Yépez

student•

Resultado del desafío:
schema/index.js

(...)
    cursoAdd   ( curso  : NuevoCurso ): Curso
    cursoEdit  ( cursoId: Int!, curso : CursoEditable ): Curso
    cursoDelete( cursoId: Int! )         : Curso
(...)

schema/Curso.js

(...)
  input NuevoCurso {
    titulo      : String!
    descripcion : String!
    rating      : Float
  }

  input CursoEditable {
    titulo      : String
    descripcion : String
    rating      : Float
  }
(...)

resolver.js

(...)
    cursoAdd   : ( _, args ) => Curso.query().insert( args.curso ),
    cursoEdit  : ( _, args ) => Curso.query().patchAndFetchById( args.cursoId, args.curso ),
    cursoDelete: ( _, args ) => {
      return Curso.query().findById( args.cursoId ).then( curso => {
        return Curso.query().deleteById( args.cursoId ).then( () => curso )
      })
    }
(...)

class BuildMutation {
    /**
     * Configuracion inicial
     *
     * @param  {Object} modelo Modelo de la tabla.
     * @param  {Object} params Campos.
     *
     * @return self Fluent interface
     */
    static query(modelo, params) {
        this.modelo = modelo;
        this.params = Object.values(params);
        return this;
    }

    /**
     * Permite borrar un registro.
     *
     * @return entidad.
     */
    static get delete() {
        return (
            this.modelo
                .query()
                .findById(...this.params)
                .then(data => this.modelo
                    .query()
                    .deleteById(...this.params)
                    .then(() => data))
        );
    }

    /**
     * Permite agregar un nuevo registro.
     *
     * @return entidad.
     */
    static get save() {
        return (
            this.modelo
                .query()
                .insert(...this.params)
        );
    }

    /**
     * Permite editar un nuevo registro.
     *
     * @return entidad.
     */
    static get edit() {
        return (
            this.modelo
                .query()
                .patchAndFetchById(...this.params)
        );
    }
}

export default BuildMutation;

// Importacion de modelos referentes a la base de datos.
import { ModeloCurso, ModeloProfesor, ModeloComentario } from "../../DB/models";
import BuildMutation from "./BuildMutation";

/**
 * Declarando la capa de datos que utilizara para resoler los querys.
 */
const RESOLVERS = {
    Query: {
        // permite extraer los datos de la DB y
        // con eager se le indica que relaciones tiene cada tabla.
        cursos: () => ModeloCurso.query().eager("[profesor, comentarios]"),
        profesores: () => ModeloProfesor.query().eager("cursos"),
        comentarios: () => ModeloComentario.query().eager(),
        curso: (rootValue, args) => ModeloCurso.query().findById(args.id),
        profesor: (rootValue, args) => ModeloProfesor.query().findById(args.id),
    },
    Mutation: {
        profesorAdd: (_, args) => BuildMutation.query(ModeloProfesor, args).save,
        profesorEdit: (_, args) => BuildMutation.query(ModeloProfesor, args).edit,
        profesorDelete: (_, args) => BuildMutation.query(ModeloProfesor, args).delete,
        cursoAdd: (_, args) => BuildMutation.query(ModeloCurso, args).save,
        cursoEdit: (_, args) => BuildMutation.query(ModeloCurso, args).edit,
        cursoDelete: (_, args) => BuildMutation.query(ModeloCurso, args).delete,
        comentarioAdd: (_, args) => BuildMutation.query(ModeloComentario, args).save,
        comentarioEdit: (_, args) => BuildMutation.query(ModeloComentario, args).edit,
        comentarioDelete: (_, args) => BuildMutation.query(ModeloComentario, args).delete,
    },
};

export default RESOLVERS;

cursoAdd: (_, args) => Curso.query().insert(args.curso),
    cursoEdit: (_, args) => Curso.query().patchAndFetchById(args.cursoId, args.curso),
    cursoDelete: (_, args) => Curso.query().findById(args.cursoId).then(curso => Curso.query().deleteById(args.cursoId).then(() => curso))

 Mutation: {
    //CURSOS
    cursoAdd: (_,args) =>{
      return Curso.query().insert(args.curso)
    },
    cursoEdit: (_,args) =>{
      return Curso.query().patchAndFetchById(args.cursoId,args.curso)
    },
    cursoDelete: (_,args) => {
      return Curso.query().findById(args.cursoId).then((curso) => {
        return Curso.query().deleteById(args.cursoId).then(() => curso)
      })
    }
  }

(...)
  input NuevoCurso {
    titulo      : String!
    descripcion : String!
    rating      : Float
  }

  input CursoEditable {
    titulo      : String
    descripcion : String
    rating      : Float
  }
(...)

(...)
    cursoAdd   : ( _, args ) => Curso.query().insert( args.curso ),
    cursoEdit  : ( _, args ) => Curso.query().patchAndFetchById( args.cursoId, args.curso ),
    cursoDelete: ( _, args ) => {
      return Curso.query().findById( args.cursoId ).then( curso => {
        return Curso.query().deleteById( args.cursoId ).then( () => curso )
      })
    }
(...)

Desafío: Terminar de Crear las Mutaciones

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