#typify.mbt

• Rust output is identical to upstream typify's for the same schema and settings. It emits the same token stream as typify-impl, with the same type names, derives, serde attributes, builders and TryFrom validation.
• MoonBit output mirrors the Rust types and adds JSON codecs that behave like the serde-derived Rust code:
  • the same inputs are accepted and rejected, with the same error messages;
  • accepted inputs decode to the same values;
  • values encode to byte-identical JSON.
  So a Rust service and a MoonBit program can share one schema and exchange JSON without surprises.

#Command line

moonx bobzhang/typify/cmd/typify schema.json                  # writes schema.rs
moonx bobzhang/typify/cmd/typify schema.json --lang moonbit   # writes schema.mbt
moonx bobzhang/typify/cmd/typify schema.json -o -             # to stdout

moonx bobzhang/typify/cmd/typify schema.json -o - | rustfmt --edition 2021 > schema.rs

#Generated MoonBit

// moon.pkg of the package holding the generated file
import {
  "bobzhang/typify/runtime" @typify_rt,
}

• T::from_json_str(text): decode JSON text, like serde_json::from_str.
• value.to_json_string(): encode as compact JSON, like serde_json::to_string.
• T::from_json(json) and value.to_json(): conversions to and from the builtin Json. These are lossy: duplicate keys and number spellings are not representable in Json.
• T::deserialize(de) and value.serialize(): the underlying @typify_rt.Serde trait.
• T::default() when the schema gives a default.
• For string enums: to_string, parse and variant_index.

{
  "title": "Veggies",
  "type": "object",
  "properties": {
    "fruits": { "type": "array", "items": { "type": "string" } },
    "vegetables": { "type": "array", "items": { "$ref": "#/definitions/veggie" } }
  },
  "definitions": {
    "veggie": {
      "type": "object",
      "required": ["veggieName", "veggieLike"],
      "properties": {
        "veggieName": { "type": "string" },
        "veggieLike": { "type": "boolean" }
      }
    }
  }
}

let veggies = Veggies::from_json_str(
  "{\"fruits\":[\"apple\"],\"vegetables\":[{\"veggieName\":\"leek\",\"veggieLike\":true}]}",
)
println(veggies.vegetables[0].veggie_name) // leek
println(veggies.to_json_string()) // same JSON as serde_json::to_string

#Type mapping

#Library

let root = @schema.RootSchema::from_json_str(schema_text)
let space = @typify.TypeSpace::new(@typify.TypeSpaceSettings::default())
space.add_root_schema(root)
let rust : String = @rust.to_stream(space).to_string()
let moonbit : String = @moonbit.generate(space)

#How it is verified

• typify IR and Rust tokens:
  • upstream typify's type descriptions and token streams, compared token for token, for every upstream fixture (including the github and vega schemas);
  • thousands of random schemas covering tagged unions, merges, defaults, references and formats;
  • upstream's errors and panics.
• serde behaviour of the generated MoonBit:
  • upstream's generated Rust is compiled with serde and fed the same instances, including duplicate keys, reordered keys, escapes, edge-case numbers, positional arrays and deep nesting;
  • output text and error messages must match exactly, across all upstream fixtures and hundreds of random schemas.
• Building blocks:
  • serde_json parsing, errors and number formatting (including zmij's f32/f64 output);
  • regress regular expressions;
  • schemars schema decoding;
  • heck case conversion;
  • Unicode identifier tables;
  • semver;
  • the uuid, chrono and std::net parsers and printers.

#License