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

package/lib/es6/src/Deser.js

@@ -429,6 +429,97 @@ function checkFieldsSanity(name, _fields, _optional) {
   };
 }
 
+function isSafeCast(_field) {
+  while (true) {
+    let field = _field;
+    if (typeof field !== "object") {
+      switch (field) {
+        case "Date" :
+        case "Datetime" :
+          return false;
+        default:
+          return true;
+      }
+    } else {
+      switch (field.TAG) {
+        case "Tuple" :
+          return field._0.every(isSafeCast);
+        case "Object" :
+          return field._0.every(param => isSafeCast(param[1]));
+        case "Deserializer" :
+        case "Collection" :
+          return field._0.isSafeCast();
+        case "Array" :
+        case "Optional" :
+        case "OptionalWithDefault" :
+        case "Mapping" :
+        case "DefaultWhenInvalid" :
+        case "Morphism" :
+          _field = field._0;
+          continue;
+        default:
+          return true;
+      }
+    }
+  };
+}
+
+function serialize(_value, _shape, self) {
+  while (true) {
+    let shape = _shape;
+    let value = _value;
+    if (typeof shape !== "object") {
+      switch (shape) {
+        case "Date" :
+        case "Datetime" :
+          return value.toISOString();
+        case "Self" :
+          _shape = self;
+          continue;
+        default:
+          return value;
+      }
+    } else {
+      switch (shape.TAG) {
+        case "Literal" :
+          return shape._0;
+        case "Array" :
+          let inner = shape._0;
+          return value.map(v => serialize(v, inner, self));
+        case "Tuple" :
+          return Belt_Array.zipBy(value, shape._0, (v, f) => serialize(v, f, self));
+        case "Object" :
+          return Object.fromEntries(Stdlib_Array.filterMap(shape._0, param => {
+            let fieldType = param[1];
+            let key = param[0];
+            return Stdlib_Option.map(value[key], fieldValue => [
+              key,
+              serialize(fieldValue, fieldType, self)
+            ]);
+          }));
+        case "Optional" :
+          if (value === undefined) {
+            return null;
+          }
+          _shape = shape._0;
+          _value = Primitive_option.valFromOption(value);
+          continue;
+        case "Mapping" :
+          let inner$1 = shape._0;
+          return Stdlib_Dict.mapValues(value, v => serialize(v, inner$1, self));
+        case "Deserializer" :
+        case "Collection" :
+          return shape._0.toJSON(value);
+        case "OptionalWithDefault" :
+        case "DefaultWhenInvalid" :
+        case "Morphism" :
+          _shape = shape._0;
+          continue;
+      }
+    }
+  };
+}
+
 let Field = {
   usingString: usingString,
   usingInt: usingInt,
@@ -442,12 +533,26 @@ let Field = {
   _taggedToString: _taggedToString,
   extractValue: extractValue,
   fromUntagged: fromUntagged,
-  checkFieldsSanity: checkFieldsSanity
+  checkFieldsSanity: checkFieldsSanity,
+  isSafeCast: isSafeCast,
+  serialize: serialize
 };
 
 function MakeDeserializer(S) {
   let fields = S.fields;
-  let name = `Deserializer ` + "Deser" + `, ` + "File \"Deser.res\", line 318, characters 39-47";
+  let name = `Deserializer ` + "Deser" + `, ` + "File \"Deser.res\", line 380, characters 29-37";
+  let safeCastCache = {
+    contents: undefined
+  };
+  let isSafeCast$1 = () => {
+    let cached = safeCastCache.contents;
+    if (cached !== undefined) {
+      return cached;
+    }
+    let result = isSafeCast(fields);
+    safeCastCache.contents = result;
+    return result;
+  };
   let checkFieldsSanity$1 = () => checkFieldsSanity(name, fields, false);
   let fromJSON = json => {
     let res;
@@ -468,10 +573,19 @@ function MakeDeserializer(S) {
       _0: res
     };
   };
+  let toJSON = value => {
+    if (isSafeCast$1()) {
+      return value;
+    } else {
+      return serialize(value, fields, fields);
+    }
+  };
   return {
     name: name,
     fromJSON: fromJSON,
-    checkFieldsSanity: checkFieldsSanity$1
+    toJSON: toJSON,
+    checkFieldsSanity: checkFieldsSanity$1,
+    isSafeCast: isSafeCast$1
   };
 }
 

package/lib/es6/tests/index.js

@@ -34,6 +34,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 = [
     [
@@ -164,27 +217,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");
@@ -203,47 +237,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 = {
@@ -266,7 +259,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");
@@ -296,7 +289,173 @@ 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");
+  });
+});
+
 export {
   Appointment,
+  List,
+  Ledger,
 }
 /* Deserializer Not a pure module */

