Valibot: Validación Modular, Tree-Shaking y Pipelines de Esquemas

z.string().min(5).max(100).email().trim();

+-------------------------------------------------------------------------+
|                  GRAFO MONOLÍTICO DE ZOD (Tree-Shaking Imposible)       |
+-------------------------------------------------------------------------+
|  import { z } from 'zod';                                               |
|  z.string().email();                                                    |
|                                                                         |
|  El empaquetador inspecciona la clase ZodString:                        |
|  class ZodString {                                                      |
|    min() { ... }     // <- ¡Se incluye en el bundle aunque no se use!   |
|    max() { ... }     // <- ¡Se incluye en el bundle!                    |
|    uuid() { ... }    // <- ¡Se incluye en el bundle!                    |
|    regex() { ... }   // <- ¡Se incluye en el bundle!                    |
|    ip() { ... }      // <- ¡Se incluye en el bundle!                    |
|  }                                                                      |
|  => Tamaño final del bundle: ~14 KB (gzip)                              |
+-------------------------------------------------------------------------+
|                                                                         |
|                  GRAFO MODULAR DE VALIBOT (Tree-Shaking Total)          |
+-------------------------------------------------------------------------+
|  import { object, string, email, pipe } from 'valibot';                 |
|                                                                         |
|  El empaquetador evalúa las exportaciones ES:                           |
|  - object()   => Incluido en el bundle (~350 bytes)                     |
|  - string()   => Incluido en el bundle (~150 bytes)                     |
|  - email()    => Incluido en el bundle (~200 bytes)                     |
|  - pipe()     => Incluido en el bundle (~100 bytes)                     |
|  * ¡Las restantes 150+ funciones de la librería se descartan del build! |
|  => Tamaño final del bundle: ~850 bytes (gzip)!                         |
+-------------------------------------------------------------------------+

import * as v from 'valibot';

// Definición de esquema mediante composición funcional con pipe()
export const UserProfileSchema = v.object({
  id: v.pipe(
    v.string(),
    v.uuid('El identificador debe ser un UUID v4 válido')
  ),
  username: v.pipe(
    v.string(),
    v.trim(), // Transformación: remueve espacios superfluos
    v.minLength(3, 'El nombre debe contener al menos 3 caracteres'),
    v.maxLength(20, 'El nombre no puede exceder 20 caracteres')
  ),
  email: v.pipe(
    v.string(),
    v.trim(),
    v.toLowerCase(), // Transformación: normalización de mayúsculas
    v.email('Formato de correo electrónico no válido')
  ),
  age: v.pipe(
    v.number(),
    v.minValue(18, 'El servicio está restringido a mayores de 18 años'),
    v.maxValue(100, 'Introduce una edad válida')
  ),
  website: v.optional(
    v.pipe(
      v.string(),
      v.url('Formato de URL no válido')
    )
  ),
});

// Inferencia estática de los datos de entrada en bruto (previos a transformaciones)
export type UserProfileInput = v.InferInput<typeof UserProfileSchema>;

// Inferencia estática de los datos procesados (posteriores a trim y toLowerCase)
export type UserProfileOutput = v.InferOutput<typeof UserProfileSchema>;

import * as v from 'valibot';

// Acción personalizada para validar fortaleza de contraseña
export function passwordStrength(requirementMessage = 'La contraseña debe contener al menos 1 número y 1 carácter especial') {
  return v.check((input: string) => {
    const hasNumber = /\d/.test(input);
    const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>]/.test(input);
    return hasNumber && hasSpecialChar;
  }, requirementMessage);
}

// Acción personalizada para validar NIF/CIF o identificador fiscal
export function isValidTaxId(errorMessage = 'Identificador fiscal de empresa no válido') {
  return v.check((input: string) => {
    if (!/^\d{10}$/.test(input)) return false;
    
    const coefficients = [2, 4, 10, 3, 5, 9, 4, 6, 8];
    const controlSum = coefficients.reduce(
      (sum, coeff, idx) => sum + coeff * Number(input[idx]),
      0
    );
    const controlDigit = (controlSum % 11) % 10;
    
    return Number(input[9]) === controlDigit;
  }, errorMessage);
}

// Empleo de acciones personalizadas dentro de un pipeline
export const SecurityFormSchema = v.object({
  taxId: v.pipe(
    v.string(),
    v.trim(),
    isValidTaxId()
  ),
  password: v.pipe(
    v.string(),
    v.minLength(8, 'La contraseña debe tener un mínimo de 8 caracteres'),
    passwordStrength()
  ),
});

import * as v from 'valibot';
import { UserProfileSchema, UserProfileOutput } from './profile-schema';

export interface FormSubmissionResult {
  isSuccess: boolean;
  data?: UserProfileOutput;
  fieldErrors?: Record<string, string>;
}

export function handleProfileSubmission(rawFormData: unknown): FormSubmissionResult {
  // safeParse no arroja excepciones y devuelve una unión discriminada tipada
  const result = v.safeParse(UserProfileSchema, rawFormData);

  if (!result.success) {
    // Transformar el array plano de issues en un mapa de errores por campo
    const fieldErrors: Record<string, string> = {};

    for (const issue of result.issues) {
      // Extraer el nombre del primer segmento de la ruta (ej. 'email' o 'username')
      const fieldName = issue.path?.[0]?.key;
      if (typeof fieldName === 'string' && !fieldErrors[fieldName]) {
        fieldErrors[fieldName] = issue.message;
      }
    }

    return {
      isSuccess: false,
      fieldErrors,
    };
  }

  // Los datos han sido completamente saneados y validados
  return {
    isSuccess: true,
    data: result.output,
  };
}