JSON Structure SDKs

Official SDKs for validating JSON documents against JSON Structure schemas.

JSON Structure is a type-oriented schema language for JSON, designed for defining data structures that can be validated and mapped to programming language types.

Available SDKs

Language	Package	Status
Python	json-structure	✅ Available
.NET	JsonStructure	✅ Available
Java	json-structure	✅ Available
TypeScript/JavaScript	json-structure	✅ Available
Go	github.com/json-structure/sdk/go	✅ Available
Rust	json-structure	✅ Available
Perl	JSON::Structure	✅ Available
C	json-structure	✅ Available

Features

All SDKs provide:

• Schema Validation: Validate JSON Structure schema documents for correctness
• Instance Validation: Validate JSON instances against JSON Structure schemas
• Full Type Support: All 34 primitive and compound types from JSON Structure Core v0
• Extensions: Support for validation addins, conditional composition, and imports

Quick Start

Python

pip install json-structure

from json_structure import InstanceValidator, SchemaValidator

# Validate a schema
schema = {
    "$schema": "https://json-structure.org/meta/core/v0/#",
    "name": "Person",
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "int32"}
    }
}

schema_validator = SchemaValidator()
schema_errors = schema_validator.validate(schema)

# Validate an instance
instance = {"name": "Alice", "age": 30}
instance_validator = InstanceValidator(schema)
instance_errors = instance_validator.validate_instance(instance)

.NET

dotnet add package JsonStructure

using JsonStructure.Validation;
using System.Text.Json.Nodes;

// Validate a schema
var schema = JsonNode.Parse("""
{
    "$schema": "https://json-structure.org/meta/core/v0/#",
    "name": "Person",
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "int32"}
    }
}
""");

var schemaValidator = new SchemaValidator();
var schemaResult = schemaValidator.Validate(schema);

// Validate an instance
var instance = JsonNode.Parse("""{"name": "Alice", "age": 30}""");
var instanceValidator = new InstanceValidator();
var instanceResult = instanceValidator.Validate(instance, schema);

Java

<dependency>
    <groupId>org.json-structure</groupId>
    <artifactId>json-structure</artifactId>
    <version>0.1.0</version>
</dependency>

import org.json_structure.validation.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();

// Validate a schema
JsonNode schema = mapper.readTree("""
{
    "$schema": "https://json-structure.org/meta/core/v0/#",
    "name": "Person",
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "int32"}
    }
}
""");

SchemaValidator schemaValidator = new SchemaValidator();
ValidationResult schemaResult = schemaValidator.validate(schema);

// Validate an instance
JsonNode instance = mapper.readTree("{\"name\": \"Alice\", \"age\": 30}");
InstanceValidator instanceValidator = new InstanceValidator();
ValidationResult instanceResult = instanceValidator.validate(instance, schema);

TypeScript/JavaScript

npm install json-structure

import { SchemaValidator, InstanceValidator } from 'json-structure';

// Validate a schema
const schema = {
  $schema: 'https://json-structure.org/meta/core/v0/#',
  name: 'Person',
  type: 'object',
  properties: {
    name: { type: 'string' },
    age: { type: 'int32' }
  }
};

const schemaValidator = new SchemaValidator();
const schemaResult = schemaValidator.validate(schema);

// Validate an instance
const instance = { name: 'Alice', age: 30 };
const instanceValidator = new InstanceValidator();
const instanceResult = instanceValidator.validate(instance, schema);

Go

go get github.com/json-structure/sdk/go

package main

import (
    "encoding/json"
    "fmt"
    jsonstructure "github.com/json-structure/sdk/go"
)

func main() {
    // Define a schema
    schemaJSON := `{
        "$schema": "https://json-structure.org/meta/core/v0/#",
        "name": "Person",
        "type": "object",
        "properties": {
            "name": {"type": "string"},
            "age": {"type": "int32"}
        }
    }`

    var schema map[string]interface{}
    json.Unmarshal([]byte(schemaJSON), &schema)

    // Validate the schema
    schemaValidator := jsonstructure.NewSchemaValidator(nil)
    schemaResult := schemaValidator.Validate(schema)
    fmt.Printf("Schema valid: %v\n", schemaResult.IsValid)

    // Validate an instance
    instance := map[string]interface{}{
        "name": "Alice",
        "age":  float64(30),
    }

    instanceValidator := jsonstructure.NewInstanceValidator(nil)
    instanceResult := instanceValidator.Validate(instance, schema)
    fmt.Printf("Instance valid: %v\n", instanceResult.IsValid)
}

Perl

cpanm JSON::Structure

use JSON::Structure::SchemaValidator;
use JSON::Structure::InstanceValidator;
use JSON::MaybeXS;

# Define a schema
my $schema = decode_json(q|{
    "$schema": "https://json-structure.org/meta/core/v0/#",
    "name": "Person",
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "int32"}
    }
}|);

# Validate the schema
my $schema_validator = JSON::Structure::SchemaValidator->new();
my $schema_result = $schema_validator->validate($schema);
print "Schema valid: ", ($schema_result->is_valid ? "true" : "false"), "\n";

# Validate an instance
my $instance = decode_json('{"name": "Alice", "age": 30}');
my $instance_validator = JSON::Structure::InstanceValidator->new(schema => $schema);
my $instance_result = $instance_validator->validate($instance);
print "Instance valid: ", ($instance_result->is_valid ? "true" : "false"), "\n";

Rust

cargo add json-structure

use json_structure::{SchemaValidator, InstanceValidator};
use serde_json::json;

fn main() {
    // Define a schema
    let schema = json!({
        "$schema": "https://json-structure.org/meta/core/v0/#",
        "name": "Person",
        "type": "object",
        "properties": {
            "name": {"type": "string"},
            "age": {"type": "int32"}
        }
    });

    // Validate the schema
    let schema_validator = SchemaValidator::new();
    let schema_result = schema_validator.validate(&schema);
    println!("Schema valid: {}", schema_result.is_valid());

    // Validate an instance
    let instance = json!({"name": "Alice", "age": 30});
    let instance_validator = InstanceValidator::new();
    let instance_result = instance_validator.validate(&instance, &schema);
    println!("Instance valid: {}", instance_result.is_valid());
}

C

# Build with CMake
mkdir build && cd build
cmake ..
cmake --build .

#include "json_structure.h"
#include <stdio.h>

int main() {
    // Define a schema
    const char* schema_json = "{\n"
        "\"$schema\": \"https://json-structure.org/meta/core/v0/#\",\n"
        "\"name\": \"Person\",\n"
        "\"type\": \"object\",\n"
        "\"properties\": {\n"
        "    \"name\": {\"type\": \"string\"},\n"
        "    \"age\": {\"type\": \"int32\"}\n"
        "}\n"
    "}";

    // Parse and validate the schema
    cJSON* schema = cJSON_Parse(schema_json);
    JsValidationResult result = js_validate_schema(schema);
    printf("Schema valid: %s\n", result.is_valid ? "true" : "false");
    js_result_cleanup(&result);

    // Validate an instance
    const char* instance_json = "{\"name\": \"Alice\", \"age\": 30}";
    cJSON* instance = cJSON_Parse(instance_json);
    result = js_validate_instance(instance, schema);
    printf("Instance valid: %s\n", result.is_valid ? "true" : "false");
    
    js_result_cleanup(&result);
    cJSON_Delete(instance);
    cJSON_Delete(schema);
    return 0;
}

Documentation

• JSON Structure Specification
• JSON Structure Primer

Contributing

Contributions are welcome! Please see the individual SDK directories for language-specific contribution guidelines.

License

MIT License - see LICENSE for details.