#MoonbitBSON

#Install

moon add moonbit-community/bson

import {
  "moonbit-community/bson",
}

#Usage

let user = @bson.Document::new()
  .set("name", @bson.Bson::String("Ada"))
  .set("age", @bson.Bson::Int32(37))
  .set("active", @bson.Bson::Boolean(true))
  .set(
    "scores",
    @bson.Bson::Array([
      @bson.Bson::Double(9.5),
      @bson.Bson::Double(10.0),
    ]),
  )

let bytes = user.to_bytes()
let decoded = @bson.Document::from_bytes(bytes)

assert_eq(decoded.require_string("name"), "Ada")
assert_eq(decoded.require_int32("age"), 37)

#Supported BSON types

#Safety and errors

• Declared document and array lengths are hard boundaries.
• Exact decoding rejects trailing bytes and invalid terminators.
• UTF-8, Boolean bytes, old binary lengths, ObjectId/Decimal128 sizes, Regex options, depth, and total size are validated.
• Every BsonError carries a category, byte offset, document path, and message.
• Degenerate BSON array keys are accepted and normalized as required by the MongoDB BSON Corpus. Strict applications can enable DecodeOptions::new(require_canonical_array_keys=true).

#Extended JSON

node tools/bson-codegen.mjs codegen/example.schema.json src/codegen_generated_test.mbt

node tools/bson-derive.mjs src/derive_types_test.mbt src/derive_generated_test.mbt

#Development

moon fmt --check src
moon check --target all --deny-warn --warn-list +73
moon test --target all --deny-warn --warn-list +73
moon test --release --target all --deny-warn --warn-list +73
moon bench --target native --release
moon coverage analyze -- -f summary
node tools/bson-codegen.mjs --check codegen/example.schema.json src/codegen_generated_test.mbt
node tools/bson-derive.mjs --check src/derive_types_test.mbt src/derive_generated_test.mbt
node tools/decimal128-differential.mjs
moon info --target all
moon package --list

#License

#MoonbitBSON

///|
test "build and roundtrip a document" {
  let user = @bson.Document::new()
    .set("name", String("Ada"))
    .set("age", Int32(37))
    .set("active", Boolean(true))
    .set("scores", Array([Double(9.5), Double(10.0)]))
  let encoded = user.to_bytes()
  let decoded = @bson.Document::from_bytes(encoded)
  assert_eq(decoded.require_string("name"), "Ada")
  assert_eq(decoded.require_int32("age"), 37)
}

///|
test "decode a framed document" {
  let encoded = @bson.Document::new().set("x", Int64(42L)).to_bytes()
  let framed = encoded + b"remaining"
  let (document, consumed) = @bson.decode_prefix(framed[:])
  assert_eq(document.require_int64("x"), 42L)
  assert_eq(consumed, encoded.length())
}

///|
test "canonical Extended JSON" {
  let document = @bson.Document::new()
    .set("count", Int64(9007199254740993L))
    .set("decimal", Decimal128(@bson.Decimal128::from_string("1.2500")))
  let text = document.to_extended_json_string()
  let decoded = @bson.Document::from_extended_json_string(text)
  assert_eq(decoded, document)
}

///|
test "typed and raw APIs" {
  let uuid = @bson.Uuid::from_string("00112233-4455-6677-8899-aabbccddeeff")
  let document = @bson.Document::new()
    .set("created", DateTime(@bson.DateTime::from_millis(0L)))
    .set("request_id", Binary(uuid.to_binary()))
  let raw = @bson.RawDocument::from_bytes(@bson.serialize_to_bytes(document))
  assert_eq(raw.get_element("created").unwrap().type_code(), 0x09)
  let decoded : @bson.Document = @bson.deserialize_from_bytes(raw.bytes())
  assert_eq(decoded.require_datetime("created").to_millis(), 0L)
  assert_eq(decoded.require_uuid("request_id"), uuid)
}

///|
test "borrowed view and split stream" {
  let bytes = @bson.Document::new().set("ok", Boolean(true)).to_bytes()
  let view = @bson.RawDocumentView::from_bytes(bytes[:])
  assert_eq(view.iter().next().unwrap().key(), "ok")
  let stream = @bson.BsonStreamDecoder::new()
  assert_eq(stream.push(bytes[:2]).length(), 0)
  assert_eq(stream.push(bytes[2:])[0].require_bool("ok"), true)
  stream.finish()
}

///|
test "raw stream view" {
  let first = @bson.Document::new().set("ok", Boolean(true)).to_bytes()
  let second = @bson.Document::new().set("count", Int32(2)).to_bytes()
  let stream = @bson.BsonStreamRawDecoder::new()
  let views = stream.push(first + second)
  assert_eq(views.length(), 2)
  assert_eq(views[0].get("ok").unwrap().to_bson(), Boolean(true))
  assert_eq(views[1].get("count").unwrap().to_bson(), Int32(2))
  stream.finish()
}