#OpenRPC.mbt

#What works today

• Parses OpenRPC 1.x document metadata, including tags, servers, server variables, method summaries, and examples.
• Preserves reusable schemas, examples, pairings, content descriptors, errors, links, and tags under components.
• Resolves local JSON Pointer references in method, parameter, result, tag, and example entries.
• Validates parameter and result schemas that use nested local component references.
• Validates parameter, result, and pairing examples against their declared schemas.
• Expands declared server URL variables using caller overrides or defaults and enforces enum values.
• Compares two parsed documents and classifies method, parameter, result, server, tag, and component changes.
• Parses JSON into the required OpenRPC document, info, and method metadata.
• Preserves ordered parameters (name, required, and raw schema) and optional result descriptors.
• Accepts OpenRPC 1.x documents and rejects other major versions.
• Rejects duplicate method names and reports invalid JSON, missing fields, wrong field types, and non-object methods with JSON-style paths.
• Supports deterministic lookup with Document::find_method.
• Builds a JSON-RPC 2.0 request from a parsed method with the caller's request id and named parameters.
• Builds a positional JSON-RPC 2.0 request from the method's declared parameter order.
• Rejects missing required parameters and names that are not declared by the method before a request is sent.
• Rejects missing required positional parameters and excess positional values while allowing omitted trailing optional parameters.
• Builds named or positional JSON-RPC notifications that omit id and reuse the same contract checks.
• Builds contract-aware JSON-RPC batches from named or positional calls, checking method names and unique request ids.
• Decodes a JSON-RPC 2.0 response for an expected request id into a raw result or structured error.
• Correlates JSON-RPC batch responses with the original calls, reorders them deterministically, and preserves per-method result/error records.
• Rejects malformed response envelopes, mismatched ids, and invalid error objects with JSON-style diagnostics.
• Provides a pure, portable JSON Schema subset validator for boolean schemas, primitive type, enum, const, object properties, arrays, string and numeric bounds, and allOf/anyOf/oneOf/not composition.
• Exposes opt-in Parameter::validate, Method::validate_named_params, Method::validate_positional_params, Method::validate_result, and ResultDescriptor::validate helpers with stable JSON-style paths.
• Lints parsed contracts for empty names, duplicate parameters, ambiguous positional ordering, malformed or contradictory schema boundaries, and invalid nested composition.
• Keeps the result embeddable on MoonBit targets; there is no native-only file or network dependency.

#Small example

import { "zmjknn/openrpc" @openrpc }

let source = #|{
  #|  "openrpc": "1.4.0",
  #|  "info": {"title": "Inventory", "version": "1.0.0"},
  #|  "methods": [{"name": "inventory.list"}]
  #|}

match @openrpc.Document::parse(source) {
  Ok(document) => println(document.methods[0].name)
  Err(diagnostics) => {
    for diagnostic in diagnostics {
      println(diagnostic.path + ": " + diagnostic.message)
    }
  }
}

#Install from Mooncakes

moon add zmjknn/openrpc

#Runnable quickstart

moon run examples/quickstart --target wasm-gc

method=inventory.get, server=https://dev.inventory.example/rpc, request={"jsonrpc":"2.0","id":7,"method":"inventory.get","params":{"id":"abc"}}

let params : Map[String, Json] = {"id": "abc"}
let request = method_value.build_request(7, params)

let values : Array[Json] = ["abc"]
let request = method_value.build_positional_request(7, values)

let params : Map[String, Json] = {"id": "abc"}
match method_value.validate_named_params(params) {
  Ok(_) => println("parameters satisfy the OpenRPC schemas")
  Err(diagnostics) => println(diagnostics[0].path + ": " + diagnostics[0].message)
}

match document.validate_named_params("inventory.get", {"id": "abc"}) {
  Ok(_) => println("parameters satisfy the referenced schemas")
  Err(diagnostics) => println(diagnostics[0].path + ": " + diagnostics[0].message)
}

match document.find_server("primary") {
  Some(server) =>
    match server.render_url({"region": "staging"}) {
      Ok(url) => println(url)
      Err(diagnostics) => println(diagnostics[0].message)
    }
  None => println("server is not declared")
}

let diagnostics = document.lint()
for diagnostic in diagnostics {
  println(diagnostic.path + ": " + diagnostic.message)
}

let notification = method_value.build_notification({"scope": "all"})

let calls : Array[@openrpc.BatchCall] = [
  @openrpc.BatchCall::new(
    1,
    "inventory.get",
    @openrpc.RequestParams::named({"id": "abc"}),
  ),
]
let batch = document.build_batch(calls)

match document.decode_batch_response(response, calls) {
  Ok(values) => {
    for value in values {
      println(value.method_name)
    }
  }
  Err(diagnostics) => println(diagnostics[0].path + ": " + diagnostics[0].message)
}

match method_value.decode_response(response, 7) {
  Ok(@openrpc.RpcResponse::Result(value)) => println(value.stringify())
  Ok(@openrpc.RpcResponse::Error(error_value)) => println(error_value.message)
  Err(diagnostics) => {
    for diagnostic in diagnostics {
      println(diagnostic.path + ": " + diagnostic.message)
    }
  }
}

#Repository structure

#Deliberate boundary

#Development

moon fmt --check
moon check --target wasm-gc
moon build --target wasm-gc
moon test --target wasm-gc
moon run examples/quickstart --target wasm-gc

#Mooncakes publication