Validación de Datos en GradQL con Scalars Personalizados

Curso de GraphQL con Node.js

Contenido del curso

Introducción

Fundamentos de GraphQL

Tipado en GraphQL

GraphQL en la Tienda con Express.js

Autenticación con GraphQL y JSON Web Tokens

Bonus

22
Anidamiento dinámico en GraphQL: optimización de consultas SQL
18:07 min

Conclusiones

Tomar examen

Validación de Datos en GradQL con Scalars Personalizados

Resumen

Link de interés:

GraphQL Scalars

Andrés Esteban Rodríguez Jiménez

Estudiante

Custom Scalars

En nuestro servidor REST API realizamos validaciones precisas de datos utilizando la librería Joi, pero ¿Cómo lo podemos hacer en consultas GraphQL? Para lograr esto, utilizaremos una técnica llamada custom scalars.

Para utilizar estos tipos de datos, debemos extender GraphQL instalando la librería graphql-scalars:

npm install graphql-scalars

Esta librería nos permite realizar validaciones nativas en GraphQL, sin necesidad de utilizar librerías adicionales como Joi.

Para implementar nuestros scalars, debemos realizar los siguientes pasos en el archivo index.js de la carpeta graphql:

const { ApolloServer } = require('apollo-server-express');
const { expressMiddleware } = require('apollo-server-express');
const { loadFiles } = require('@graphql-tools/load-files');
const { buildContext } = require('graphql-passport');
const resolvers = require('./resolvers');
const { typeDefs: scalarsTypeDefs, resolvers: scalarsResolvers } = require('graphql-scalars');

const useGraphql = async (app) => {
	 // Cargamos los tipos de definición en una única variable dentro de un array
  const typeDefs = [
    ...await loadFiles('./src/**/*.graphql'),
    scalarsTypeDefs
  ];

  // Agregamos los resolvers en una única variable dentro de un array
  const allResolvers = [
    resolvers,
    scalarsResolvers
  ];

  // Los implementamos en nuestro servidor Apollo
  const server = new ApolloServer({
    typeDefs,
    resolvers: allResolvers,
  });

  await server.start();
  app.use(
    '/graphql',
    expressMiddleware(server, {
      context: async ({ req, res }) => buildContext({ req, res })
    }),
  );
};

module.exports = useGraphql;

Luego, podemos comenzar a utilizar los custom scalars en nuestro esquema GraphQL. Aquí hay un ejemplo de cómo se vería en nuestro archivo schema.graphql:

# Tipos de respuesta enviadas

type Mutation {
  # login
  login(email: EmailAddress! password: String!): AuthResponse
}

# Esquemas de respuestas
type Product {
  id: ID!
  name: String!
  price: Float!
  description: URL!
  image: String!
  createdAt: Date!
  categoryId: ID!
  category: Category!
}

type Category {
  id: ID!
  name: String!
  image: String!
}

type User {
  id: ID!
  email: EmailAddress!
  role: String!
  createdAt: Date!
}

# Esquemas de autenticación
type AuthResponse {
  access_token: String!
  user: User!
}

# Inputs

# Products
input CreateProductDto {
  name: String!
  price: Int!
  description: String!
  image: URL!
  categoryId: ID!
}

input UpdateProductDto {
  name: String
  price: Int
  description: String
  image: URL
  categoryId: ID
}

# Categories
input CreateCategoryDto {
  name: String!
  image: URL!
}

Excelente, pero ¿Qué sucede si necesitamos realizar una validación adicional, como limitar la longitud de caracteres de un campo? Para esto, podemos utilizar expresiones regulares.

En nuestro archivo resolver.js, podemos hacer lo siguiente:

const { RegularExpression } = require('graphql-scalars');

// Creamos nuestro nuevo tipo
const CategoryNameType = new RegularExpression('CategoryNameType', /^[a-zA-Z0-9]{3,8}$/);

const resolvers = {
  Query: {
    // ...
  },
  Mutation: {
    // ...
  },
  // Para agregarlo, lo agregamos como un nuevo tipo
  CategoryNameType
};

module.exports = resolvers;

Luego, debemos realizar un paso adicional en nuestro archivo schema.graphql:

# Categories
input CreateCategoryDto {
  # Y ahora podemos usarlo normalmente
  name: CategoryNameType!
  image: URL!
}

# Debemos importarlo de la siguiente manera
scalar CategoryNameType

¡Listo! De esta manera, podemos crear tipos de datos complejos utilizando custom scalars en GraphQL.

Validación de Datos en GradQL con Scalars Personalizados

Introducción

Integración de GraphQL con Node.js y Express

Integración de GradQL en API REST existente

Organización del Código para Implementar GraphQL

Fundamentos de GraphQL

Creación de tu primer servidor GradQL con Apollo Server Express

Consultar GraphQL desde Insomnia y Postman

Tipado en GraphQL

Sistema de Tipado en GradQL: Queries y Mutations

Tipos escalares de GraphQL y validación automática

Validación de Nullables y Listas en GradQL

Creación y Manejo de Tipos de Datos en GraphQL

Integración de Archivos GradQL y Live Reloading en Node.js

GraphQL en la Tienda con Express.js

Cómo separar resolvers GraphQL por entidad

Conexión de Base de Datos y Consultas en GraphQL con SQLite

Creación de productos con mutations e inputs en GraphQL

Uso de Variables y Alias en GradQL para Optimizar Consultas

Actualización y Eliminación de Productos con GraphQL

Anidamiento de Entidades con GradQL en APIs

Autenticación con GraphQL y JSON Web Tokens

Autenticación de Usuarios con JWT en GraphQL y Node.js

Creación de Mutación para Categorías con Validación de Roles

Autenticación de JSON Web Tokens en GraphQL con Passport

Validación de Roles y Sesiones con GradQL y Express