Schema Validator

Schema es una pequeña librería de validación basada en esquemas. La API está inspirada en zod y su objetivo es ofrecer una solución de validación simple, personalizada y sin dependencias extras.

Instalación

npm install @adairo/schema-validator

Uso básico

Creando un esquema de tipo string

const s = require("schema");

// creación de un esquema para strings
const schema = s.string();

// parsing
schema.parse("a-string"); // -> { success: true, data: "a-string"}
schema.parse(140); // -> { success: false, error: SchemaError}

Nota: Schema.parse() se comporta como Zod.safeParse()

Creando un esquema de tipo object

const s = require("schema");

// creación de un esquema para objetos
const schema = s.object({
  email: s.string().email(),
  password: s.string().regex(/strong-password-regex/),
});

schema.parse({ email: "invalid-email.com", password: "123" });

Tipos de esquemas

const s = require("schema");

s.string();
s.number();
s.boolean();
s.object();
s.array();

Casting de primitivos

const s = require("schema");

s.number({ coerce: true }).parse("24"); // -> { success: true, data: 24 }
s.string({ coerce: true }).parse(25); // -> { success: true, data: "25" }
s.boolean({ coerce: true }).parse(0); // -> { success: true, data: false }

Métodos en común de todos los esquemas

schema.optional(); // El esquema ignora las validaciones si se le pasa un valor undefined

schema.transform(fn); // Recibe una función para transformar el valor

schema.assert(fn); // Recibe una función que valida y lanza una exepción en caso de error

// Ejemplo
const schema = s.object({
  query: s.object({
    limit: s.number({ coerce: true }).min(1).optional(),
    byOrder: s
      .string()
      .transform((v) => v.toUpperCase())
      .assert((order) => {
        if (order !== "ASC" && order !== "DESC") {
          throw new Error("'ASC' y 'DESC' son los únicos valores permitidos");
        }
      }),
  }),
});

schema.parse({ query: { byOrder: "asc" } }); // -> { success: true, data: { query: { byOrder: "ASC" } } }

StringSchema

// Validaciones
s.string().min(5);
s.string().max(10);
s.string().uuid();
s.string().email();
s.string().regex();

// transformaciones
s.string().trim();

NumberSchema

// Validaciones
s.number().min(5);
s.number().max(10);

ObjectSchema

// Utilidades
s.object({ keyA: s.string() }).extend(s.object({ keyB: s.number() }));
// Equivalente a
s.object({ keyA: s.string(), keyB: s.number() });

ArraySchema

// Validaciones
s.array().min(2);
s.array().max(10);
s.array().nonempty(); // equivalente a array().min(1)
s.array().length(5);

Manejo de errores

Cuando el método schema.parse() falla la validación, regresa un objeto con la siguiente forma:

{ success: false, error: SchemaError }

La clase SchemaError hereda de la clase Error y tiene un miembro issues que es un arreglo de todos los errores que se encontraron en la validación.

const schema = s.object({
  nestedA: s.object({
    keyA: s.string(),
    keyB: s.string(),
  }),
  nestedB: s.object({
    keyAB: s.string(),
  }),
});

schema.parse({ nestedA: {} });
/**
 * Resultado:
 * {
 *   success: false,
 *   error: {
 *     issues: [
 *       { message: "Valor undefined", path: ["nestedA", "keyA"] },
 *       { message: "Valor undefined", path: ["nestedA", "keyB"] },
 *       { message: "Valor undefined", path: ["nestedB"] },
 *     ]
 *   }
 * }
 *
 */