@kaiko.io/rescript-deser 7.0.0 → 8.0.0-alpha.1

package/lib/js/tests/index.js

@@ -35,6 +35,59 @@ let Appointment = {
   Deserializer: Deserializer
 };
 
+let fields$1 = {
+  TAG: "Object",
+  _0: [
+    [
+      "head",
+      "String"
+    ],
+    [
+      "tail",
+      {
+        TAG: "Optional",
+        _0: "Self"
+      }
+    ]
+  ]
+};
+
+let Deserializer$1 = Deser.MakeDeserializer({
+  fields: fields$1
+});
+
+let List = {
+  Deserializer: Deserializer$1
+};
+
+let fields$2 = {
+  TAG: "Object",
+  _0: [
+    [
+      "records",
+      {
+        TAG: "Deserializer",
+        _0: Deserializer$1
+      }
+    ],
+    [
+      "next",
+      {
+        TAG: "Optional",
+        _0: "Self"
+      }
+    ]
+  ]
+};
+
+let Deserializer$2 = Deser.MakeDeserializer({
+  fields: fields$2
+});
+
+let Ledger = {
+  Deserializer: Deserializer$2
+};
+
 Qunit.module("Basic deserializer", param => {
   let valid = [
     [
@@ -165,27 +218,8 @@ Qunit.module("Recursive deserializer", param => {
     qunit.deepEqual(Stdlib_Result.isError(InfiniteList.checkFieldsSanity()), true, "Ok");
   });
   Qunit.test("Finite list", qunit => {
-    let fields = {
-      TAG: "Object",
-      _0: [
-        [
-          "head",
-          "String"
-        ],
-        [
-          "tail",
-          {
-            TAG: "Optional",
-            _0: "Self"
-          }
-        ]
-      ]
-    };
-    let List = Deser.MakeDeserializer({
-      fields: fields
-    });
     qunit.expect(1);
-    qunit.deepEqual(List.checkFieldsSanity(), {
+    qunit.deepEqual(Deserializer$1.checkFieldsSanity(), {
       TAG: "Ok",
       _0: undefined
     }, "Ok");
@@ -204,47 +238,6 @@ Qunit.module("Recursive deserializer", param => {
     });
   });
   Qunit.test("Recursion in sub-deserializer", qunit => {
-    let fields = {
-      TAG: "Object",
-      _0: [
-        [
-          "head",
-          "String"
-        ],
-        [
-          "tail",
-          {
-            TAG: "Optional",
-            _0: "Self"
-          }
-        ]
-      ]
-    };
-    let List = Deser.MakeDeserializer({
-      fields: fields
-    });
-    let fields$1 = {
-      TAG: "Object",
-      _0: [
-        [
-          "records",
-          {
-            TAG: "Deserializer",
-            _0: List
-          }
-        ],
-        [
-          "next",
-          {
-            TAG: "Optional",
-            _0: "Self"
-          }
-        ]
-      ]
-    };
-    let Ledger = Deser.MakeDeserializer({
-      fields: fields$1
-    });
     let data = {"records": {"head": "A", "tail": {"head": "B"}},
         "next": {"records": {"head": "A", "tail": {"head": "B"}}}};
     let expected = {
@@ -267,7 +260,7 @@ Qunit.module("Recursive deserializer", param => {
       }
     };
     qunit.expect(1);
-    qunit.deepEqual(Ledger.fromJSON(data), {
+    qunit.deepEqual(Deserializer$2.fromJSON(data), {
       TAG: "Ok",
       _0: expected
     }, "nice ledger");
@@ -297,5 +290,171 @@ Qunit.module("Type safety limits", param => {
   });
 });
 
+Qunit.module("isSafeCast and toJSON", param => {
+  let fields = {
+    TAG: "Object",
+    _0: [
+      [
+        "name",
+        "String"
+      ],
+      [
+        "count",
+        "Int"
+      ],
+      [
+        "ratio",
+        "Float"
+      ],
+      [
+        "active",
+        "Boolean"
+      ]
+    ]
+  };
+  let Deserializer$3 = Deser.MakeDeserializer({
+    fields: fields
+  });
+  let fields$1 = {
+    TAG: "Object",
+    _0: [
+      [
+        "items",
+        {
+          TAG: "Array",
+          _0: "String"
+        }
+      ],
+      [
+        "tags",
+        {
+          TAG: "Mapping",
+          _0: "Int"
+        }
+      ],
+      [
+        "label",
+        {
+          TAG: "Optional",
+          _0: "String"
+        }
+      ]
+    ]
+  };
+  let Deserializer$4 = Deser.MakeDeserializer({
+    fields: fields$1
+  });
+  let fields$2 = {
+    TAG: "Object",
+    _0: [
+      [
+        "name",
+        "String"
+      ],
+      [
+        "created",
+        "Date"
+      ]
+    ]
+  };
+  let Deserializer$5 = Deser.MakeDeserializer({
+    fields: fields$2
+  });
+  let fields$3 = {
+    TAG: "Object",
+    _0: [[
+        "event",
+        {
+          TAG: "Deserializer",
+          _0: Deserializer$5
+        }
+      ]]
+  };
+  let Deserializer$6 = Deser.MakeDeserializer({
+    fields: fields$3
+  });
+  Qunit.test("Safe types: primitives return true for isSafeCast", qunit => {
+    qunit.expect(1);
+    qunit.true(Deserializer$3.isSafeCast(), "primitives are safe");
+  });
+  Qunit.test("Safe types: nested arrays/mappings/optionals return true for isSafeCast", qunit => {
+    qunit.expect(1);
+    qunit.true(Deserializer$4.isSafeCast(), "nested safe types are safe");
+  });
+  Qunit.test("Unsafe types: Date returns false for isSafeCast", qunit => {
+    qunit.expect(1);
+    qunit.false(Deserializer$5.isSafeCast(), "Date is unsafe");
+  });
+  Qunit.test("Unsafe types: nested deserializer with Date returns false", qunit => {
+    qunit.expect(1);
+    qunit.false(Deserializer$6.isSafeCast(), "nested unsafe is unsafe");
+  });
+  Qunit.test("Round-trip for safe types", qunit => {
+    let json = {"name": "test", "count": 42, "ratio": 3.14, "active": true};
+    let value = Deserializer$3.fromJSON(json);
+    if (value.TAG === "Ok") {
+      let serialized = Deserializer$3.toJSON(value._0);
+      qunit.deepEqual(serialized, json, "round-trip preserves data");
+      return;
+    }
+    qunit.false(true, value._0);
+  });
+  Qunit.test("Round-trip for unsafe types with Date", qunit => {
+    let json = {"name": "event", "created": "2024-01-15T10:30:00.000Z"};
+    let value = Deserializer$5.fromJSON(json);
+    if (value.TAG === "Ok") {
+      let serialized = Deserializer$5.toJSON(value._0);
+      qunit.deepEqual(serialized, json, "round-trip preserves data with Date");
+      return;
+    }
+    qunit.false(true, value._0);
+  });
+  Qunit.test("Nested deserializer safety propagation", qunit => {
+    let json = {"event": {"name": "meeting", "created": "2024-06-01T09:00:00.000Z"}};
+    let value = Deserializer$6.fromJSON(json);
+    if (value.TAG === "Ok") {
+      let serialized = Deserializer$6.toJSON(value._0);
+      qunit.deepEqual(serialized, json, "nested unsafe round-trip works");
+      return;
+    }
+    qunit.false(true, value._0);
+  });
+  Qunit.test("Morphism of safe type is safe", qunit => {
+    let fields_1 = v => v;
+    let fields = {
+      TAG: "Morphism",
+      _0: "Int",
+      _1: fields_1
+    };
+    let WithMorphism = Deser.MakeDeserializer({
+      fields: fields
+    });
+    qunit.expect(1);
+    qunit.true(WithMorphism.isSafeCast(), "morphism of Int is safe");
+  });
+  Qunit.test("List deserializer is safe (recursive with Self)", qunit => {
+    qunit.expect(1);
+    qunit.true(Deserializer$1.isSafeCast(), "recursive list with strings is safe");
+  });
+  Qunit.test("Appointment deserializer is unsafe (has Date)", qunit => {
+    qunit.expect(1);
+    qunit.false(Deserializer.isSafeCast(), "Appointment with Date is unsafe");
+  });
+  Qunit.test("toJSON serializes Date to ISO string", qunit => {
+    let appointment_date = new Date("2024-03-15T14:30:00.000Z");
+    let appointment_extra = "extra info";
+    let appointment = {
+      note: "Test",
+      date: appointment_date,
+      extra: appointment_extra
+    };
+    let json = Deserializer.toJSON(appointment);
+    let expected = {"note": "Test", "date": "2024-03-15T14:30:00.000Z", "extra": "extra info"};
+    qunit.deepEqual(json, expected, "Date serialized to ISO string");
+  });
+});
+
 exports.Appointment = Appointment;
+exports.List = List;
+exports.Ledger = Ledger;
 /* Deserializer Not a pure module */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1766181917581)
-#Done(1766181917581)
+#Start(1769849605835)
+#Done(1769849605836)

package/lib/ocaml/Deser.res

@@ -25,7 +25,9 @@ module type Deserializer = {
   type t
   let name: string
   let fromJSON: JSON.t => result<t, string>
+  let toJSON: t => JSON.t
   let checkFieldsSanity: unit => result<unit, string>
+  let isSafeCast: unit => bool
 }
 
 module Field = {
@@ -305,6 +307,66 @@ module Field = {
       )
       ->Result.map(_ => ())
     }
+
+  let rec isSafeCast = (field: t): bool =>
+    switch field {
+    // Any is considered *safe* because it SHOULD only be used if the type you're getting from
+    // JSON.t is compatible with the internal representation anyways.
+    | Any => true
+    | String | Literal(_) | Int | Float | Boolean | Self => true
+    | Date | Datetime => false
+    | Morphism(inner, _) => isSafeCast(inner)
+    | Array(inner)
+    | Optional(inner)
+    | OptionalWithDefault(inner, _)
+    | Mapping(inner)
+    | DefaultWhenInvalid(inner, _) =>
+      isSafeCast(inner)
+    | Tuple(fields) => fields->Array.every(isSafeCast)
+    | Object(fields) => fields->Array.every(((_, f)) => isSafeCast(f))
+    | Deserializer(mod) | Collection(mod) => {
+        module M = unpack(mod: Deserializer)
+        M.isSafeCast()
+      }
+    }
+
+  let rec serialize: ('a, t, t) => JSON.t = (value, shape, self) =>
+    switch shape {
+    | Any | String | Int | Float | Boolean => value->Obj.magic
+    | Literal(v) => JSON.String(v)
+    | Self => serialize(value, self, self)
+    | Date | Datetime => JSON.String(value->Obj.magic->Date.toISOString)
+
+    | Morphism(inner, _) => serialize(value, inner, self)
+    | Array(inner) => JSON.Array(value->Obj.magic->Array.map(v => serialize(v, inner, self)))
+
+    | Tuple(fields) =>
+      JSON.Array(Belt.Array.zipBy(value->Obj.magic, fields, (v, f) => serialize(v, f, self)))
+
+    | Object(fields) =>
+      JSON.Object(
+        fields
+        ->Array.filterMap(((key, fieldType)) =>
+          value
+          ->Obj.magic
+          ->Dict.get(key)
+          ->Option.map(fieldValue => (key, serialize(fieldValue, fieldType, self)))
+        )
+        ->Dict.fromArray,
+      )
+    | Optional(inner) =>
+      switch value->Obj.magic {
+      | Some(v) => serialize(v, inner, self)
+      | None => JSON.Null
+      }
+    | OptionalWithDefault(inner, _) | DefaultWhenInvalid(inner, _) => serialize(value, inner, self)
+    | Mapping(inner) =>
+      JSON.Object(value->Obj.magic->Dict.mapValues(v => serialize(v, inner, self)))
+    | Deserializer(mod) | Collection(mod) => {
+        module M = unpack(mod: Deserializer)
+        M.toJSON(value->Obj.magic)
+      }
+    }
 }
 
 module type Serializable = {
@@ -315,10 +377,24 @@ module type Serializable = {
 module MakeDeserializer = (S: Serializable): (Deserializer with type t = S.t) => {
   type t = S.t
   let fields = S.fields
-  %%private(let (loc, _f) = __LOC_OF__(module(S: Serializable)))
+  let (loc, _f) = __LOC_OF__(module(S: Serializable))
   let name = `Deserializer ${__MODULE__}, ${loc}`
 
-  %%private(external _toNativeType: FieldValue.t => t = "%identity")
+  external _toNativeType: FieldValue.t => t = "%identity"
+  external _fromNativeType: t => FieldValue.t = "%identity"
+
+  let safeCastCache: ref<option<bool>> = ref(None)
+
+  let isSafeCast = () => {
+    switch safeCastCache.contents {
+    | Some(cached) => cached
+    | None => {
+        let result = Field.isSafeCast(fields)
+        safeCastCache := Some(result)
+        result
+      }
+    }
+  }
 
   @doc("Checks for trivial infinite-recursion in the fields of the module.
 
@@ -331,11 +407,20 @@ module MakeDeserializer = (S: Serializable): (Deserializer with type t = S.t) =>
   ")
   let checkFieldsSanity = () => Field.checkFieldsSanity(name, fields, false)
 
-  @doc("Parse a `'a` into `result<t, string>`")
+  @doc("Parse a `JSON.t` into `result<t, string>`")
   let fromJSON: JSON.t => result<t, _> = json => {
     switch json->Field.fromUntagged(fields, fields) {
     | res => Ok(res->_toNativeType)
     | exception TypeError(e) => Error(e)
     }
   }
+
+  @doc("Serialize a `t` into `JSON.t`")
+  let toJSON: t => JSON.t = value => {
+    if isSafeCast() {
+      value->Obj.magic
+    } else {
+      Field.serialize(value, fields, fields)
+    }
+  }
 }