zod vs joi vs yup vs class-validator vs class-transformer-validator | Comparação de pacotes npm de "Validação e Transformação de Dados em JavaScript"

Pacote	Downloads	Stars	Tamanho	Issues	Publicado em	Licença

zod	33,688,040	38,799	1.63 MB	545	il y a 14 jours	MIT
joi	13,876,921	21,115	531 kB	192	il y a un an	BSD-3-Clause
yup	8,190,959	23,435	260 kB	240	il y a 6 mois	MIT
class-validator	5,006,028	11,455	5.13 MB	319	il y a 2 mois	MIT
class-transformer-validator	48,005	203	-	16	il y a 5 ans	MIT

Pacote

Downloads

Stars

Tamanho

Issues

Publicado em

Licença

zod

33,688,040

38,799

1.63 MB

545

il y a 14 jours

MIT

joi

13,876,921

21,115

531 kB

192

il y a un an

BSD-3-Clause

yup

8,190,959

23,435

260 kB

240

il y a 6 mois

MIT

class-validator

5,006,028

11,455

5.13 MB

319

il y a 2 mois

MIT

class-transformer-validator

48,005

203

il y a 5 ans

MIT

Validação de Dados

zod:
zod é uma biblioteca de validação de esquemas que prioriza a inferência de tipos do TypeScript. Ele fornece uma API simples para definir esquemas de validação e gera automaticamente tipos TypeScript com base nos esquemas definidos.
joi:
joi fornece validação de dados baseada em esquemas. Os desenvolvedores definem esquemas de validação usando uma API de encadeamento, e o Joi suporta validação aninhada, validação assíncrona e personalização de mensagens de erro.
yup:
yup é semelhante ao Joi, mas com uma API mais simples e amigável. Ele suporta validação de esquemas aninhados, validação assíncrona e permite a definição de mensagens de erro personalizadas. O Yup é especialmente popular em aplicativos React.
class-validator:
class-validator permite a validação de dados em classes usando decoradores. Ele valida os dados com base nas anotações de decorador e suporta validação aninhada, validação assíncrona e personalização de mensagens de erro.
class-transformer-validator:
class-transformer-validator fornece validação de dados usando decoradores definidos nas propriedades das classes. Ele valida os dados com base nas regras especificadas e pode transformar os dados ao mesmo tempo, se necessário.

Transformação de Dados

zod:
zod suporta transformação de dados como parte do processo de validação. Ele permite que os desenvolvedores definam funções de transformação que são aplicadas aos dados durante a validação, tornando-o mais flexível em comparação com algumas outras bibliotecas.
joi:
joi não suporta transformação de dados nativamente, mas permite a modificação dos dados durante a validação usando métodos personalizados. Os desenvolvedores podem definir lógica de transformação personalizada dentro dos esquemas de validação.
yup:
yup também não fornece transformação de dados nativamente, mas permite a definição de lógica de transformação personalizada usando o método transform. Os desenvolvedores podem transformar os dados durante o processo de validação, se necessário.
class-validator:
class-validator não fornece transformação de dados por conta própria. Ele se concentra exclusivamente na validação de dados. Para transformação, você precisaria usar uma biblioteca separada, como class-transformer, em conjunto com o class-validator.
class-transformer-validator:
class-transformer-validator suporta transformação de dados durante a validação. Ele pode converter tipos de dados automaticamente com base nas regras definidas nas classes, tornando-o útil para garantir que os dados estejam no formato correto após a validação.

Integração com TypeScript

zod:
zod é uma biblioteca de validação de esquemas de primeira classe para TypeScript. Ele fornece inferência de tipos automática e precisa com base nos esquemas de validação definidos, tornando-o uma das melhores opções para projetos TypeScript.
joi:
joi oferece suporte a TypeScript, mas sua inferência de tipos não é tão forte quanto a de algumas bibliotecas baseadas em classe. Os desenvolvedores podem definir tipos para esquemas de validação, mas a inferência automática pode ser limitada.
yup:
yup possui suporte a TypeScript e fornece boa inferência de tipos para esquemas de validação. Ele é especialmente amigável para projetos TypeScript, com tipos bem definidos para sua API.
class-validator:
class-validator é projetado para funcionar bem com TypeScript. Ele usa decoradores e tipos de classe para validação, oferecendo boa inferência de tipos e suporte para validação de dados tipados.
class-transformer-validator:
class-transformer-validator é totalmente compatível com TypeScript e aproveita os tipos de classe e decoradores para validação e transformação. Ele fornece inferência de tipos com base nas definições de classe, tornando-o fácil de usar em projetos TypeScript.

