JSON Schema Generator — Complete Guide (हिंदी)

JSON Schema ek declarative language hai JSON documents ko annotate aur validate karne ke liye. Current stable release Draft 2020-12 hai।

JSON Schema kya karta hai

• Validation — Runtime pe verify karo ki JSON data expected structure follow karta hai
• Documentation — Self-documenting API contracts jo humans aur machines dono read kar sakein
• Code generation — Schema se TypeScript interfaces, Python dataclasses, Go structs generate karo
• UI generation — react-jsonschema-form jaise tools schema se automatically forms render karte hain
• IDE support — JSON aur YAML files ko schema mila do toh autocomplete aur inline errors milenge

Simple Schema Example

// Sample JSON:
{
  "id": 42,
  "username": "jsmith",
  "email": "jsmith@example.com",
  "age": 30,
  "active": true
}

// Generated JSON Schema (Draft 2020-12):
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "id":       { "type": "integer" },
    "username": { "type": "string", "minLength": 3, "maxLength": 30 },
    "email":    { "type": "string", "format": "email" },
    "age":      { "type": "integer", "minimum": 0, "maximum": 150 },
    "active":   { "type": "boolean" }
  },
  "required": ["id", "username", "email"],
  "additionalProperties": false
}

Draft Version History

Core Data Types

String Keywords — Practical Examples

{
  "type": "string",
  "minLength": 8,
  "maxLength": 128,
  "pattern": "^[A-Z]{2}\d{6}$",
  "format": "email"
  // Formats: email, uri, uuid, date, date-time, ipv4, ipv6, hostname
}

Conditional Keywords (Draft 7+)

{
  "type": "object",
  "properties": {
    "accountType": { "enum": ["personal", "business"] },
    "companyName": { "type": "string" }
  },
  "if": {
    "properties": { "accountType": { "const": "business" } }
  },
  "then": {
    "required": ["companyName"]   // Business account mein company required
  }
}

required — Mandatory Fields

{
  "type": "object",
  "properties": {
    "id":       { "type": "integer" },
    "email":    { "type": "string", "format": "email" },
    "password": { "type": "string", "minLength": 8 },
    "nickname": { "type": "string" }    // Optional — required mein nahi
  },
  "required": ["id", "email", "password"]
}

// VALID:   { "id": 1, "email": "a@b.com", "password": "secret123" }
// INVALID: { "id": 1, "email": "a@b.com" }
//          → "required property 'password' is missing"

additionalProperties — Object Shape Control

// Strict: unknown keys reject karo
{
  "type": "object",
  "properties": { "name": { "type": "string" } },
  "additionalProperties": false
}
// INVALID: { "name": "Alice", "hackerField": "malicious" }

// Flexible: extra keys allowed but constrained
{
  "additionalProperties": { "type": "string" }
}

pattern — Regex Validation

{
  "username": { "pattern": "^[a-zA-Z0-9_]{3,30}$" },
  "phone":    { "pattern": "^\+91[6-9]\d{9}$" },  // Indian phone numbers
  "hexColor": { "pattern": "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$" },
  "slug":     { "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" }
}

Common Mistake — properties ≠ required

// GALAT SAMAJH — properties sirf define karta hai, enforce nahi
{
  "type": "object",
  "properties": { "name": { "type": "string" } }
}
// {} is VALID! properties ki value abhi bhi optional hai.

// SAHI: required alag se likhna padta hai
{
  "type": "object",
  "properties": { "name": { "type": "string" } },
  "required": ["name"]
}

JSON Schema APIs ki description ka backbone hai। OpenAPI 3.1 ne JSON Schema Draft 2020-12 ke saath full alignment kiya hai।

OpenAPI 3.1 ke saath JSON Schema

openapi: 3.1.0
components:
  schemas:
    CreateUserRequest:
      type: object
      properties:
        username:
          type: string
          minLength: 3
          pattern: '^[a-zA-Z0-9_]+$'
        email:
          type: string
          format: email
        password:
          type: string
          minLength: 8
          writeOnly: true  # Sirf request mein, response mein nahi
      required: [username, email, password]
      additionalProperties: false

