#MoonCheck

#Features

• Small schema language with the kinds you actually use: string, number, int, bool, object, array
• Constraints: required, enum, numeric min/max, minLength/maxLength for strings, minItems/maxItems for arrays, items for array element types, and arbitrarily nested objects
• Structured errors: every error carries a JSON-pointer-like path ($.user.age, $.tags[0]), a machine-readable kind, and a human message such as expected Int, got String
• Collects all errors instead of stopping at the first
• Built for CI: validate many documents in one run, with a machine-readable JSON report (--report json) and stable exit codes
• Schema linting: mooncheck check-schema schema.json checks the schema document itself, so a broken contract fails before any data is checked
• Shell globs work as-is (mooncheck validate s.json configs/*.json); the CLI needs no glob support and no extra dependency
• Schemas are described as plain JSON documents, so they work across languages and are easy to read; they can also be built directly in MoonBit
• No runtime dependencies beyond the MoonBit standard library

#Installation / Build

moon check            # type-check the library and all packages
moon test             # run the test suite
moon run examples/demo   # run the demo (works on any backend)

moon update

# Windows (MSVC) or Linux/macOS
moon build cmd/main --target native

#Quick Start

match @MoonCheck.validate_strings(schema_text, data_text) {
  Ok(errors) if errors.is_empty() => println("valid")
  Ok(errors) =>
    for error in errors {
      println(@MoonCheck.to_string(error))
    }
  Err(reason) => println("could not validate: \{reason}")
}

let schema = try { @MoonCheck.parse_schema_string(schema_text) } catch {
  _ => panic("bad schema")
}
let data = try { @json.parse(data_text) } catch { _ => panic("bad json") }
if @MoonCheck.is_valid(schema, data) { ... }

let results = [
  @MoonCheck.FileResult::new("a.json", @MoonCheck.validate_text(schema, text_a)),
  @MoonCheck.FileResult::new("b.json", @MoonCheck.validate_text(schema, text_b)),
]
let report = @MoonCheck.RunReport::new("schema.json", results)
println(@MoonCheck.render(report, @MoonCheck.ReportFormat::text(), false))
println(@MoonCheck.render(report, @MoonCheck.ReportFormat::json(), false))

#Schema Example

{
  "type": "object",
  "properties": {
    "name": { "type": "string", "required": true, "minLength": 1, "maxLength": 30 },
    "age":  { "type": "int", "required": true, "min": 0, "max": 150 },
    "role": { "type": "string", "required": false, "enum": ["admin", "user"] },
    "tags": { "type": "array", "required": false, "maxItems": 5, "items": { "type": "string" } }
  }
}

#Validation Example

{ "name": "", "age": 200, "role": "owner", "tags": ["a", "b"] }

$.name: length must be at least 1, got 0
$.age: value must be at most 150, got 200
$.role: value must be one of ["admin","user"]
$.tags: length must be at most 5, got 4

#CLI Usage

# one schema, one data file — valid: prints nothing, exits 0
mooncheck validate examples/cli/schema.json examples/cli/data_valid.json

# one schema, one data file — invalid: prints the errors, exits 1
mooncheck validate examples/cli/schema.json examples/cli/data_invalid.json
# -> $.action: value must be one of ["click","type","scroll"]
#    $.x: value must be at least 0, got -5
#    $.y: value must be at most 1080, got 5000

mooncheck validate examples/cli/config.schema.json examples/cli/configs/*.json

ok: service_a.json
ok: service_b.json
service_c_broken.json: $.host: length must be at least 1, got 0
service_c_broken.json: $.port: value must be at most 65535, got 70000
service_c_broken.json: $.timeout: expected Int, got String
checked 3 document(s): 2 ok, 1 failed, 3 error(s)

{
  "schema": "examples/cli/config.schema.json",
  "ok": false,
  "summary": { "checked": 3, "failed": 1, "errors": 3 },
  "documents": [
    { "path": "service_a.json", "ok": true, "errors": [] },
    { "path": "service_b.json", "ok": true, "errors": [] },
    {
      "path": "service_c_broken.json",
      "ok": false,
      "errors": [
        { "path": "$.host", "kind": "too_short", "message": "length must be at least 1, got 0" },
        { "path": "$.port", "kind": "above_max", "message": "value must be at most 65535, got 70000" },
        { "path": "$.timeout", "kind": "type_mismatch", "message": "expected Int, got String" }
      ]
    }
  ]
}

mooncheck check-schema schema.json   # lint a schema document on its own
mooncheck --help                     # usage
mooncheck --version                  # version
mooncheck validate s.json d.json -q  # only report failures

#Use Cases

• REST API request validation — check username, age, email and friends on an incoming request before handing the payload to handlers.
• Configuration file validation — a tool reads a JSON config; MoonCheck verifies required keys, types, and ranges before the tool trusts it.
• AI Agent / LLM tool-call validation — a model emits a tool call such as { "action": "click", "x": 123, "y": 456 }; validate fields, types, and ranges before dispatching to the executor.

#Ecosystem and Scope

#Testing

moon test

#Project Structure

MoonCheck/
├── moon.mod                 # module metadata
├── moon.pkg                 # root library package (no dependencies)
├── schema.mbt               # schema type model (Type, specs, props)
├── schema_json.mbt          # parse schema documents from JSON
├── validate.mbt             # validation engine, validate_strings/validate_text
├── error.mbt                # structured ValidationError / ErrorKind
├── report.mbt               # text and JSON reports
├── cli.mbt                  # command line parsing + usage text
├── MoonCheck_test.mbt       # black-box tests (public API)
├── MoonCheck_wbtest.mbt     # white-box tests (engine internals)
├── cli_wbtest.mbt           # white-box tests (CLI parsing + end-to-end flow)
├── report_wbtest.mbt        # white-box tests (report rendering)
├── cmd/
│   └── main/                # CLI shell: reads files, prints, sets exit status
└── examples/
    ├── demo/                # runnable demo (moon run examples/demo)
    └── cli/                 # sample schemas + data (configs/ for batch runs)

#License