Tamanho e Desempenho

zod:
zod é uma biblioteca de validação leve e rápida, projetada para desempenho. Ele oferece validação rápida com baixo consumo de recursos, tornando-o adequado para aplicativos que exigem validação em tempo real sem comprometer o desempenho.
joi:
joi é mais pesado em comparação com algumas bibliotecas de validação devido à sua natureza altamente configurável e suporte a validação aninhada. No entanto, o desempenho é geralmente aceitável para a maioria das aplicações. O uso excessivo de validações complexas pode afetar o desempenho.
yup:
yup é projetado para ser leve e rápido, com desempenho semelhante ao Joi. Ele é otimizado para validação de esquemas e é especialmente eficiente em validações aninhadas. O impacto no desempenho é mínimo, tornando-o adequado para aplicativos em tempo real.
class-validator:
class-validator é uma biblioteca leve que se concentra na validação de dados. Seu impacto no desempenho é mínimo, mas pode aumentar com validações aninhadas e assíncronas. É importante otimizar as validações para evitar problemas de desempenho em grandes aplicativos.
class-transformer-validator:
class-transformer-validator é relativamente leve, mas seu desempenho pode ser afetado pela validação e transformação de dados em tempo real, especialmente para estruturas de dados complexas. O impacto no desempenho dependerá da complexidade das regras de validação e transformação definidas.

Exemplo de Código

zod:

Exemplo de Validação com zod

const { z } = require('zod');

const schema = z.object({
  name: z.string(),
  age: z.number().int(),
});

const userData = { name: 'John', age: '30' }; // age is a string

try {
  const validatedData = schema.parse(userData);
  console.log('Validated user:', validatedData);
} catch (error) {
  console.log('Validation error:', error.errors);
}

joi:

Exemplo de Validação com joi

const Joi = require('joi');

const schema = Joi.object({
  name: Joi.string().required(),
  age: Joi.number().integer().required(),
});

const userData = { name: 'John', age: '30' }; // age is a string
const { error, value } = schema.validate(userData);

if (error) {
  console.log('Validation error:', error.details);
} else {
  console.log('Validated user:', value);
}

yup:

Exemplo de Validação com yup

const *yup* = require('yup');

const schema = yup.object().shape({
  name: yup.string().required(),
  age: yup.number().integer().required(),
});

const userData = { name: 'John', age: '30' }; // age is a string
schema.validate(userData).then((value) => {
  console.log('Validated user:', value);
}).catch((error) => {
  console.log('Validation error:', error.errors);
});

class-validator:

Exemplo de Validação com class-validator

import { IsInt, IsString } from 'class-validator';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';

class User {
  @IsString()
  name: string;

  @IsInt()
  age: number;
}

const userData = { name: 'John', age: '30' }; // age is a string
const user = plainToClass(User, userData);

validate(user).then((errors) => {
  if (errors.length > 0) {
    console.log('Validation errors:', errors);
  } else {
    console.log('Validated user:', user);
  }
});

class-transformer-validator:

Exemplo de Validação e Transformação com class-transformer-validator

import { IsInt, IsString } from 'class-validator';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';
import { validateAndTransform } from 'class-transformer-validator';

class User {
  @IsString()
  name: string;

  @IsInt()
  age: number;
}

const userData = { name: 'John', age: '30' }; // age is a string
const user = plainToClass(User, userData);

validateAndTransform(user).then((errors) => {
  if (errors.length > 0) {
    console.log('Validation errors:', errors);
  } else {
    console.log('Validated and transformed user:', user);
  }
});