#Ion Schema (moonrockz/ion/schema)

#Schema documents

#ISL 1.0

• A type with no type constraint has type: any, so it matches no null. any also matches a document. In ISL 2.0, such a type matches any value.
• nullable::T matches null.null, the typed nulls of the Ion types of T's base type, and the values of T. The base type is the type that T's type constraint names, or any. For example, nullable::int matches null, null.int, and 5, but not null.string. There is no $null_or::.
• content: closed allows only the fields in the type's fields, which have no closed::.
• scale is the number of digits after the decimal point: scale: 2 is exponent: -2. There is no exponent, field_names, or ieee754_float.
• annotations takes only a list of symbols, annotated with any of required::, ordered::, and closed::. Each symbol can be required:: or optional::. With ordered, the required symbols must appear in order; with closed too, the value's annotations must be the symbols in order, the optional ones at most once.
• A valid occurs is allowed in any type, and has no effect outside fields and ordered_elements. element takes no distinct::.
• An inline type may be annotated type::, and an inline import may have an as, which has no effect.
• A bound of a timestamp range in valid_values must have a known offset.
• There are no reserved symbols: a top-level value that is not a header, a type, or a footer, and a field that is not an ISL 1.0 keyword, are open content. The header's imports is its only field with a meaning. A schema has a header only if it has a footer.

///|
test "load an ISL 1.0 schema" {
  let schema = @schema.Schema::load_from_text(
    (
      #|$ion_schema_1_0
      #|type::{
      #|  name: price,
      #|  content: closed,
      #|  fields: {
      #|    amount: { type: decimal, scale: 2, occurs: required },
      #|    note: nullable::string,
      #|  },
      #|}
    ),
  )
  assert_true(
    schema.is_valid("price", @text.read_ion("{ amount: 9.99, note: null }")),
  )
  // 9.9 has a scale of 1, `tax` is not a field of the type, and the default
  // type `any` has no null.
  assert_true(!schema.is_valid("price", @text.read_ion("{ amount: 9.9 }")))
  assert_true(
    !schema.is_valid("price", @text.read_ion("{ amount: 9.99, tax: 1.00 }")),
  )
  assert_true(!schema.is_valid("price", @text.read_ion("null.struct")))
}

#Validating values

///|
test "validate records against a type" {
  let definition =
    #|$ion_schema_2_0
    #|type::{
    #|  name: person,
    #|  type: struct,
    #|  fields: {
    #|    name: { type: string, occurs: required, codepoint_length: range::[1, 40] },
    #|    role: { valid_values: [admin, member, guest] },
    #|    tags: { type: list, element: symbol },
    #|  },
    #|}
  let schema = @schema.Schema::load_from_text(definition)
  assert_true(
    schema.is_valid("person", @text.read_ion("{ name: \"Ada\", role: admin }")),
  )
  let violations = schema.validate(
    "person",
    @text.read_ion("{ role: owner, tags: [a, \"b\"] }"),
  )
  let report = violations
    .map(violation => violation.path() + ": " + violation.message())
    .join("\n")
  inspect(
    report,
    content=(
      #|$.name: field occurs 0 time(s)
      #|$.role: value is not one of the allowed values
      #|$.tags[1]: expected one of [symbol] but found string
    ),
  )
}

#Imports

///|
test "import a type from another schema" {
  let schemas : Map[String, String] = {
    "common.isl": "$ion_schema_2_0 type::{ name: positive_int, type: int, valid_values: range::[1, max] }",
  }
  let resolver = (id : String) => {
    match schemas.get(id) {
      Some(text) => @text.read_ion_datagram(text)
      None => raise @ion.IonError::DataModel("no schema named " + id)
    }
  }
  let schema = @schema.Schema::load_from_text(
    (
      #|$ion_schema_2_0
      #|schema_header::{ imports: [{ id: "common.isl", type: positive_int, as: count }] }
      #|type::{ name: tally, fields: { votes: count } }
    ),
    resolver~,
  )
  assert_true(schema.is_valid("tally", @text.read_ion("{ votes: 3 }")))
  assert_true(!schema.is_valid("tally", @text.read_ion("{ votes: 0 }")))
  // Without a resolver, the import cannot load.
  let message = try
    @schema.Schema::load_from_text(
      "$ion_schema_2_0 schema_header::{ imports: [{ id: \"common.isl\" }] }",
    )
  catch {
    error => error.message()
  } noraise {
    _ => "loaded"
  }
  inspect(
    message,
    content="the schema imports 'common.isl', but no resolver was given to load it",
  )
}