Internetinis JSON į JSON schemą generatorius

Kaip veikia schemos generavimas po gaubtu

JSON schemos generavimas iš pavyzdžio JSON apima daugiau nei laukų priskyrimą tipams. Šis įrankis naudodamas kelis pagrindinius veiksmus užtikrina tikslumą ir pilnumą:

1. Analizė: Įrankis analizuoja jūsų JSON pagal ECMA-404 standartą, pateikdamas išsamius klaidų pranešimus dėl netaisyklingų ar dviprasmiškų konstrukcijų.
2. Struktūrinė analizė: Sukuriamas duomenų medis, kuriame kiekvienas atributas ir elementas priskiriamas JSON schemos pagrindiniams tipams (objektas, masyvas, eilutė, skaičius, sveikasis, boolean, null).
3. Rekursyvus perėjimas: Giliai įdėtos struktūros – įskaitant objektų masyvus arba įdėtus masyvus – peržvelgiamos rekursyviai, kad būtų sugeneruotos įdėtos schemų apibrėžtys.
4. Tipų spėjimas ir sujungimas: Kiekvienam laukui ar masyvo elementui nustatomi tipai. Jei laukai turi mišrius tipus, „type“ išreiškiamas kaip masyvas (sąjunga) pagal JSON schemos specifikacijas.
5. Privalomumo ir pasirinktinumo nustatymas: Analizuojant visus objektus kiekviename lygyje, įrankis atskiria visada esančius (privalomus) nuo kartais praleidžiamų (pasirinktinių) raktų.
6. Reikšmių apribojimai: Kur įmanoma, įrankis nustato enum (galimų reikšmių rinkinį), min/max skaičiams, minLength/maxLength eilutėms bei formatų užuominas (pavyzdžiui, „email“, „uri“ ar „date-time“).
7. Kraštutinių atvejų tvarkymas: Skiriamas ypatingas dėmesys tuštiems masyvams, null reikšmėms ir nevisiškoms struktūroms – užtikrinant galiojančias schemas, atitinkančias realaus pasaulio įvairovę.
8. Schemų sintezė: Galutinė schema išleidžiama kaip standartus atitinkantis Draft-07 dokumentas – paruoštas naudoti su įrankiais kaip Ajv, OpenAPI ar kodo generavimo bibliotekomis.

Kodėl verta generuoti JSON schemą? Praktiniai panaudojimai

• Automatinis validavimas: Naudokite sugeneruotas schemas duomenų sutarčių užtikrinimui ir įeinančių duomenų validavimui savo API, mikroservisuose ar CLI įrankiuose.
• API dokumentacija: Automatiškai generuokite dokumentaciją ir interaktyvius naršyklius (Swagger, Postman) su tiksliomis duomenų apibrėžtimis.
• Kodo generavimas: Kurkite tipams saugius modelius ar validavimo modulius TypeScript, Python, Java ir kitomis kalbomis, naudodami schemą kaip vienintelį tiesos šaltinį.
• Testinių duomenų generavimas: Įrankiai kaip JSON Schema Faker ar Mockaroo naudoja schemas sintezuoti realistiškus dirbtinius duomenis kokybės užtikrinimui ir apkrovos testams.
• Refaktoringas ir migracija: Validuokite senas ar kintančias duomenų struktūras, užtikrindami suderinamumą evoliucionuojant jūsų backend’ui.

Techninės ypatybės

• Suderinamumas su Draft-07 siekiant maksimalios sąveikos su populiariausiais validavimo įrankiais ir API dizaino platformomis.
• Rekursyvi bet kokio gilumo įdėtinių struktūrų analizė – masyvai masyvuose, objektai masyvuose ir daugiau.
• Tikslus tipų sąjungos („type“ masyvo) atpažinimas laukams ar elementams, kurie skiriasi tarp pavyzdžių.
• Automatinis enum, ilgio, šablono, formato, min/max ir kitų dažnų apribojimų aptikimas.
• Aiškus null, tuščių masyvų/objektų ir dalinių įrašų palaikymas.
• Schemų generavimas vyksta visiškai naršyklėje. Jūsų įvestas JSON nepalieka įrenginio.

Techninis pavyzdys: nuo JSON pavyzdžio iki Draft-07 schemos

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

Kaip naudoti šį JSON į JSON schemą įrankį

1. Įklijuokite arba įrašykite savo JSON pavyzdį žemiau esančiame redaktoriuje. Įrankis priima bet kokį galiojantį JSON – nuo paprastų objektų iki giliai įdėtų struktūrų.
2. Spustelėkite „Generuoti JSON schemą“, kad sugeneruotumėte ir peržiūrėtumėte JSON schemą.
3. Nukopijuokite, redaguokite ar atsisiųskite schemą. Integruokite ją tiesiogiai į savo API apibrėžimus, validavimo logiką ar dokumentaciją.

Kodo pavyzdžiai JSON į schemos generavimą

Sužinokite, kaip sukurti JSON schemą iš JSON naudojant įvairias programavimo kalbas.

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.