Generator JSON do JSON Schema Online

Jak działa generowanie schematu „pod maską”

Tworzenie JSON Schema na podstawie przykładowego JSON to coś więcej niż przypisanie pól do typów. Narzędzie stosuje kilka kluczowych kroków dla dokładności i kompletności:

1. Analiza składniowa: Narzędzie parsuje Twój JSON zgodnie ze standardem ECMA-404, zgłaszając szczegółowe błędy dla niepoprawnych danych lub niejednoznacznych konstrukcji.
2. Analiza strukturalna: Tworzy drzewiastą reprezentację danych, klasyfikując każdą właściwość i element według podstawowych typów JSON Schema (obiekt, tablica, string, number, integer, boolean, null).
3. Rekursywne przeszukiwanie: Głębokie i zagnieżdżone struktury — w tym tablice obiektów i zagnieżdżone tablice — są przetwarzane rekurencyjnie, aby wygenerować zagnieżdżone definicje schematu.
4. Wnioskowanie i łączenie typów: Dla każdej właściwości lub elementu tablicy typ jest wywnioskowany. Gdy pola mają mieszane typy, 'type' jest wyrażony jako tablica (typ unii), zgodnie ze specyfikacją JSON Schema.
5. Wykrywanie wymaganych i opcjonalnych: Przez analizę wszystkich obiektów na danym poziomie rozróżnia się klucze zawsze obecne (wymagane) i czasem brakujące (opcjonalne).
6. Ograniczenia wartości: Tam gdzie to możliwe, narzędzie wnioskowuje enumy (zbiór dozwolonych wartości), min/max dla liczb, minLength/maxLength dla stringów oraz wskazówki formatów (np. 'email', 'uri', 'date-time').
7. Obsługa przypadków brzegowych: Specjalna uwaga dla pustych tablic, nulli oraz rzadkich struktur — zapewniając poprawne schematy dopasowane do zmienności rzeczywistych danych.
8. Synteza schematu: Końcowy schemat jest generowany jako dokument zgodny ze standardem Draft-07 — gotowy do użycia z narzędziami takimi jak Ajv, OpenAPI czy biblioteki do generowania kodu.

Dlaczego warto generować JSON Schema? Praktyczne zastosowania

• Automatyczna walidacja: Używaj generowanych schematów do wymuszania kontraktów danych i walidacji przychodzących danych w Twoich API, mikroserwisach lub CLI.
• Dokumentacja API: Automatycznie generuj dokumentację i interaktywne przeglądarki (Swagger, Postman) z precyzyjnymi definicjami danych.
• Generowanie kodu: Twórz modele typowane lub walidatory w TypeScript, Python, Java i innych językach, używając schematu jako jedynego źródła prawdy.
• Generowanie danych testowych: Narzędzia jak JSON Schema Faker czy Mockaroo wykorzystują schematy do generowania realistycznych danych testowych dla QA i testów obciążeniowych.
• Refaktoryzacja i migracja: Waliduj starsze lub zmieniające się struktury danych, zapewniając kompatybilność wraz z rozwojem backendu.

Funkcje techniczne

• Zgodność z Draft-07 dla maksymalnej interoperacyjności z popularnymi walidatorami i platformami projektowania API.
• Rekursywna analiza dowolnej głębokości zagnieżdżeń — tablice w tablicach, obiekty w tablicach i więcej.
• Precyzyjne wnioskowanie typów unii ('type' jako tablica) dla pól lub elementów o zmiennych typach.
• Automatyczne wykrywanie enumów, długości, wzorców, formatów, min/max i innych powszechnych ograniczeń.
• Wyraźne wsparcie dla wartości null, pustych tablic/obiektów oraz rekordów częściowych.
• Generowanie schematów odbywa się w całości w przeglądarce. Twój JSON nigdy nie opuszcza Twojego urządzenia.

Przykład techniczny: Od przykładowego JSON do schematu 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"]
}

Jak korzystać z tego narzędzia JSON do JSON Schema

1. Wklej lub wpisz przykładowy JSON w edytor poniżej. Narzędzie akceptuje każdy poprawny JSON, od prostych obiektów po głęboko zagnieżdżone struktury.
2. Kliknij 'Wygeneruj JSON Schema', aby utworzyć i wyświetlić wygenerowany schemat JSON Schema.
3. Skopiuj, edytuj lub pobierz schemat. Zintegruj go bezpośrednio z definicjami API, logiką walidacji lub dokumentacją.

Przykłady kodu do generowania schematów z JSON

Dowiedz się, jak wygenerować schemat JSON (JSON Schema) z pliku JSON w różnych językach programowania.

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.