Tipos Zod

import { z } from "zod";
 
// Primitivos
const str = z.string().min(1).max(255);
const num = z.number().int().positive();
const bool = z.boolean();
const date = z.date();
const bigint = z.bigint();
 
// Strings con validadores integrados
const email = z.string().email();
const url = z.string().url();
const uuid = z.string().uuid();
const cuid = z.string().cuid();
const regex = z.string().regex(/^[A-Z]{3}-\d{4}$/);
 
// Números
const price = z.number().min(0).max(999999).multipleOf(0.01);
const port = z.number().int().gte(1024).lte(65535);
 
// Arrays
const tags = z.array(z.string()).min(1).max(10);
const uniqueTags = z.array(z.string()).nonempty();
 
// Objetos
const User = z.object({
  id: z.string().uuid(),
  name: z.string(),
  role: z.enum(["admin", "user", "guest"]),
});
 
// Enums
const Status = z.enum(["active", "inactive", "pending"]);
const NativeEnum = z.nativeEnum(MyEnum); // funciona con enums de TS
 
// Uniones y uniones discriminadas
const Result = z.discriminatedUnion("status", [
  z.object({ status: z.literal("ok"), data: z.string() }),
  z.object({ status: z.literal("error"), message: z.string() }),
]);
 
// Opcionales, nullables, valores por defecto
const optional = z.string().optional();       // string | undefined
const nullable = z.string().nullable();       // string | null
const nullish = z.string().nullish();         // string | null | undefined
const withDefault = z.string().default("N/A");

"use client";
 
import { useState } from "react";
import { z } from "zod";
 
const ProductSchema = z.object({
  name: z.string().min(1, "Nombre de producto requerido").max(100),
  price: z.coerce.number().positive("El precio debe ser positivo"),
  category: z.enum(["electronics", "clothing", "food", "other"]),
  tags: z.array(z.string().min(1)).min(1, "Al menos una etiqueta").max(5),
  metadata: z
    .object({
      weight: z.coerce.number().positive().optional(),
      color: z.string().optional(),
    })
    .optional(),
});
 
type Product = z.infer<typeof ProductSchema>;
 
export function ProductForm() {
  const [result, setResult] = useState<string>("");
 
  function handleSubmit(e: React.FormEvent<HTMLFormElement>) {
    e.preventDefault();
    const fd = new FormData(e.currentTarget);
 
    const raw = {
      name: fd.get("name"),
      price: fd.get("price"),
      category: fd.get("category"),
      tags: (fd.get("tags") as string)?.split(",").map((t) => t.trim()),
      metadata: {
        weight: fd.get("weight") || undefined,
        color: fd.get("color") || undefined,
      },
    };
 
    const parsed = ProductSchema.safeParse(raw);
    if (parsed.success) {
      setResult(JSON.stringify(parsed.data, null, 2));
    } else {
      setResult(parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("\n"));
    }
  }
 
  return (
    <form onSubmit={handleSubmit} className="flex max-w-md flex-col gap-3">
      <input name="name" placeholder="Nombre de producto" className="rounded border p-2" />
      <input name="price" placeholder="Precio" type="number" step="0.01" className="rounded border p-2" />
      <select name="category" className="rounded border p-2">
        <option value="electronics">Electrónica</option>
        <option value="clothing">Ropa</option>
        <option value="food">Comida</option>
        <option value="other">Otro</option>
      </select>
      <input name="tags" placeholder="Etiquetas (separadas por coma)" className="rounded border p-2" />
      <input name="weight" placeholder="Peso (opcional)" type="number" className="rounded border p-2" />
      <input name="color" placeholder="Color (opcional)" className="rounded border p-2" />
      <button type="submit" className="rounded bg-blue-600 px-4 py-2 text-white">Validar</button>
      {result && <pre className="rounded bg-gray-50 p-3 text-sm whitespace-pre-wrap">{result}</pre>}
    </form>
  );
}

const Base = z.object({ id: z.string().uuid(), createdAt: z.date() });
const WithName = Base.extend({ name: z.string() });
const Merged = Base.merge(z.object({ email: z.string().email() }));
const Picked = Base.pick({ id: true });
const Omitted = Base.omit({ createdAt: true });
const Partial = Base.partial();          // todos los campos opcionales
const Required = Partial.required();     // todos los campos requeridos nuevamente
const DeepPartial = Base.deepPartial();  // objetos anidados también opcionales

const Config = z.record(z.string(), z.number());
// { [key: string]: number }
 
const Scores = z.map(z.string(), z.number());
// Map<string, number>

const Coord = z.tuple([z.number(), z.number()]);
const Tagged = z.tuple([z.literal("point"), z.number(), z.number()]);
const WithRest = z.tuple([z.string()]).rest(z.number());
// [string, ...number[]]

type Category = { name: string; children: Category[] };
 
const CategorySchema: z.ZodType<Category> = z.lazy(() =>
  z.object({
    name: z.string(),
    children: z.array(CategorySchema),
  })
);

// z.enum produce un tipo de unión
const Role = z.enum(["admin", "user"]);
type Role = z.infer<typeof Role>; // "admin" | "user"
Role.enum.admin; // "admin" — acceso a constante tipada
Role.options;    // ["admin", "user"] — la tupla
 
// nativeEnum funciona con enums de TypeScript
enum Direction { Up = "UP", Down = "DOWN" }
const DirSchema = z.nativeEnum(Direction);
type Dir = z.infer<typeof DirSchema>; // Direction
 
// Las uniones discriminadas se infieren correctamente
type Result = z.infer<typeof Result>;
// { status: "ok"; data: string } | { status: "error"; message: string }