Serialization of optional record fields when value is of non-primitive type and is None

[alex35mil]

module Inner = {
  @schema
  type t = {k: int}
}

module OuterInt = {
  @schema
  type t = {int?: @s.null option<int>}
}

module OuterRecord = {
  @schema
  type t = {record?: @s.null option<Inner.t>}
}

let int = {OuterInt.int: None}
let record = {OuterRecord.record: None}

let intJson = int->S.reverseConvertToJsonOrThrow(OuterInt.schema)->Js.Json.stringify
let recordJson = record->S.reverseConvertToJsonOrThrow(OuterRecord.schema)->Js.Json.stringify

intJson->Js.log2("Int JSON:", _)
recordJson->Js.log2("Record JSON:", _)

Expected output:

Int JSON: {"int":null}
Record JSON: {"record":null}

Actual output:

Int JSON: {"int":null}
Record JSON: {"record":{"BS_PRIVATE_NESTED_SOME_NONE":0}}

[alex35mil]

There's something sketchy going on with optional fields.

In my real app, where the structure is much more nested, I even get this somehow:

let x = {OuterRecord.record: None} // -> {record: {BS_PRIVATE_NESTED_SOME_NONE: 0}}
x->S.reverseConvertToJsonOrThrow(OuterRecord.schema) // -> {record: {k: undefined}}
x->S.reverseConvertToJsonStringOrThrow(OuterRecord.schema) // -> {"record":{}}

I can't reproduce it on this simple example, but it behaves this way on my nested structure.

sury@10.0.4
sury-ppx@10.0.0

[alex35mil]

Reproduced:

module Inner = {
  @schema
  type t = {k?: @s.null option<int>}
}

@schema
type t = {record?: @s.null option<Inner.t>}

let record = {record: None}

record->Js.log
record->S.reverseConvertToJsonOrThrow(schema)->Js.log
record->S.reverseConvertToJsonStringOrThrow(schema)->Js.log

{ record: { BS_PRIVATE_NESTED_SOME_NONE: 0 } }
{ record: { k: undefined } }
{"record":{}}

[DZakh]

Could you try the 11th version?

[alex35mil]

@DZakh does it work with ReScript v11?

[DZakh]

Only up until v11.0.0-alpha.2

[alex35mil]

@DZakh Tried this version on Replit. Seems to be the same outcome.

[DZakh]

Ok, I'll investigate 🫡

[DZakh]

You can use runtime API as a workaround:

module OuterRecord = {
  type t = {record?: option<Inner.t>}
  let schema = S.schema(s => {
    record: ?s.matches(S.null(Inner.schema))
  })
}

[DZakh]

I think this should work

[alex35mil]

Same thing, unfortunately:

link to replit

[DZakh]

Reproduced:

module Inner = {
@Schema
type t = {k?: @s.null option}
}

@Schema
type t = {record?: @s.null option<Inner.t>}

let record = {record: None}

record->Js.log
record->S.reverseConvertToJsonOrThrow(schema)->Js.log
record->S.reverseConvertToJsonStringOrThrow(schema)->Js.log

{ record: { BS_PRIVATE_NESTED_SOME_NONE: 0 } }
{ record: { k: undefined } }
{"record":{}}

Am I right that you expect this?

{ record: { BS_PRIVATE_NESTED_SOME_NONE: 0 } }
{ record: { k: null } }
{"record": { k: null } }

[DZakh]

Ok, fixed the issue. Is there a way for you to use ReScript v12, or should I backport it for v11?

[alex35mil]

@DZakh Thanks! I worked around it by moving deletions to a dedicated endpoint, so not a blocker for me.