Generador Online de JSON a Esquema JSON

Cómo Funciona la Generación de Esquemas

Generar un esquema JSON a partir de un JSON de muestra implica más que mapear campos a tipos. Esta herramienta sigue varios pasos clave para asegurar la corrección y completitud:

1. Análisis Sintáctico: La herramienta parsea tu JSON según ECMA-404, reportando errores detallados ante entradas mal formadas o constructos ambiguos.
2. Análisis Estructural: Construye un árbol que representa tus datos, clasificando cada propiedad y elemento según los tipos básicos de JSON Schema (objeto, arreglo, cadena, número, entero, booleano, nulo).
3. Recorrido Recursivo: Estructuras profundas y anidadas —incluyendo arreglos de objetos o arreglos anidados— se recorren recursivamente para generar definiciones de esquema anidadas.
4. Inferencia y Unión de Tipos: Para cada propiedad o elemento del arreglo se infiere el tipo. Cuando hay tipos mezclados, 'type' se expresa como un arreglo (tipo unión) según especificación JSON Schema.
5. Detección de Requeridos y Opcionales: Analizando todos los objetos en cada nivel, la herramienta diferencia claves siempre presentes (requeridas) de las que pueden faltar (opcionales).
6. Restricciones de Valores: Cuando es posible, infiere enums (conjunto de valores permitidos), mínimos/máximos para números, longitudes mínimas/máximas para cadenas, y sugerencias de formato (como 'email', 'uri' o 'date-time').
7. Gestión de Casos Especiales: Se presta especial atención a arreglos vacíos, valores nulos y estructuras dispersas, garantizando esquemas válidos que reflejan la variabilidad real.
8. Síntesis del Esquema: El esquema final se emite como un documento conforme al Draft-07, listo para usarse con herramientas como Ajv, OpenAPI o librerías para generación de código.

¿Por Qué Generar Esquema JSON? Usos Prácticos

• Validación Automática: Usa esquemas generados para imponer contratos de datos y validar cargas entrantes en tus APIs, microservicios o interfaces CLI.
• Documentación de API: Genera automáticamente documentación y exploradores interactivos (Swagger, Postman) con definiciones precisas.
• Generación de Código: Crea modelos o validadores con tipado seguro en TypeScript, Python, Java y otros lenguajes usando tu esquema como fuente única de verdad.
• Generación de Datos de Prueba: Herramientas como JSON Schema Faker o Mockaroo usan esquemas para sintetizar datos simulados realistas para QA y pruebas de carga.
• Refactorización y Migración: Valida estructuras de datos legadas o cambiantes, asegurando compatibilidad a medida que evoluciona tu backend.

Características Técnicas

• Compatibilidad con Draft-07 para máxima interoperabilidad con los principales validadores y plataformas de diseño de APIs.
• Análisis recursivo para cualquier profundidad de anidación: arreglos dentro de arreglos, objetos dentro de arreglos y más.
• Inferencia precisa de tipos unión ('type' en arreglo) para campos o ítems con variabilidad entre muestras.
• Detección automática de enums, longitud, patrón, formato, min/máx y otras restricciones comunes.
• Soporte explícito para nulos, arreglos/objetos vacíos y registros parciales.
• La generación del esquema se realiza completamente en el navegador. Tu JSON de entrada nunca sale de tu dispositivo.

Ejemplo Técnico: De JSON de Muestra a Esquema Draft-07

{
  "transaction": {
    "id": "txn_abc123",
    "amount": 99.95,
    "currency": "USD",
    "status": "completed",
    "meta": {
      "ip": "203.0.113.1",
      "tags": ["recurring", null]
    }
  },
  "refunded": false,
  "notes": null
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "transaction": {
      "type": "object",
      "properties": {
        "id": { "type": "string" },
        "amount": { "type": "number" },
        "currency": { "type": "string", "minLength": 3, "maxLength": 3 },
        "status": { "type": "string", "enum": ["completed"] },
        "meta": {
          "type": "object",
          "properties": {
            "ip": { "type": "string", "format": "ipv4" },
            "tags": {
              "type": "array",
              "items": { "type": ["string", "null"] }
            }
          },
          "required": ["ip", "tags"]
        }
      },
      "required": ["id", "amount", "currency", "status", "meta"]
    },
    "refunded": { "type": "boolean" },
    "notes": { "type": ["null"] }
  },
  "required": ["transaction", "refunded", "notes"]
}

