///|
fn read_json(text : String, maximum : Int32) -> Result[Json, MonitorError] {
if text.length() > maximum {
return Err(ResourceLimit("JSON input length"))
}
Ok(@json.parse(text[:], max_nesting_depth=16, reject_duplicate_keys=true)) catch {
_ => Err(InvalidData("invalid JSON, duplicate keys, or excessive nesting"))
}
}
///|
fn decimal_timestamp(text : String) -> Result[Int64, MonitorError] {
if text.length() == 0 || text.length() > 19 {
return Err(
InvalidData("timestamp must be a nonnegative decimal Int64 string"),
)
}
if text.length() > 1 && text.has_prefix("0") {
return Err(InvalidData("timestamp has a leading zero"))
}
for char in text.to_array() {
if char < '0' || char > '9' {
return Err(InvalidData("timestamp contains a nondecimal character"))
}
}
Ok(@string.parse_int64(text[:])) catch {
_ => Err(InvalidData("timestamp exceeds Int64"))
}
}
///|
/// Timestamps are decimal strings, preserving every Int64 bit in JavaScript.
/// Unknown fields and duplicate keys are rejected to prevent silent typos.
pub fn Observation::from_json(
text : String,
) -> Result[Observation, MonitorError] {
let json = match read_json(text, 1048576) {
Err(e) => return Err(e)
Ok(value) => value
}
let object = match json {
Object(fields) if fields.length() == 2 => fields
_ => return Err(InvalidData("observation requires exactly time and values"))
}
let time = match object.get("time") {
Some(String(value)) =>
match decimal_timestamp(value) {
Err(e) => return Err(e)
Ok(value) => value
}
_ => return Err(InvalidData("time must be a decimal string"))
}
let fields = match object.get("values") {
Some(Object(fields)) => fields
_ => return Err(InvalidData("values must be an object"))
}
let values : Map[String, Bool] = Map([])
for key, value in fields {
match value {
True => values.set(key, true)
False => values.set(key, false)
_ => return Err(InvalidData("atom values must be Boolean"))
}
}
Observation::new(time, values)
}
///|
pub fn Observation::to_json(self : Observation) -> String {
let values : Map[String, Json] = Map([])
for key, value in self.values {
values.set(key, Json::boolean(value))
}
Json::object(
Map([
("time", Json::string(self.time.to_string())),
("values", Json::object(values)),
]),
).stringify()
}
///|
/// Portable rule documents carry syntax rather than internal DAG node IDs.
/// Resource limits are supplied by the receiver, never trusted from the wire.
pub fn Plan::from_json(
text : String,
limits~ : Limits = Limits::defaults(),
) -> Result[Plan, MonitorError] {
let json = match read_json(text, 1048576) {
Err(e) => return Err(e)
Ok(value) => value
}
let object = match json {
Object(fields) if fields.length() == 2 => fields
_ => return Err(InvalidData("rule document requires version and rules"))
}
if object.get("version") != Some(Json::string("1")) {
return Err(InvalidData("unsupported rule document version"))
}
let rules = match object.get("rules") {
Some(Array(rules)) => rules
_ => return Err(InvalidData("rules must be an array"))
}
if rules.length() > limits.nodes {
return Err(ResourceLimit("rule count"))
}
let parsed : Array[(String, String)] = []
for rule in rules {
let fields = match rule {
Object(fields) if fields.length() == 2 => fields
_ => return Err(InvalidData("rule requires exactly name and formula"))
}
match (fields.get("name"), fields.get("formula")) {
(Some(String(name)), Some(String(formula))) =>
parsed.push((name, formula))
_ => return Err(InvalidData("rule name and formula must be strings"))
}
}
Plan::from_strings(parsed, limits~)
}
///|
pub fn Plan::to_json(self : Plan) -> String {
let rules : Array[Json] = []
for i in 0.. String {
let verdicts : Map[String, Json] = Map([])
for i in 0.. Result[Array[Decision], MonitorError] {
if text.length() > 16777216 {
return Err(ResourceLimit("JSONL batch length"))
}
let lines = text.split("\n").to_array()
let decisions : Array[Decision] = []
for i in 0.. value
Err(e) =>
return Err(
InvalidData("line " + (i + 1).to_string() + ": " + e.message()),
)
}
match self.push(event) {
Ok(value) => decisions.push(value)
Err(e) =>
return Err(
InvalidData("line " + (i + 1).to_string() + ": " + e.message()),
)
}
}
Ok(decisions)
}