Resolvers para mutaciones y filtros

Curso Avanzado de Node.js con GraphQL, Apollo Server y Prisma

Contenido del curso

Introducción

Base de datos y ORM

Producción

Próximos pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0020:28

Resolvers para mutaciones y filtros

Curso Avanzado de Node.js con GraphQL, Apollo Server y Prisma

Clase 7 de 23

Clase 7 / 23

Emmanuel Rodríguez

Hace 5 años

Clean Architecture

📚 Repositorio

. Para esta sección, en vez de utilizar los Data sources, desarrollo una abstracción mediante el patrón MVC (Model-View-Controller). Para ello defino la siguiente estructura de trabajo:

src
  └─⫸ controllers
  │	   └─⫸ Account.controller.ts
  └─⫸ graphql
  │	  └─⫸ schemas
  │	  	  └─⫸ Account.schema.ts
  └─⫸ models
  	  └─⫸ Account
	  	  └─⫸ Account.entity.ts
	  	  └─⫸ Account.model.ts

Partiendo de la capa del modelo tenemos que:

Un modelo define la capa de definición y abstracción a la información.

export interface Account {
    id: number
    email: string
    password: string
}

export type Query = Pick<Account, 'id'>
export type Payload = Pick<Account, 'email' | 'password'>

export default class AccountModel extends Model<Account, Query, Payload> {
    /**
     * @private
     * @description Prisma ORM definition handler library. */
    private client = new Prisma('account')
    /**
     * @description Find an account by id.
     * @param {Query} query
     * @returns Account */
    async findUnique(query: Query): Promise<Account> {
        return await this.client.findUnique({
            where: query,
        })
    }
	
   // More code ...
}

Para el controlador tenemos que:

Un controlador gestiona y administra el acceso a los datos, así como la secuencia necesaria para su manipulación basadas en las reglas de negocio.

import Error from '@controllers/Error.controller'

import Account from '@models/Account/Account.model'
import { Query, Payload } from '@models/Account/Account.entity'

export default class AccountController {
    private model = new Account()
    /**
     * @description Find an account by id.
     * @param {Query} query
     * @returns Account */
    async findAccount(query: Query) {
        const account = await this.model.findUnique({
            id: Number(query.id),
        })
        if (!account) throw new Error('NOT_FOUND')
        return account
    }

   // More code ...
}

Por último, el esquema la defino como su puente o límite mediante prototipos:

import { gql } from 'apollo-server'

import { Query, Payload } from '@models/Account/Account.entity'
import AccountController from '@controllers/Account.contoller'

const accountController = new AccountController()

export default {
    Schema: gql`
        type Account {
            id: ID!
            email: String!
            password: String!
        }

        input CreateAccount {
            email: String!
            password: String!
        }

        extend type Query {
            account(id: ID!): Account!
            accounts: [Account!]!
        }
    `,
    Query: {
        account: async (_: any, query: Query) => {
            return await accountController.findAccount(query)
        },
        accounts: async () => {
            return await accountController.findAccounts()
        },
    },
    Mutation: {
        createAccount: async (_: any, { account }: { account: Payload }) => {
            validate(account)
            return await accountController.createAccount(account)
        },
    },
}

Comentarios (13)13 comentarios

Favio Amarilla Miño

Pipe Ll

Yasniel Fajardo Egues

Nahuel Castro

Hace 4 años

Jonathan 🦑 Alvarez

Profesor

Steve Anthony Luzquiños Agama

Cristian Iñiguez

Sebastian Delgado

Hace 3 años

Matias Gabino Santana Cabrera

Josué Hernández

Antonio Silva

José María C. L.

Jose Alberto Reyes Quevedo

José Luis Encastin Flores

Introducción

¿Por qué GraphQL?

Arquitectura backend con Node.js y GraphQL

Construyendo una query simple con Apollo Server

Scalars, filtros y queries avanzadas

Base de datos y ORM

ORMs, Prisma y automatización

Modelando la base datos y schema

Resolvers para mutaciones y filtros

Filtros en Prisma

Paginación y filtros avanzados

Archivos estáticos

Archivos estáticos con Express.js y Apollo Server

Producción

Protección de recursos en GraphQL

Testing

Pruebas End to End: Estrategias y Herramientas Efectivas

Preparando la app para producción

Preparando el servidor para Heroku

Introspección

Bases de datos en producción

Deploying

Próximos pasos

Reto: guestbook

Desventajas de GraphQL

Frameworks de GraphQL

Conectemos el frontend

Resolvers para mutaciones y filtros

Progreso del curso

Introducción

Base de datos y ORM

Producción

Próximos pasos

Recursos

Recursos