Filtros en Prisma

Clase 8 de 23 • Curso Avanzado de Node.js con GraphQL, Apollo Server y Prisma

Steve Anthony Luzquiños Agama

student•

Al hacer el include de los Attributes con Prisma, el tipo que se retorna ya no es solo Avocado, sino: Avocado & { attributes: Attributes | null }, así que deberíamos cambiar esto en el tipo de retorno de nuestros resolvers. El código final se vería algo como esto:

import { Avocado, Attributes } from '@prisma/client'

const getAllAvocados = async (
  parent: unknown,
  args: unknown,
  { orm }: ResolverContext
): Promise<(Avocado & { attributes: Attributes | null })[]> => {
  try {
    return await orm.avocado.findMany({
      include: {
        attributes: true
      }
    })
  } catch (error) {
    console.error('Error getting all the avocados')
    console.error(error)
    throw error
  }
}

const getOneAvocado = async (
  parent: unknown,
  {
    id
  }: {
    id: string
  },
  { orm }: ResolverContext
): Promise<
  | (Avocado & {
      attributes: Attributes | null
    })
  | null
> => {
  try {
    return await orm.avocado.findUnique({
      where: { id: parseInt(id) },
      include: {
        attributes: true
      }
    })
  } catch (error) {
    console.error('Error getting all the avocados')
    console.error(error)
    throw error
  }
}

export { getAllAvocados, getOneAvocado }

Bruno Franco

student•

import { createHash } from 'crypto'
// import { Avocado } from './avocado.model'
import type { Avocado, Attributes, PrismaClient } from '@prisma/client'

type ResolverContext = {
  ormPrisma: PrismaClient
}

// function to findAll() with Prisma
export async function findAll(
  parent: unknown,
  args: unknown,
  context: ResolverContext
): Promise<(Avocado & { attributes: Attributes | null })[] | null> {
  try {
    return await context.ormPrisma.avocado.findMany({
      include: {
        attributes: true,
      },
    })
  } catch (error) {
    console.error('Error getting all the avocados')
    console.error(error)
    throw error
  }
}

export async function findOne(
  parent: unknown,
  args: { id: string },
  context: ResolverContext
): Promise<
  | (Avocado & {
      attributes: Attributes | null
    })
  | null
> {
  try {
    return await context.ormPrisma.avocado.findUnique({
      where: { id: parseInt(args.id) },
      include: {
        attributes: true,
      },
    })
  } catch (error) {
    console.error('Error getting all the avocados')
    console.error(error)
    throw error
  }
}

export const resolver: Record<
  keyof (Avocado & { attributes: Attributes | null }),
  (parent: Avocado & { attributes: Attributes | null }) => unknown
> = {
  id: (parent) => parent.id,
  createdAt: (parent) => parent.createdAt,
  updatedAt: (parent) => parent.updatedAt,
  deletedAt: (parent) => parent.deletedAt,
  sku: (parent) => parent.sku,
  name: (parent) => parent.name,
  price: (parent) => parent.price,
  image: (parent) => parent.image,
  attributes: (parent) => ({
    description: parent.attributes?.description,
    shape: parent.attributes?.shape,
    hardiness: parent.attributes?.hardiness,
    taste: parent.attributes?.taste,
  }),
}

export async function createAvo(
  parent: unknown,
  { data }: { data: Pick<Avocado, 'name' | 'price' | 'image'> & Attributes },
  context: ResolverContext
): Promise<Avocado> {
  const { name, price, image, ...attributes } = data

  return context.ormPrisma.avocado.create({
    data: {
      name,
      price,
      image,
      sku: new Date().toISOString(),
    },
    include: {
      attributes: true,
    },
  })
}

Emmanuel Rodríguez

student•

Inclusión de relaciones

🚧 Documentación

🛠 Commit

. Con prisma, es posible manipular la respuesta deseada mediante dos opciones de retorno:

Select - Para retornar campos específicos o de aquellos basadas en su relación.
Include - Para incluir relaciones en la misma respuesta.

. Ya que GraphQL permite dinámicamente seleccionar los campos, con Prisma solamente definimos que será tratado en el su request la distinción de dichos campos. . Por ejemplo, siguiendo la clase del profesor, anexo simplemente la opción include.

// Account.model.ts
export default class AccountModel extends Model<Account, Query, Payload> {
   // more code...
    /**
     * @description Find an account by id.
     * @param {Query} query
     * @returns Account */
    async findUnique(query: Query): Promise<Account> {
        return await this.client.findUnique({
            where: query,
            include: { directions: true },
        })
    }
   // more code...
}

Revisando que la referencia esté definida en el schema de graphql:

        type Account {
            id: ID!
            email: String!
            password: String!
            directions: [Direction]
        }

Steve Anthony Luzquiños Agama

student•

El avocado del profesor:

{
  "data": {
    "name": "Zutano Avocado",
    "price": 1.25,
    "image": "/images/zutano.jpg",
    "description": "The Zutano avocado is a cold hardy, consistent producing avocado variety. It resembles the Fuerte in appearance but is less flavorful but more cold hardy. The green fruits are abovate in shape with waxy bumps on the skin. The flesh has a low oil but high water content which causes it to have a more fibrous texture.",
    "shape": "Pear",
    "hardiness": "-5 ºC",
    "taste": "Splendid, is an avocado"
  }
}

José María C. L.

student•

Gracias mi buen

José Luis Encastin Flores

student•

Si prisma nos crea el tipado, ¿es recomendable incluir esquemas hechos con librerias como joi para la integridad de los datos?

Luis Alfredo Hernández Duarte

student•

Siempre he pasado de string a int con el signo + ¿Hay alguna diferencia entre éste y ParseInt?

...findUnique({ where: { id: +args.id }})

Jonathan 🦑 Alvarez

teacher•

En general no pero no me sorprendería que hayan casos super específicos donde no sea igual. En todo caso, parseInt es mucho más explícito, y por ende más claro en su propósito que anteponer un "+"

Juan Jose Rivas Álvarez

student•

Como recomendacion para poder leer archivos json en el navegador de una mejor manera les recomiendo esta extencion extencion

Fernando Quinteros Gutierrez

student•

👉 El link para la API de los avocados

Filtros en Prisma

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