🥮 mooncakes.io

jsonschema

JSON Schema validator and code generator for MoonBit

jsonschema
validation
codegen
moon add mizchi/jsonschema@0.8.1
Download zip
Author
Version
0.8.1
License
MIT
Repository
Last updated
16 hours ago
Downloads
4K
README

#@mizchi/jsonschema

$ moon add mizchi/jsonschema

#Features

  • Parse raw json schema to build Validator
  • Schema Builder like a zod
  • Moonbit Code generation from json schema
    • mizchi/jsonschema/codegen

#Supported

#LICENSE

MIT

#
Validatable

source
pub trait Validatable {
  fn validate(Self, Json, resolver~ : Resolver, json_path~ : JsonPointer, schema_path~ : JsonPointer) -> Array[ValidationError]
}

#
ParseError

source
pub suberror ParseError {
  JsonDecodeError(
JsonDecodeError)
  PointerParseError(String)
  InvalidSchema(String)
}

JsonSchema compilation errors

#
AllOfSchema

source
pub struct AllOfSchema {
  schemas : Array[JsonSchema]
} derive(Eq, 
Debug)

#
AnyOfSchema

source
pub struct AnyOfSchema {
  schemas : Array[JsonSchema]
} derive(Eq, 
Debug)

#
AnySchema

source

#
ArraySchema

source
pub struct ArraySchema {
  items : JsonSchema?
  prefix_items : Array[JsonSchema]?
  contains : JsonSchema?
  min_contains : Int?
  max_contains : Int?
  min_items : Int?
  max_items : Int?
} derive(Eq, 
Debug, 
FromJson)

#
BooleanSchema

source

#
Builder

source
pub struct Builder {
} derive(Eq, 
Debug)

Schema builder like a zod schema Example usage:
let b = @jsonschema.Builder::new()
let schema = b.object(
  properties={
    name: b.string(),
    age: b.number(),
  },
  required=["name", "age"],
)
let _result = schema.validate({ "name": "Alice", "age": 30.0 }).unwrap()

#
Builder::all_of

source
fn Builder::all_of(_self : Builder, schemas : Array[JsonSchema]) -> JsonSchema

{ "allOf": [...] }

#
Builder::any

source
fn Builder::any(_self : Builder) -> JsonSchema

{ "type": "any" }

#
Builder::any_of

source
fn Builder::any_of(_self : Builder, schemas : Array[JsonSchema]) -> JsonSchema

{ "anyOf": [...] }

#
Builder::array

source
fn Builder::array(_self : Builder, items? : JsonSchema, prefix_items? : Array[JsonSchema], contains? : JsonSchema, min_contains? : Int, max_contains? : Int, min_items? : Int, max_items? : Int) -> JsonSchema

{ "type": "array" }

#
Builder::boolean

source
fn Builder::boolean(_self : Builder) -> JsonSchema

{ "type": "boolean" }

#
Builder::const_

source
fn Builder::const_(_self : Builder, value : Json) -> JsonSchema

{ "const": value }

#
Builder::enum_

source
fn Builder::enum_(_self : Builder, values : Array[Json]) -> JsonSchema

{ "enum": [...] }

#
Builder::enumerable_one_of

source
fn Builder::enumerable_one_of(self : Builder, tag : String, schemas : Array[JsonSchema], params~ : JsonSchema?) -> JsonSchema

{ "oneOf": [...] }

#
Builder::integer

source
fn Builder::integer(_self : Builder, minimum? : Int, maximum? : Int, exclusive_minimum? : Int, exclusive_maximum? : Int) -> JsonSchema

{ "type": "integer" }

#
Builder::new

source
fn Builder::new() -> Builder

#
Builder::null

source
fn Builder::null(_self : Builder) -> JsonSchema

{ "type": "null" }

#
Builder::number

source
fn Builder::number(_self : Builder, minimum? : Double, maximum? : Double, exclusive_minimum? : Double, exclusive_maximum? : Double) -> JsonSchema

{ "type": "number" }

#
Builder::object

source
fn Builder::object(_self : Builder, properties? : Map[String, JsonSchema], required? : Array[String], additional_properties? : JsonSchema, required_all? : Bool) -> JsonSchema

{ "type": "object" }

#
Builder::one_of

source
fn Builder::one_of(_self : Builder, schemas : Array[JsonSchema]) -> JsonSchema

{ "oneOf": [...] }

#
Builder::ref_

source
fn Builder::ref_(_self : Builder, pointer : JsonPointer) -> JsonSchema

#
Builder::ref_from_string

source
fn Builder::ref_from_string(_self : Builder, pointer : String) -> JsonSchema

{ "$ref": ... }

#
Builder::string

