Verkossa JSON JSON-skeemaksi -luoja

Miten skeeman generointi toimii taustalla

JSON-skeeman generointi esimerkkijsonista on enemmän kuin kenttien ja tyyppien yhdistämistä. Tämä työkalu hyödyntää useita keskeisiä vaiheita oikeellisuuden ja täydellisyyden varmistamiseksi:

1. Jäsentäminen: Työkalu jäsentää JSONisi käyttäen ECMA-404 -standardia ja raportoi yksityiskohtaiset virheet sopimattomasta syötteestä tai epäselvistä rakenteista.
2. Rakenneanalyysi: Se rakentaa puuesityksen tiedoistasi, ja luokittelee jokaisen ominaisuuden ja elementin JSON Schema:n ydintyyppeihin (objekti, taulukko, merkkijono, numero, kokonaisluku, totuusarvo, null).
3. Rekursiivinen läpikäynti: Syvät ja sisäkkäiset rakenteet – mukaan lukien objekteja sisältävät taulukot tai sisäkkäiset taulukot – käydään läpi rekursiivisesti, jotta saadaan aikaan sisäkkäiset skeemamäärittelyt.
4. Tyyppien päättely ja yhdistäminen: Jokaiselle ominaisuudelle tai taulukon alkiolle tyypit päätellään. Jos ominaisuuksilla tai alkioilla on useita tyyppejä, "type" ilmaistaan taulukkona (liittymätyyppi) JSON Schema -määrityksen mukaisesti.
5. Vaadittujen vs. valinnaisten tunnistus: Analysoimalla kaikki tason objektit työkalu erottaa aina läsnä olevat (vaaditut) ja joskus puuttuvat (valinnaiset) avaimet.
6. Arvorajoitteet: Mahdollisuuksien mukaan työkalu päättelee enum-arvot (sallitut arvot), minimi/maximi luvuille, minLength/maxLength merkkijonoille ja formaattivihjeet (kuten 'email', 'uri', tai 'date-time').
7. Poikkeustapausten käsittely: Erityishuomiota kiinnitetään tyhjiin taulukoihin, null-arvoihin ja harvakkeisiin rakenteisiin – varmistaen validit skeemat, jotka vastaavat todellista vaihtelua.
8. Skeeman koostaminen: Lopullinen skeema tuotetaan standardinmukaisena Draft-07 -dokumenttina – käyttövalmiina esimerkiksi Ajv:n, OpenAPI:n tai koodigenerointikirjastojen kanssa.

Miksi luoda JSON-skeema? Käytännön käyttötarkoitukset

• Automaattinen validointi: Käytä luotuja skeemoja tiedonsopimusten varmistamiseen ja saapuvien datakuormien validointiin API:ssasi, mikropalveluissa tai komentorivityökaluissa.
• API-dokumentaatio: Luo automaattisesti dokumentaatiota ja vuorovaikutteisia selaimia (Swagger, Postman) tarkkojen tietomääritysten kanssa.
• Koodigenerointi: Luo tyyppiturvallisia malleja tai validoijia TypeScriptille, Pythonille, Javalle ja muille kielille käyttäen skeemaasi yhtenä totuuden lähteenä.
• Testidatan generointi: Työkalut kuten JSON Schema Faker tai Mockaroo käyttävät skeemoja realistisen mock-datan syntetisointiin laadunvarmistus- ja kuormitustesteissä.
• Refaktorointi & migraatio: Validioi vanhoja tai muuttuvia datastruktuureja varmistaen yhteensopivuus backendin kehittyessä.

Tekniset ominaisuudet

• Draft-07-yhteensopivuus maksimaaliseen yhteentoimivuuteen tärkeimpien validoijien ja API-suunnittelualustojen kanssa.
• Rekursiivinen analysointi mielivaltaisen syvyisille rakenteille – taulukot taulukoiden sisällä, objektit taulukoissa ja paljon muuta.
• Tarkka liittymätyypeille ("type"-taulukko) päättely kentille tai alkioille, jotka vaihtelevat eri esimerkeissä.
• Automaattinen enumien, pituuden, mallin, formaatin, minimi/maximi ja muiden yleisten rajoitteiden tunnistus.
• Selkeä tuki null-arvoille, tyhjille taulukoille/objekteille ja osittaisille tietueille.
• Skeeman generointi tapahtuu kokonaan selaimessasi. Syöttämäsi JSON ei koskaan poistu laitteeltasi.

Tekninen esimerkki: Esimerkkijsonista Draft-07 -skeemaksi

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

Näin käytät tätä JSON JSON-skeemaksi -työkalua

1. Liitä tai kirjoita esimerkkisi JSON-editoriin alla. Työkalu hyväksyy kaiken kelvollisen JSONin, yksinkertaisista objekteista syvästi sisäkkäisiin rakenteisiin.
2. Klikkaa 'Luo JSON-skeema' nähdäksesi luodun skeeman.
3. Kopioi, muokkaa tai lataa skeema. Ota se suoraan käyttöön API-määrittelyihisi, validointilogiikkaasi tai dokumentaatioosi.

Esimerkkikoodit JSON:n muuntamiseen skeemaksi

Katso, miten luodaan JSON-skeema JSON-tiedostosta eri ohjelmointikielillä.

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.