Online generátor JSON do JSON Schema

Jak funguje generování schema v pozadí

Generování JSON Schema z příkladového JSON je víc než jen přiřazení polí k typům. Tento nástroj používá několik klíčových kroků pro správnost a úplnost:

1. Parsování: Nástroj zpracuje váš JSON dle standardu ECMA-404 a poskytuje detailní chyby při nesprávném nebo nejednoznačném vstupu.
2. Strukturální analýza: Vytváří stromovou reprezentaci dat, kde klasifikuje každou vlastnost a prvek podle základních JSON Schema typů (object, array, string, number, integer, boolean, null).
3. Rekurzivní průchod: Hloubkové a vnořené struktury — včetně polí objektů nebo vnořených polí — jsou rekurzivně analyzovány a vytváří se jejich vnořená schema.
4. Odvozování a spojování typů: Pro každou vlastnost nebo prvek pole jsou odvozeny typy. Pokud má vlastnost nebo položka smíšené typy, 'type' je vyjádřen jako pole typů (unijní typ) dle JSON Schema specifikace.
5. Detekce povinných a nepovinných: Analyzuje všechny objekty na každé úrovni a rozlišuje mezi klíči, které jsou vždy přítomny (povinné) a těmi, které mohou chybět (volitelné).
6. Omezení hodnot: Kde je to možné, nástroj odvozuje výčty hodnot (enum), minima/maxima pro čísla, minimální a maximální délku pro řetězce a formátové nápovědy (např. 'email', 'uri', 'date-time').
7. Zvláštní případy: Důraz se klade na prázdná pole, hodnoty null a řídké struktury — aby výsledné schema byly validní a odpovídaly reálné proměnlivosti dat.
8. Syntéza schema: Finální schema je vydáno jako standardní dokument Draft-07 — připravený k použití s nástroji jako Ajv, OpenAPI nebo knihovnami pro generování kódu.

Proč generovat JSON Schema? Praktické využití

• Automatická validace: Použijte vygenerovaná schema k prosazení datových kontraktů a validaci příchozích dat v API, mikroslužbách nebo CLI.
• Dokumentace API: Automaticky generujte dokumentaci a interaktivní prohlížeče (Swagger, Postman) s přesnými datovými definicemi.
• Generování kódu: Vytvářejte typově bezpečné modely nebo validátory v TypeScript, Pythonu, Javě a dalších jazycích pomocí schema jako jediného zdroje pravdy.
• Generování testovacích dat: Nástroje jako JSON Schema Faker nebo Mockaroo využívají schema k syntéze realistických testovacích dat pro kontrolu kvality a zátěžové testy.
• Refaktoring a migrace: Validujte stará nebo měnící se datová schémata a zajišťujte kompatibilitu během vývoje backendu.

Technické vlastnosti

• Podpora Draft-07 pro maximální interoperabilitu s hlavními validátory a platformami návrhu API.
• Rekurzivní analýza s libovolnou hloubkou zanoření — pole v polích, objekty v polích a další.
• Přesné odvození unijních typů (pole v 'type') pro pole či položky s různými typy napříč vzorky.
• Automatická detekce výčtů hodnot, délek, vzorů, formátů, minim a maxim atd.
• Explicitní podpora hodnot null, prázdných polí/objektů a částečných záznamů.
• Generování schema probíhá kompletně v prohlížeči. Váš vstupní JSON neopouští zařízení.

Technický příklad: ze vzorkového JSON na Draft-07 Schema

{
  "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"]
}

Jak používat tento nástroj JSON do JSON Schema

1. Vložte nebo napište svůj příklad JSON do editoru níže. Nástroj přijímá jakýkoli platný JSON, od jednoduchých objektů po hluboce vnořené struktury.
2. Klikněte na 'Vygenerovat JSON Schema' pro vytvoření a zobrazení výsledného JSON Schema.
3. Schema zkopírujte, upravte nebo stáhněte. Integrujte jej přímo do definic API, validační logiky nebo dokumentace.

Příklady kódu pro generování schématu z JSON

Zjistěte, jak generovat JSON Schema z JSON v různých programovacích jazycích.

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.