moonschema

moon add moonbitstack/moonschema

fn main raise {
  let schema = @moonschema.Schema::new(
    @json.parse(
      (
        #|{ "type": "object",
        #|  "properties": { "port": { "type": "integer", "minimum": 1 } },
        #|  "required": ["port"] }
      ),
    ),
  )
  println(schema.valid(@json.parse("{\"port\": 8080}")))
  for fault in schema.faults(@json.parse("{\"port\": 0}")) {
    println(fault.to_string())
  }
}

true
/port: below the minimum (minimum at /properties/port/minimum)

#What it answers

#A fault

#Four ways to say it

let schema = @moonschema.Schema::new(@json.parse("{ \"type\": \"integer\" }"))
let report = schema.report(@json.parse("\"seven\""), output=@moonschema.Output::Basic)
println(report.to_json().stringify(indent=2))

{
  "valid": false,
  "errors": [
    {
      "valid": false,
      "keywordLocation": "/type",
      "instanceLocation": "",
      "error": "not of type integer"
    }
  ]
}

#format

let schema = @moonschema.Schema::new(
  @json.parse("{ \"format\": \"ipv4\" }"),
  format=true,
)
println(schema.valid(@json.parse("\"not-an-ipv4\"")))   // false

#Versions

#References

let remote = @json.parse("{ \"$ref\": \"https://example.test/int\" }")
let schema = @moonschema.Schema::new(
  remote,
  remotes={
    "https://example.test/int": @json.parse("{ \"type\": \"integer\" }"),
  },
)
println(schema.valid(Json::number(1.0)))   // true

#Your own keywords

struct Even {}

pub impl @moonschema.Keyword for Even with fn name(_self) { "x-even" }

pub impl @moonschema.Keyword for Even with fn judge(_self, value, instance, site) {
  ignore(site)
  match (value, instance) {
    (True, Number(number, ..)) =>
      if number == (number / 2.0).floor() * 2.0 {
        Accept
      } else {
        Refuse(why="odd")
      }
    _ => Accept
  }
}

pub extend Even with @moonschema.Keyword::{name, judge}

struct Counting {}

pub impl @moonschema.Vocabulary for Counting with fn uri(_self) {
  "https://example.test/vocab/counting"
}

pub impl @moonschema.Vocabulary for Counting with fn keywords(_self) {
  let even : &@moonschema.Keyword = Even::{  }
  [even]
}

pub extend Counting with Vocabulary::{uri, keywords}

#What it will not do

• Fetch a remote $ref. The seam is remotes; the caller fills it from wherever they keep them.
• Validate a schema against its metaschema. A schema is read for what it says, not checked for whether it should have said it. $schema picks the version; the rest is the schema author's.
• Hyper-schema. Links and media types are a different specification.
• Compile schemas to code. Interpretation first; a measurement is the time to argue about it.

#Examples

#Licence