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"] }
      ),
    ),
  )
  assert_eq(schema.valid(@json.parse("{\"port\": 8080}")), true)
  let faults = schema.faults(@json.parse("{\"port\": 0}"))
  assert_eq(faults.length(), 1)
  assert_eq(
    faults[0].to_string(),
    "/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)
assert_eq(
  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,
)
assert_eq(schema.valid(@json.parse("\"not-an-ipv4\"")), false)
assert_eq(schema.valid(@json.parse("\"10.0.0.1\"")), true)

#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\" }"),
  },
)
assert_eq(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/even"
}

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

pub extend Counting with @moonschema.Vocabulary::{uri, keywords}

let metaschema = @json.parse(
  (
    #|{ "$id": "https://example.test/meta",
    #|  "$schema": "https://json-schema.org/draft/2020-12/schema",
    #|  "$vocabulary": {
    #|    "https://json-schema.org/draft/2020-12/vocab/validation": true,
    #|    "https://example.test/vocab/even": true } }
  ),
)
let remotes = { "https://example.test/meta": metaschema }
let registry = @moonschema.Registry::new()
registry.add(Counting::{  })
let schema = @moonschema.Schema::new(
  @json.parse(
    (
      #|{ "$schema": "https://example.test/meta",
      #|  "type": "integer", "x-even": true }
    ),
  ),
  remotes~,
  registry~,
)
assert_eq(schema.valid(@json.parse("4")), true)
assert_eq(
  schema.faults(@json.parse("5"))[0].to_string(),
  "the instance: odd (x-even at /x-even)",
)

#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