Convierta cualquier respuesta JSON a un esquema Zod con una solicitud POST

Accede a una API de terceros, obtiene una respuesta JSON y ahora necesita un esquema Zod para ello. El proceso manual: mirar fijamente la respuesta, contar los campos, descubrir cuáles son anulables, manejar objetos anidados, escribir z.object y z.string() para cada propiedad. Un error tipográfico y tu la validación pasa silenciosamente datos incorrectos.

Para un objeto plano de cinco campos, esto lleva unos minutos. Para una intención de pago de Stripe con cargos anidados, metadatos y más de 30 campos, lleva suficiente tiempo comenzar a cuestionar sus elecciones profesionales.

La botoi /v1/schema/json-to-zod El punto final elimina esto. PUBLICAR cualquier JSON, obtener un completo Esquema Zod de vuelta. Una solicitud, sin CLI para instalar, sin paquete npm para configurar.

La llamada API

Envíe un objeto JSON y un nombre de esquema opcional:

rizo

Respuesta:

Nodo.js

Pitón

El punto final acepta cualquier JSON válido en el json campo. Objetos, matrices, profundamente anidados. estructuras; todo funciona. El name El campo es opcional y por defecto es "Root".

Ejemplo real: una intención de pago de Stripe

Aquí hay una raya realista. payment_intent respuesta con anidado metadata y charges objetos. Este es el tipo de carga útil en la que escribir esquemas Zod a mano se vuelve doloroso rápidamente.

Cuerpo de la solicitud:

La API devuelve este esquema Zod:

Cada objeto anidado se vuelve propio z.object. La charges.data matriz produce un z.array con la forma correcta del artículo. Los valores booleanos, números y cadenas se detectan desde los valores. Copie esto en su código base, agregue import { "z" } from "zod", y tienes tipos validados en tiempo de ejecución para respuestas de Stripe en menos de 30 segundos.

También funciona para interfaces TypeScript

Si necesita tipos de TypeScript sin validación en tiempo de ejecución, el /v1/schema/json-to-typescript El punto final genera interfaces a partir de la misma entrada JSON.

Respuesta:

Mismo formato de entrada, mismo name parámetro. Usar json-to-zod cuando lo necesites Validación en tiempo de ejecución (controladores de API, análisis de formularios, cargas útiles de webhook). Usar json-to-typescript cuando solo necesita seguridad de tipos en tiempo de compilación.

Cree un script codegen para su proyecto

El verdadero poder aparece cuando automatiza la generación de esquemas. Este script obtiene respuestas API en vivo, convierte cada uno a un esquema Zod y escribe el resultado en su src/schemas/ directorio.

#!/bin/bash
set -euo pipefail

API_BASE="https://api.botoi.com/v1"
OUTPUT_DIR="./src/schemas"

mkdir -p "\$OUTPUT_DIR"

generate_schema() {
  local name=\$1
  local url=\$2
  local output_file="\$OUTPUT_DIR/\$(echo "\$name" | tr '[:upper:]' '[:lower:]').ts"

  echo "Fetching \$url ..."
  local json_response
  json_response=\$(curl -s "\$url")

  echo "Generating Zod schema for \$name ..."
  local zod_response
  zod_response=\$(curl -s -X POST "\$API_BASE/schema/json-to-zod" \\
    -H "Content-Type: application/json" \\
    -d "{
      \\"json\\": \$json_response,
      \\"name\\": \\"\$name\\"
    }")

  local schema
  schema=\$(echo "\$zod_response" | jq -r '.data.zod')

  cat > "\$output_file" << SCHEMAEOF
import { z } from "zod";

\$schema

export type \$name = z.infer<typeof \${name}Schema>;
SCHEMAEOF

  echo "Wrote \$output_file"
}

# Add your API endpoints here
generate_schema "UserProfile" "https://api.example.com/users/1"
generate_schema "Order" "https://api.example.com/orders/latest"
generate_schema "Product" "https://api.example.com/products/42"

echo "Done. Generated \$(ls "\$OUTPUT_DIR"/*.ts | wc -l) schema files."

Ejecutándolo:

Fetching https://api.example.com/users/1 ...
Generating Zod schema for UserProfile ...
Wrote ./src/schemas/userprofile.ts
Fetching https://api.example.com/orders/latest ...
Generating Zod schema for Order ...
Wrote ./src/schemas/order.ts
Fetching https://api.example.com/products/42 ...
Generating Zod schema for Product ...
Wrote ./src/schemas/product.ts
Done. Generated 3 schema files.

Cada archivo generado tiene este aspecto:

Añade este script a tu package.json como "codegen:schemas" y ejecutarlo cada vez que cambia la API ascendente. Tus esquemas Zod permanecen sincronizados con la forma de respuesta real, y los tipos de TypeScript se derivan del esquema automáticamente.

Cuando esto es útil

• Incorporación de una nueva API de terceros. Presione la API una vez, convierta la respuesta a un Zod esquema y comience a construir con tipos validados en lugar de adivinar nombres de campos.
• Migrando JavaScript a TypeScript. Si tiene respuestas API fluyendo a través de código sin escribir, genere esquemas a partir de datos reales para obtener cobertura de tipos rápidamente.
• Mantener los esquemas sincronizados. Ejecute el script codegen en CI según un cronograma para detectar cuando una API ascendente cambia su forma de respuesta.
• Creación de prototipos. Cuando necesita tipos validados para una prueba de concepto y no desea dedicar tiempo a elaborar esquemas manuales para las API que podría descartar la próxima semana.