json2schema

Infer a JSON Schema (draft 2020-12) from any JSON value.
No real data values are ever copied into the output — only structural and type information.

• Supports all JSON primitive types: null, boolean, integer, number, string
• Recursively handles nested objects and arrays
• Smart array-item merging:
  • Homogeneous arrays → single items schema
  • Mixed-type arrays → anyOf with structurally deduplicated variants
• All object properties are marked as required and additionalProperties is set to false
• Emits $schema: https://json-schema.org/draft/2020-12/schema
• Zero runtime dependencies beyond the Nim standard library
• Works as a library (json2schemalib) or a CLI tool (json2schema)

json2schema/
├── src/
│   ├── json2schemalib.nim   # Core library (importable)
│   └── json2schema.nim      # CLI entry point
├── tests/
│   └── test_all.nim         # Full test suite (unittest)
├── examples/
│   ├── user.json            # Example: nested user object
│   ├── products.json        # Example: array of product objects
│   └── mixed.json           # Example: mixed types and structures
├── json2schema.nimble        # Nimble package descriptor
└── README.md

No third-party packages are needed.

nimble build

The binary is placed at bin/json2schema (or bin/json2schema.exe on Windows).

nim compile --opt:speed src/json2schema.nim

json2schema <input.json> [output.json]
json2schema -                           # read from stdin

# Print schema to stdout
json2schema examples/user.json

# Write schema to a file
json2schema examples/user.json user.schema.json

# Pipe from stdin
echo '{"name":"Alice","age":30}' | json2schema -

# Chain with jq
cat examples/products.json | json2schema - | jq '.properties'

Input (examples/user.json):

{
  "id": 1,
  "username": "alice",
  "active": true,
  "score": 9.75,
  "roles": ["admin", "user"],
  "address": { "city": "Springfield", "zip": "12345" },
  "metadata": null
}

Output (inferred schema — no real values):

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "id":       { "type": "integer" },
    "username": { "type": "string" },
    "active":   { "type": "boolean" },
    "score":    { "type": "number" },
    "roles": {
      "type": "array",
      "items": { "type": "string" }
    },
    "address": {
      "type": "object",
      "properties": {
        "city": { "type": "string" },
        "zip":  { "type": "string" }
      },
      "required": ["city", "zip"],
      "additionalProperties": false
    },
    "metadata": { "type": "null" }
  },
  "required": ["id", "username", "active", "score", "roles", "address", "metadata"],
  "additionalProperties": false
}

When an array contains elements of different types, anyOf is used:

// Input
{ "readings": [42, 3.14, "N/A", null] }

// Output (items portion)
"items": {
  "anyOf": [
    { "type": "integer" },
    { "type": "number" },
    { "type": "string" },
    { "type": "null" }
  ]
}

import json2schemalib
import std/json

let data = parseJson("""{"name":"Bob","scores":[10,20,30]}""")

# jsonToSchema — returns schema without $schema wrapper
let schema = jsonToSchema(data)

# buildSchema — adds $schema declaration at the top level
let fullSchema = buildSchema(data)

echo fullSchema.pretty()

nimble test

Or directly:

nim compile -r tests/test_all.nim

The suite covers:

• All primitive types (null, boolean, integer, number, string)
• No real values leaking into the schema (strings, numbers, nested values)
• Object structure: properties, required, additionalProperties
• Array inference: homogeneous, mixed, nested, array-of-objects deduplication
• mergeSchemas edge cases: empty, single, duplicates, anyOf
• buildSchema wrapper: $schema presence, top-level types
• Round-trip: output is always valid JSON

MIT — see LICENSE.