package/lib/js/src/Deser.js

@@ -430,6 +430,97 @@ function checkFieldsSanity(name, _fields, _optional) {
   };
 }
 
+function isSafeCast(_field) {
+  while (true) {
+    let field = _field;
+    if (typeof field !== "object") {
+      switch (field) {
+        case "Date" :
+        case "Datetime" :
+          return false;
+        default:
+          return true;
+      }
+    } else {
+      switch (field.TAG) {
+        case "Tuple" :
+          return field._0.every(isSafeCast);
+        case "Object" :
+          return field._0.every(param => isSafeCast(param[1]));
+        case "Deserializer" :
+        case "Collection" :
+          return field._0.isSafeCast();
+        case "Array" :
+        case "Optional" :
+        case "OptionalWithDefault" :
+        case "Mapping" :
+        case "DefaultWhenInvalid" :
+        case "Morphism" :
+          _field = field._0;
+          continue;
+        default:
+          return true;
+      }
+    }
+  };
+}
+
+function serialize(_value, _shape, self) {
+  while (true) {
+    let shape = _shape;
+    let value = _value;
+    if (typeof shape !== "object") {
+      switch (shape) {
+        case "Date" :
+        case "Datetime" :
+          return value.toISOString();
+        case "Self" :
+          _shape = self;
+          continue;
+        default:
+          return value;
+      }
+    } else {
+      switch (shape.TAG) {
+        case "Literal" :
+          return shape._0;
+        case "Array" :
+          let inner = shape._0;
+          return value.map(v => serialize(v, inner, self));
+        case "Tuple" :
+          return Belt_Array.zipBy(value, shape._0, (v, f) => serialize(v, f, self));
+        case "Object" :
+          return Object.fromEntries(Stdlib_Array.filterMap(shape._0, param => {
+            let fieldType = param[1];
+            let key = param[0];
+            return Stdlib_Option.map(value[key], fieldValue => [
+              key,
+              serialize(fieldValue, fieldType, self)
+            ]);
+          }));
+        case "Optional" :
+          if (value === undefined) {
+            return null;
+          }
+          _shape = shape._0;
+          _value = Primitive_option.valFromOption(value);
+          continue;
+        case "Mapping" :
+          let inner$1 = shape._0;
+          return Stdlib_Dict.mapValues(value, v => serialize(v, inner$1, self));
+        case "Deserializer" :
+        case "Collection" :
+          return shape._0.toJSON(value);
+        case "OptionalWithDefault" :
+        case "DefaultWhenInvalid" :
+        case "Morphism" :
+          _shape = shape._0;
+          continue;
+      }
+    }
+  };
+}
+
 let Field = {
   usingString: usingString,
   usingInt: usingInt,
@@ -443,12 +534,26 @@ let Field = {
   _taggedToString: _taggedToString,
   extractValue: extractValue,
   fromUntagged: fromUntagged,
-  checkFieldsSanity: checkFieldsSanity
+  checkFieldsSanity: checkFieldsSanity,
+  isSafeCast: isSafeCast,
+  serialize: serialize
 };
 
 function MakeDeserializer(S) {
   let fields = S.fields;
-  let name = `Deserializer ` + "Deser" + `, ` + "File \"Deser.res\", line 318, characters 39-47";
+  let name = `Deserializer ` + "Deser" + `, ` + "File \"Deser.res\", line 380, characters 29-37";
+  let safeCastCache = {
+    contents: undefined
+  };
+  let isSafeCast$1 = () => {
+    let cached = safeCastCache.contents;
+    if (cached !== undefined) {
+      return cached;
+    }
+    let result = isSafeCast(fields);
+    safeCastCache.contents = result;
+    return result;
+  };
   let checkFieldsSanity$1 = () => checkFieldsSanity(name, fields, false);
   let fromJSON = json => {
     let res;
@@ -469,10 +574,19 @@ function MakeDeserializer(S) {
       _0: res
     };
   };
+  let toJSON = value => {
+    if (isSafeCast$1()) {
+      return value;
+    } else {
+      return serialize(value, fields, fields);
+    }
+  };
   return {
     name: name,
     fromJSON: fromJSON,
-    checkFieldsSanity: checkFieldsSanity$1
+    toJSON: toJSON,
+    checkFieldsSanity: checkFieldsSanity$1,
+    isSafeCast: isSafeCast$1
   };
 }