Node.js mein Ajv se Runtime Validation

import Ajv from 'ajv';
import addFormats from 'ajv-formats';

const ajv = new Ajv({ allErrors: true });
addFormats(ajv);

const schema = {
  type: "object",
  properties: {
    email: { type: "string", format: "email" },
    age:   { type: "integer", minimum: 0 }
  },
  required: ["email"]
};

const validate = ajv.compile(schema);
const data = { email: "not-valid", age: -5 };

if (!validate(data)) {
  console.error(validate.errors);
  // [
  //   { instancePath: '/email', message: 'must match format "email"' },
  //   { instancePath: '/age', message: 'must be >= 0' }
  // ]
}

TypeScript Code Generation

# JSON Schema se TypeScript interfaces generate karo
npm install -g json-schema-to-typescript
json2ts -i user.schema.json -o user.types.ts

Comparison Table

Decision Guide

JSON Schema use karo jab:
  ✓ Language-agnostic APIs (Go, Python consumers bhi hain)
  ✓ OpenAPI/Swagger documentation required hai
  ✓ Config files ke liye IDE support chahiye
  ✓ Form generation (react-jsonschema-form)

TypeScript Interface use karo jab:
  ✓ Pure TypeScript codebase, runtime validation needed nahi
  ✓ Performance-critical code
  ✓ Simple type annotation

Zod use karo jab:
  ✓ Next.js, tRPC, Remix fullstack apps
  ✓ Types aur runtime validation ek saath chahiye
  ✓ Form validation with great error messages

Zod se JSON Schema Generate Karo

import { z } from 'zod';
import { zodToJsonSchema } from 'zod-to-json-schema';

const UserSchema = z.object({
  id:       z.number().int().positive(),
  username: z.string().min(3).max(30).regex(/^[a-zA-Z0-9_]+$/),
  email:    z.string().email(),
});

type User = z.infer;         // TypeScript type
const jsonSchema = zodToJsonSchema(UserSchema); // JSON Schema for OpenAPI

Mistake 1: additionalProperties + allOf Bug

// GALAT (Draft 4-7 mein):
{
  "allOf": [{ "$ref": "#/$defs/Base" }],
  "additionalProperties": false  // Sirf apni properties dekhta hai, Base ki nahi!
}

// SAHI (Draft 2020-12):
{
  "allOf": [{ "$ref": "#/$defs/Base" }],
  "unevaluatedProperties": false  // Sab subschemas ki properties dekhta hai
}

Mistake 2: Pattern mein Double Escaping

// GALAT (JSON parse error):
{ "pattern": "^d{3}-d{4}$" }

// SAHI (double backslash in JSON string):
{ "pattern": "^\d{3}-\d{4}$" }

Mistake 3: Null vs Missing Property

// Absent: { "id": 1 }              (key exist nahi karta)
// Null:   { "id": 1, "bio": null } (key hai, value null hai)

// Dono allow karne ke liye:
{
  "properties": {
    "bio": { "type": ["string", "null"] }  // Draft 2020-12 shorthand
  }
  // "bio" required[] mein nahi — absent bhi valid
}

$defs se Reusable Components

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Address": {
      "type": "object",
      "properties": {
        "street":  { "type": "string" },
        "city":    { "type": "string" },
        "pincode": { "type": "string", "pattern": "^[1-9][0-9]{5}$" }
      },
      "required": ["street", "city", "pincode"]
    }
  },
  "type": "object",
  "properties": {
    "billingAddress":  { "$ref": "#/$defs/Address" },
    "shippingAddress": { "$ref": "#/$defs/Address" }
  }
}

Iss approach se:

• Address schema ek jagah define hai — do jagah reuse hota hai
• Address change karne par dono references automatically update ho jaate hain
• Schema smaller aur maintainable rehta hai