source
fn Builder::string(_self : Builder, minLength? : Int, maxLength? : Int, enum_? : Array[String]) -> JsonSchema

{ "type": "string" }

#
ConstSchema

source

#
EnumSchema

source

#
Enumerable

source
pub(all) struct Enumerable {
  tag : String
  positionals : Array[JsonSchema]?
  params : Map[String, JsonSchema]?
} derive(Eq, 
Debug)

#
Enumerable::new

source
fn Enumerable::new(tag : String, positionals : Array[JsonSchema]?, params : Map[String, JsonSchema]?) -> Enumerable

#
Enumerable::parse_enumerable

source
fn Enumerable::parse_enumerable(schema : OneOfSchema) -> Array[Enumerable]?

#
IntegerSchema

source

#
JsonPointer

source
pub(all) enum JsonPointer {
  Root
  Key(JsonPointer, key~ : String)
  Index(JsonPointer, index~ : Int)
} derive(Eq, Hash, ToJson, 
Debug, 
FromJson)

@json.JsonPath-like API
impl Show for JsonPointer

#
JsonPointer::access

source
fn JsonPointer::access(self : JsonPointer, json : Json) -> Json?

#
JsonPointer::from_string

source
fn JsonPointer::from_string(pointer : String) -> Result[JsonPointer, String]

Parse JSON Pointer string into JsonPointer

#
JsonPointer::index

source
fn JsonPointer::index(self : JsonPointer, index : Int) -> JsonPointer

#
JsonPointer::key

source
fn JsonPointer::key(self : JsonPointer, key : String) -> JsonPointer

#
JsonSchema

source
pub enum JsonSchema {
  Any(AnySchema)
  Null(NullSchema)
  Boolean(BooleanSchema)
  String(StringSchema)
  Number(NumberSchema)
  Integer(IntegerSchema)
  Array(ArraySchema)
  Object(ObjectSchema)
  AnyOf(AnyOfSchema)
  AllOf(AllOfSchema)
  OneOf(OneOfSchema)
  Ref(RefSchema)
  Enum(EnumSchema)
  Const(ConstSchema)
} derive(Eq, 
Debug)

JsonSchema

#
NullSchema

source

#
NumberSchema

source
pub struct NumberSchema {
  minimum : Double?
  maximum : Double?
  exclusive_minimum : Double?
  exclusive_maximum : Double?
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
ObjectSchema

source
pub struct ObjectSchema {
  properties : Map[String, JsonSchema]?
  required : Array[String]?
  additional_properties : JsonSchema?
} derive(Eq, 
Debug, 
FromJson)

#
OneOfSchema

source
pub struct OneOfSchema {
  schemas : Array[JsonSchema]
  parsed_nullable : JsonSchema?
  parsed_enumerable : Array[Enumerable]?
} derive(Eq, 
Debug)

OneOf schema

#
OneOfSchema::parse_nullable

source
fn OneOfSchema::parse_nullable(schema : OneOfSchema) -> JsonSchema?

detect nullable enumerable by [ , {"type": "null"}]

#
RefSchema

source

#
Resolver

source
pub struct Resolver {
  // private fields
}

#
Resolver::get_refs

source
fn Resolver::get_refs(self : Resolver) -> Array[JsonPointer]

#
Resolver::has

source
fn Resolver::has(self : Resolver, ref_expr : JsonPointer) -> Bool

#
Resolver::new

source
fn Resolver::new(root_json : Json) -> Resolver raise ParseError

#
Resolver::resolve

source
fn Resolver::resolve(self : Resolver, pointer : JsonPointer) -> JsonSchema?

#
StringSchema

source
pub struct StringSchema {
  min_length : Int?
  max_length : Int?
  enum_ : Array[String]?
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
ValidationError

source
pub struct ValidationError {
  input : Json
  json_path : JsonPointer
  schema_path : JsonPointer
  message : String
  children : Array[ValidationError]?
} derive(Eq, 
Debug)

#
ValidationError::new

source
fn ValidationError::new(input : Json, json_path : JsonPointer, schema_path : JsonPointer, message : String, children? : Array[ValidationError]) -> ValidationError

#
Validator

source
type Validator

#
Validator::validate

source
fn Validator::validate(self : Validator, input : Json) -> Result[Unit, Array[ValidationError]]

#
build_resolver

source
fn build_resolver(root_json : Json) -> Resolver raise ParseError

#
build_validator

source
fn build_validator(raw : Json) -> Validator raise

Example:
let jsonschema : Json = { "type": "string" }
let validator = build_validator(jsonschema)
let _result = validator.validate("hello")

#
collect_refs

source
fn collect_refs(json : Json) -> 
Set[String]

get $ref references in json

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io