zod/valibot schemas + inference

import { z } from "zod"

export const userSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(1),
  age: z.number().int().min(0).optional()
})

export type User = z.infer<typeof userSchema>

// User is kept in sync with runtime rules.

import type { Request, Response } from "express"
import { userSchema, type User } from "./schema"

export function createUser(req: Request, res: Response<User | { error: string; issues?: unknown }>) {
  const r = userSchema.safeParse(req.body)
  if (!r.success) {
    return res.status(400).json({ error: "Invalid body", issues: r.error.format() })
  }
  const user = r.data
  return res.status(201).json(user)
}

// parse() throws; safeParse() returns a discriminated union

import { object, string, number, optional, minLength, uuid, minValue } from "valibot"
import type { Infer } from "valibot"

export const VUser = object({
  id: string([uuid()]),
  name: string([minLength(1)]),
  age: optional(number([minValue(0)]))
})

export type VUserT = Infer<typeof VUser>

// Similar idea: one schema, inferred type.

import { ZodTypeAny } from "zod"

export function validate<T extends ZodTypeAny, Out = unknown>(schema: T, value: unknown, onError?: (issues: unknown) => never | void): { ok: true; data: Out } | { ok: false; issues: unknown } {
  const r = schema.safeParse(value)
  if (!r.success) {
    const issues = r.error.format()
    if (onError) onError(issues as unknown as never)
    return { ok: false, issues }
  }
  return { ok: true, data: r.data as unknown as Out }
}