Générateur en ligne de JSON vers JSON Schema

Fonctionnement interne de la génération de schéma

Générer un JSON Schema à partir d'un JSON exemple nécessite plus que d'associer simplement champs et types. Cet outil suit plusieurs étapes clés pour garantir précision et exhaustivité :

1. Analyse syntaxique : L'outil analyse votre JSON selon la norme ECMA-404, signalant en détail les erreurs ou ambiguïtés dans le code source.
2. Analyse structurelle : Il construit une représentation arborescente de vos données, classifiant chaque propriété et élément selon les types fondamentaux de JSON Schema (objet, tableau, chaîne, nombre, entier, booléen, null).
3. Parcours récursif : Les structures profondes et imbriquées—tableaux d'objets ou tableaux imbriqués—sont parcourues récursivement pour produire des définitions de schéma imbriquées.
4. Inférence et fusion des types : Pour chaque propriété ou élément, les types sont déduits. En cas de types mixtes, le 'type' est exprimé par un tableau (type union) selon la spécification JSON Schema.
5. Détection requis vs optionnel : En analysant tous les objets à chaque niveau, l’outil distingue entre clés toujours présentes (requises) et clés parfois absentes (optionnelles).
6. Contraintes de valeur : Lorsque possible, l’outil infère des énumérations (ensembles de valeurs autorisées), min/max pour nombres, minLength/maxLength pour chaînes, et formats ('email', 'uri', 'date-time').
7. Gestion des cas limites : Une attention particulière est portée aux tableaux vides, valeurs null, et structures creuses pour garantir des schémas valides couvrant la variabilité réelle.
8. Synthèse du schéma : Le schéma final est généré comme un document conforme au Draft-07, prêt à être utilisé avec Ajv, OpenAPI ou des bibliothèques de génération de code.

Pourquoi générer un JSON Schema ? Usages pratiques

• Validation automatisée : Utilisez les schémas générés pour appliquer des contrats de données et valider les payloads entrants dans vos API, microservices ou CLI.
• Documentation API : Auto-générez documentations et explorateurs interactifs (Swagger, Postman) avec des définitions de données précises.
• Génération de code : Créez des modèles ou validateurs typés en TypeScript, Python, Java et autres, en utilisant le schéma comme source unique de vérité.
• Génération de données de test : Des outils comme JSON Schema Faker ou Mockaroo utilisent des schémas pour synthétiser des données factices réalistes pour QA et tests de charge.
• Refactoring & migration : Validez des structures de données legacy ou évolutives, assurant la compatibilité lors de l’évolution du backend.

Fonctionnalités techniques

• Compatibilité Draft-07 pour une interopérabilité maximale avec les principaux validateurs et plateformes de conception API.
• Analyse récursive de profondeur illimitée—tableaux dans tableaux, objets dans tableaux, etc.
• Inférence précise des types union (tableau 'type') pour champs ou éléments variant entre échantillons.
• Détection automatique des enums, longueurs, motifs, formats, min/max et autres contraintes courantes.
• Prise en charge explicite des null, tableaux/objets vides et enregistrements partiels.
• La génération de schéma s’effectue entièrement dans le navigateur. Votre JSON ne quitte jamais votre appareil.

Exemple technique : Du JSON exemple au schéma 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"]
}

Comment utiliser cet outil JSON vers JSON Schema

1. Collez ou saisissez votre JSON exemple dans l'éditeur ci-dessous. L’outil accepte tout JSON valide, des objets simples aux structures profondément imbriquées.
2. Cliquez sur « Générer le schéma JSON » pour créer et visualiser le JSON Schema généré.
3. Copiez, modifiez ou téléchargez le schéma. Intégrez-le directement dans vos définitions d’API, logiques de validation ou documentations.

Exemples de code pour la génération de schémas à partir de JSON

Découvrez comment générer un schéma JSON à partir de JSON dans divers langages de programmation.

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.