Cómo Usar Esta Herramienta de JSON a Esquema JSON

1. Pega o escribe tu JSON de ejemplo en el editor que está abajo. La herramienta acepta cualquier JSON válido, desde objetos simples hasta estructuras profundamente anidadas.
2. Haz clic en 'Generar Esquema JSON' para crear y visualizar el esquema JSON producido.
3. Copia, edita o descarga el esquema. Intégralo directamente en tus definiciones API, lógica de validación o documentación.

Ejemplos de Código para Generar Esquemas desde JSON

Descubre cómo generar un esquema JSON a partir de JSON en varios lenguajes de programación.

const generateSchema = require('jsonschema-generator');
const data = {
  name: "Alice",
  age: 30,
  isActive: true,
  tags: ["user", "admin"]
};
const schema = generateSchema(data);
console.log(JSON.stringify(schema, null, 2));

const GenerateSchema = require('generate-schema');
const data = { name: "Alice", age: 30, tags: ["admin", "user"] };
const schema = GenerateSchema.json('User', data);
console.log(JSON.stringify(schema, null, 2));

from genson import SchemaBuilder
sample = {"name": "Alice", "age": 30, "tags": ["user", "admin"]}
builder = SchemaBuilder()
builder.add_object(sample)
print(builder.to_json(indent=2))

from jsonschema_generate import generate_schema
sample = {"name": "Alice", "age": 30, "tags": ["user", "admin"]}
schema = generate_schema(sample)
print(schema)

package main
import (
  "encoding/json"
  "fmt"
  "github.com/invopop/jsonschema"
)
type User struct {
  Name string   `json:"name"
  Age  int      `json:"age"
  Tags []string `json:"tags"
}
func main() {
  schema := jsonschema.Reflect(&User{})
  out, _ := json.MarshalIndent(schema, "", "  ")
  fmt.Println(string(out))
}

# Generate Java POJOs *from* a JSON Schema, not the reverse.
# For schema generation from Java, see tools like jackson-module-jsonSchema.
# See: https://github.com/FasterXML/jackson-module-jsonSchema

using NJsonSchema;
using Newtonsoft.Json.Linq;
var sample = JObject.Parse("{\"name\":\"Alice\",\"age\":30, \"tags\":[\"user\"]}");
var schema = await JsonSchema.FromSampleJsonAsync(sample.ToString());
Console.WriteLine(schema.ToJson());

require 'vendor/autoload.php';
use Swaggest\JsonSchema\Structure\ClassStructure;
$sample = ["name" => "Alice", "age" => 30, "tags" => ["user"]];
$schema = ClassStructure::exportSchema($sample);
echo json_encode($schema, JSON_PRETTY_PRINT);

require 'json_schemer'
sample = { "name" => "Alice", "age" => 30, "tags" => ["admin", "user"] }
schema = JSONSchemer.schema(sample)
puts schema.to_json

echo '{"name":"Alice","age":30,"tags":["user","admin"]}' | genson | jq .

use schemars::JsonSchema;
use serde::Serialize;
#[derive(Serialize, JsonSchema)]
struct User {
  name: String,
  age: u32,
  tags: Vec<String>,
}
fn main() {
  let schema = schemars::schema_for!(User);
  println!("{}", serde_json::to_string_pretty(&schema).unwrap());
}

import json.schema._
case class User(name: String, age: Int, tags: List[String])
val schema = Json.schema[User]
println(schema.asSpray.prettyPrint)

# Generate schema from a TypeScript interface:
typescript-json-schema tsconfig.json User --out schema.json
# See https://github.com/YousefED/typescript-json-schema

// Dart does not have an automatic JSON Schema generator yet.
// Manually define schema as a Dart Map or use online tools.