#JSON codecs

• The contract package holds the typed identities, the trait definitions and the detached wire contract. A generator or a schema exporter can read the contract without the runtime.
• The morphir package holds the scalar adapters of the Morphir IR. General codecs do not import it.
• Without a selected profile, the base rules apply. moonrockz/smithy-validation, JSON-RPC and the Smithy JSON AST do not change. A profile in a model does not change any protocol that does not select it.

#Prepare once, check, decode and encode

///|
test "one model with two representations" {
  let model = @contract.loader()
  .add_idl(
    "expr.smithy",
    (
      #|$version: "2"
      #|namespace example
      #|use smithy.serialization#jsonProfiles
      #|use smithy.serialization#jsonEncoding
      #|
      #|@jsonProfiles([
      #|  {id: "object"}
      #|  {id: "array", defaults: {union: {style: "tagArray"}}}
      #|])
      #|union Expr {
      #|  Num: Count
      #|  Add: Add
      #|}
      #|
      #|@range(min: 0, max: 100)
      #|integer Count
      #|
      #|@jsonEncoding(profiles: {array: {tuple: {members: ["left", "right"]}}})
      #|structure Add {
      #|  @required
      #|  left: Expr
      #|  @required
      #|  right: Expr
      #|}
    ),
  )
  .assemble().model.unwrap()
  let root = @smithy.ShapeId::parse("example#Expr").unwrap()
  let object = @codec.PreparedCodec::prepare(
    model,
    root,
    profile=Some(@contract.ProfileId::parse("object")),
  )
  let array = @codec.PreparedCodec::prepare(
    model,
    root,
    profile=Some(@contract.ProfileId::parse("array")),
  )
  let value = object.decode(
    "{\"Add\":{\"left\":{\"Num\":1},\"right\":{\"Num\":2}}}",
  )
  inspect(array.encode(value), content="[\"Add\",[\"Num\",1],[\"Num\",2]]")
  // A finding names the semantic shape and the original JSON location.
  let result = array.check("[\"Add\",[\"Num\",1],[\"Num\",101]]")
  inspect(result.findings[0].code, content="Range")
  inspect(result.findings[0].path.pointer(), content="/2/1")
}

#Values

///|
test "build a value and encode it" {
  let model = @contract.loader()
  .add_idl(
    "pair.smithy", "$version: \"2\"\nnamespace example\nstructure Pair { @required left: BigDecimal, right: String }",
  )
  .assemble().model.unwrap()
  let codec = @codec.PreparedCodec::prepare(
    model,
    @smithy.ShapeId::parse("example#Pair").unwrap(),
  )
  let value = codec.value(
    Structure([
      ("left", @codec.LogicalValue::number("12345678901234567890.000000001")),
    ]),
  )
  inspect(
    codec.encode(value),
    content="{\"left\":12345678901234567890.000000001}",
  )
  // An incomplete structure is refused before any output exists.
  try codec.value(Structure([("right", String("r"))])) catch {
    @codec.CodecFailure(result) =>
      inspect(result.findings[0].code, content="RequiredMember")
  } noraise {
    _ => fail("expected a refusal")
  }
}

#Declaring profiles

#Representations

///|
test "positions keep their source paths" {
  let model = @contract.loader()
  .add_idl(
    "entry.smithy",
    (
      #|$version: "2"
      #|namespace example
      #|use smithy.serialization#jsonEncoding
      #|
      #|@jsonEncoding(base: {tuple: {members: ["head"], rest: "tail"}})
      #|structure Call {
      #|  @required
      #|  head: String
      #|  tail: Sizes
      #|}
      #|
      #|list Sizes {
      #|  member: Size
      #|}
      #|
      #|@range(max: 9)
      #|integer Size
    ),
  )
  .assemble().model.unwrap()
  let codec = @codec.PreparedCodec::prepare(
    model,
    @smithy.ShapeId::parse("example#Call").unwrap(),
  )
  inspect(codec.canonicalize("[\"f\",1,2]"), content="[\"f\",1,2]")
  let result = codec.check("[\"f\",1,20]")
  inspect(result.findings[0].path.pointer(), content="/2")
}

#Compact forms and canonical output

• read: {kind, adapter, field, absent} matches by JSON kind, and optionally by an adapter that accepts the value, a field that the object contains, or a field that it does not contain.
• bind: "name" binds the whole value to one member. positions: [...] and rest bind an array. A union form names its member and binds fields of that member's payload; without bind or positions it reads the whole value as the payload.
• write: {empty: [...], present: [...]} selects the form for canonical output when every empty member is absent and every present member is present and not empty. A present empty value counts as absent only for an emptyAsAbsent member, so a compact form never drops a present empty member. Every member that the form does not bind must be in empty, so the form never drops information.

#Scalar adapters

• a failure is a finding at the value's path joined with the adapter's relative path;
• an adapter charges its work through AdapterContext::charge, which shares the request budget;
• the reader checks the output kind, and the writer checks that the adapter writes a kind that it reads.

#Versioned bundles

@jsonBundle(
  id: "doc"
  version: {field: "formatVersion", adapter: "test.version"}
  releases: [
    {since: "1.0.0", until: "2.0.0", root: V1, profiles: ["v1"]}
    {since: "2.0.0", until: "2.1.0", root: V2, profiles: ["v2", "v2-expanded"]}
  ]
)
structure Documents {}

#Limits

#Compatibility