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

package/lib/bs/___incremental/index.res

@@ -0,0 +1,189 @@
+open QUnit
+open RescriptCore
+
+module Appointment = {
+  type t = {
+    note: string,
+    date: Date.t,
+    extra: option<string>,
+  }
+  module Deserializer = Deser.MakeDeserializer({
+    type t = t
+    open Deser.Field
+
+    let fields = Object([("note", String), ("date", Date), ("extra", Optional(String))])
+  })
+}
+
+module_("Basic deserializer", _ => {
+  let valid: array<(_, Appointment.t)> = [
+    (
+      %raw(`{"note": "Bicentennial doctor's appointment", "date": "2100-01-01"}`),
+      {
+        note: "Bicentennial doctor's appointment",
+        date: Date.fromString("2100-01-01"),
+        extra: None,
+      },
+    ),
+    (
+      %raw(`{
+      "note": "Bicentennial doctor's appointment",
+      "date": "2100-01-01",
+      "extra": "Don't take your stop-aging pills the night before the appointment",
+    }`),
+      {
+        note: "Bicentennial doctor's appointment",
+        date: Date.fromString("2100-01-01"),
+        extra: Some("Don't take your stop-aging pills the night before the appointment"),
+      },
+    ),
+  ]
+
+  test("Correctly deserializes data", qunit => {
+    qunit->expect(valid->Array.length)
+    valid->Array.forEach(
+      ((data, expected)) => {
+        Console.log2("Running sample", data)
+        switch Appointment.Deserializer.fromJSON(data) {
+        | Ok(result) => qunit->deepEqual(result, expected, "result == expected")
+        | Error(msg) => Console.error(msg)
+        }
+      },
+    )
+  })
+
+  let invalid = [
+    (
+      "Missing non-optional field",
+      %raw(`{"extra": "Bicentennial doctor's appointment", "date": "2100-01-01"}`),
+    ),
+  ]
+
+  test("Correctly catches invalid data", qunit => {
+    qunit->expect(invalid->Array.length)
+    invalid->Array.forEach(
+      ((message, data)) => {
+        Console.log3("Running sample", message, data)
+        switch Appointment.Deserializer.fromJSON(data) {
+        | Ok(result) => Console.error2("Invalid being accepted: ", result)
+        | Error(msg) => {
+            Console.log2("Correctly detected:", msg)
+            qunit->ok(true, true)
+          }
+        }
+      },
+    )
+  })
+})
+
+module_("Recursive deserializer", _ => {
+  module TrivialTree = {
+    type rec t<'a> = {
+      data: 'a,
+      children: array<t<'a>>,
+    }
+
+    module DeserializerImpl = Deser.MakeDeserializer({
+      type payload
+      type rec t = {
+        data: payload,
+        children: array<t>,
+      }
+      open Deser.Field
+
+      let fields = Object([("data", Any), ("children", Array(Self))])
+    })
+
+    module Deserializer = {
+      include DeserializerImpl
+
+      let fromJSON = data => data->DeserializerImpl.fromJSON->Result.map(x => x->Obj.magic)
+    }
+  }
+
+  let valid: array<(_, TrivialTree.t<string>)> = [
+    (
+      %raw(`{"data": "A", "children": [{"data": "A1", "children": []}, {"data": "B", "children": [{"data": "C", "children": []}, {"data": "D", "children": []}]}]}`),
+      {
+        data: "A",
+        children: [
+          {data: "A1", children: []},
+          {data: "B", children: [{data: "C", children: []}, {data: "D", children: []}]},
+        ],
+      },
+    ),
+  ]
+
+  test("Trivial recursion detection: Ok", qunit => {
+    qunit->expect(1)
+    qunit->deepEqual(TrivialTree.Deserializer.checkFieldsSanity(), Ok(), "Ok")
+  })
+
+  test("Infinite list", qunit => {
+    module InfiniteList = Deser.MakeDeserializer({
+      open Deser.Field
+
+      type t
+      let fields = Object([("head", String), ("tail", Self)])
+    })
+
+    qunit->expect(1)
+    qunit->deepEqual(InfiniteList.checkFieldsSanity()->Result.isError, true, "Ok")
+  })
+
+  test("Finite list", qunit => {
+    module List = Deser.MakeDeserializer({
+      open Deser.Field
+
+      type t
+      let fields = Object([("head", String), ("tail", Optional(Self))])
+    })
+
+    qunit->expect(1)
+    qunit->deepEqual(List.checkFieldsSanity(), Ok(), "Ok")
+  })
+
+  test("Correctly deserializes recursive data", qunit => {
+    qunit->expect(valid->Array.length)
+    valid->Array.forEach(
+      ((data, expected)) => {
+        Console.log2("Running sample", data)
+        switch TrivialTree.Deserializer.fromJSON(data) {
+        | Ok(result) => qunit->deepEqual(result, expected, "result == expected")
+        | Error(msg) => Console.error(msg)
+        }
+      },
+    )
+  })
+
+  test("Recursion in sub-deserializer", qunit => {
+    module List = Deser.MakeDeserializer({
+      open Deser.Field
+
+      type t
+      let fields = Object([("head", String), ("tail", Optional(Self))])
+    })
+
+    module Ledger = Deser.MakeDeserializer({
+      open Deser.Field
+
+      type t
+      let fields = Object([("records", Deserializer(module(List))), ("next", Optional(Self))])
+    })
+
+    let data = %raw(`
+       {"records": {"head": "A", "tail": {"head": "B"}},
+        "next": {"records": {"head": "A", "tail": {"head": "B"}}}}
+    `)
+    let expected = {
+      "records": {"head": "A", "tail": {"head": "B", "tail": None}},
+      "next": {
+        "records": {"head": "A", "tail": {"head": "B", "tail": None}},
+        "next": None,
+      },
+    }
+
+    qunit->expect(1)
+    qunit->deepEqual(data->Ledger.fromJSON->Obj.magic, Ok(expected), "nice ledger")
+  })
+})

package/lib/es6/src/Deser.js

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Js_json from "rescript/lib/es6/js_json.js";
 import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as Core__Dict from "@rescript/core/lib/es6/src/Core__Dict.js";
 import * as Caml_option from "rescript/lib/es6/caml_option.js";
@@ -138,28 +137,26 @@ function toString(type_) {
 }
 
 function _taggedToString(tagged) {
-  if (typeof tagged !== "object") {
-    switch (tagged) {
-      case "JSONFalse" :
-          return "Boolean(false)";
-      case "JSONTrue" :
+  if (!Array.isArray(tagged) && (tagged === null || typeof tagged !== "object") && typeof tagged !== "number" && typeof tagged !== "string" && typeof tagged !== "boolean") {
+    return "Null";
+  }
+  if (Array.isArray(tagged)) {
+    return "Array(" + Core__Option.getOr(JSON.stringify(tagged), "...") + ")";
+  }
+  switch (typeof tagged) {
+    case "boolean" :
+        if (tagged) {
           return "Boolean(true)";
-      case "JSONNull" :
-          return "Null";
-      
-    }
-  } else {
-    switch (tagged.TAG) {
-      case "JSONString" :
-          return "String(\"" + tagged._0 + "\")";
-      case "JSONNumber" :
-          return "Number(" + tagged._0.toString() + ")";
-      case "JSONObject" :
-          return "Object(" + Core__Option.getOr(JSON.stringify(tagged._0), "...") + ")";
-      case "JSONArray" :
-          return "Array(" + Core__Option.getOr(JSON.stringify(tagged._0), "...") + ")";
-      
-    }
+        } else {
+          return "Boolean(false)";
+        }
+    case "string" :
+        return "String(\"" + tagged + "\")";
+    case "number" :
+        return "Number(" + tagged.toString() + ")";
+    case "object" :
+        return "Object(" + Core__Option.getOr(JSON.stringify(tagged), "...") + ")";
+    
   }
 }
 
@@ -189,93 +186,34 @@ function extractValue(values, field, shape, self) {
 function fromUntagged(untagged, _shape, self) {
   while(true) {
     var shape = _shape;
-    var match = Js_json.classify(untagged);
     var exit = 0;
-    var s;
-    var f;
     if (typeof shape !== "object") {
       switch (shape) {
         case "Any" :
             return untagged;
         case "String" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONString") {
-                return match._0;
-              }
-              exit = 1;
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && typeof untagged === "string") {
+              return untagged;
             }
             break;
         case "Int" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONNumber") {
-                return match._0 | 0;
-              }
-              exit = 1;
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && typeof untagged === "number") {
+              return untagged | 0;
             }
             break;
         case "Float" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONNumber") {
-                return match._0;
-              }
-              exit = 1;
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && typeof untagged === "number") {
+              return untagged;
             }
             break;
         case "Boolean" :
-            if (typeof match !== "object") {
-              switch (match) {
-                case "JSONFalse" :
-                    return false;
-                case "JSONTrue" :
-                    return true;
-                default:
-                  exit = 1;
-              }
-            } else {
-              exit = 1;
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && typeof untagged === "boolean") {
+              return untagged;
             }
             break;
         case "Date" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              switch (match.TAG) {
-                case "JSONString" :
-                    s = match._0;
-                    exit = 2;
-                    break;
-                case "JSONNumber" :
-                    f = match._0;
-                    exit = 3;
-                    break;
-                default:
-                  exit = 1;
-              }
-            }
-            break;
         case "Datetime" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              switch (match.TAG) {
-                case "JSONString" :
-                    s = match._0;
-                    exit = 2;
-                    break;
-                case "JSONNumber" :
-                    f = match._0;
-                    exit = 3;
-                    break;
-                default:
-                  exit = 1;
-              }
-            }
+            exit = 2;
             break;
         case "Self" :
             _shape = self;
@@ -285,133 +223,91 @@ function fromUntagged(untagged, _shape, self) {
     } else {
       switch (shape.TAG) {
         case "Literal" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONString") {
-                var text = match._0;
-                var expected = shape._0;
-                if (text === expected) {
-                  return text;
-                }
-                throw {
-                      RE_EXN_ID: $$TypeError,
-                      _1: "Expecting literal " + expected + ", got " + text,
-                      Error: new Error()
-                    };
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && typeof untagged === "string") {
+              var expected = shape._0;
+              if (untagged === expected) {
+                return untagged;
               }
-              exit = 1;
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "Expecting literal " + expected + ", got " + untagged,
+                    Error: new Error()
+                  };
             }
             break;
         case "Array" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONArray") {
-                var shape$1 = shape._0;
-                return match._0.map((function(shape$1){
-                          return function (item) {
-                            return fromUntagged(item, shape$1, self);
-                          }
-                          }(shape$1)));
-              }
-              exit = 1;
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && Array.isArray(untagged)) {
+              var shape$1 = shape._0;
+              return untagged.map((function(shape$1){
+                        return function (item) {
+                          return fromUntagged(item, shape$1, self);
+                        }
+                        }(shape$1)));
             }
             break;
         case "Tuple" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONArray") {
-                var items = match._0;
-                var bases = shape._0;
-                var lenbases = bases.length;
-                var lenitems = items.length;
-                if (lenbases === lenitems) {
-                  return Belt_Array.zipBy(items, bases, (function (i, b) {
-                                return fromUntagged(i, b, self);
-                              }));
-                }
-                throw {
-                      RE_EXN_ID: $$TypeError,
-                      _1: "Expecting " + lenbases.toString() + " items, got " + lenitems.toString(),
-                      Error: new Error()
-                    };
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && Array.isArray(untagged)) {
+              var bases = shape._0;
+              var lenbases = bases.length;
+              var lenitems = untagged.length;
+              if (lenbases === lenitems) {
+                return Belt_Array.zipBy(untagged, bases, (function (i, b) {
+                              return fromUntagged(i, b, self);
+                            }));
               }
-              exit = 1;
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "Expecting " + lenbases.toString() + " items, got " + lenitems.toString(),
+                    Error: new Error()
+                  };
             }
             break;
         case "Object" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONObject") {
-                var values = match._0;
-                return Object.fromEntries(shape._0.map((function(values){
-                              return function (param) {
-                                var field = param[0];
-                                var value;
-                                try {
-                                  value = extractValue(values, field, param[1], self);
-                                }
-                                catch (raw_msg){
-                                  var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
-                                  if (msg.RE_EXN_ID === $$TypeError) {
-                                    throw {
-                                          RE_EXN_ID: $$TypeError,
-                                          _1: "Field \"" + field + "\": " + msg._1,
-                                          Error: new Error()
-                                        };
-                                  }
-                                  throw msg;
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && typeof untagged === "object" && !Array.isArray(untagged)) {
+              return Object.fromEntries(shape._0.map(function (param) {
+                              var field = param[0];
+                              var value;
+                              try {
+                                value = extractValue(untagged, field, param[1], self);
+                              }
+                              catch (raw_msg){
+                                var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
+                                if (msg.RE_EXN_ID === $$TypeError) {
+                                  throw {
+                                        RE_EXN_ID: $$TypeError,
+                                        _1: "Field \"" + field + "\": " + msg._1,
+                                        Error: new Error()
+                                      };
                                 }
-                                return [
-                                        field,
-                                        value
-                                      ];
+                                throw msg;
                               }
-                              }(values))));
-              }
-              exit = 1;
+                              return [
+                                      field,
+                                      value
+                                    ];
+                            }));
             }
             break;
         case "Optional" :
-            var shape$2 = shape._0;
-            if (typeof match !== "object") {
-              if (match === "JSONNull") {
-                return undefined;
-              }
-              _shape = shape$2;
-              continue ;
-            } else {
-              _shape = shape$2;
-              continue ;
+            if (!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") {
+              return undefined;
             }
+            _shape = shape._0;
+            continue ;
         case "OptionalWithDefault" :
-            var shape$3 = shape._0;
-            if (typeof match !== "object") {
-              if (match === "JSONNull") {
-                return shape._1;
-              }
-              _shape = shape$3;
-              continue ;
-            } else {
-              _shape = shape$3;
-              continue ;
+            if (!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") {
+              return shape._1;
             }
+            _shape = shape._0;
+            continue ;
         case "Mapping" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONObject") {
-                var f$1 = shape._0;
-                return Core__Dict.mapValues(match._0, (function(f$1){
-                          return function (v) {
-                            return fromUntagged(v, f$1, self);
-                          }
-                          }(f$1)));
-              }
-              exit = 1;
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && typeof untagged === "object" && !Array.isArray(untagged)) {
+              var f = shape._0;
+              return Core__Dict.mapValues(untagged, (function(f){
+                        return function (v) {
+                          return fromUntagged(v, f, self);
+                        }
+                        }(f)));
             }
             break;
         case "Deserializer" :
@@ -425,17 +321,15 @@ function fromUntagged(untagged, _shape, self) {
                   Error: new Error()
                 };
         case "Collection" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONArray") {
-                return match._0.map(shape._0.fromJSON).filter(function (x) {
-                              return Core__Result.isOk(x);
-                            }).map(function (prim) {
-                            return prim;
-                          });
-              }
-              exit = 1;
+            if (!(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean") && Array.isArray(untagged)) {
+              return Core__Array.filterMap(untagged.map(shape._0.fromJSON), (function (x) {
+                              if (x.TAG === "Ok") {
+                                return Caml_option.some(x._0);
+                              }
+                              console.warn("Deser", "Could not deserialize value in the collection", x._0);
+                            })).map(function (prim) {
+                          return prim;
+                        });
             }
             break;
         case "DefaultWhenInvalid" :
@@ -455,35 +349,37 @@ function fromUntagged(untagged, _shape, self) {
         
       }
     }
-    switch (exit) {
-      case 1 :
-          throw {
-                RE_EXN_ID: $$TypeError,
-                _1: "Expected " + toString(shape) + ", but got " + _taggedToString(match) + " instead",
-                Error: new Error()
-              };
-      case 2 :
-          var r = new Date(s);
-          if (Number.isNaN(r.getDate())) {
-            throw {
-                  RE_EXN_ID: $$TypeError,
-                  _1: "Invalid date " + s,
-                  Error: new Error()
-                };
-          }
-          return r;
-      case 3 :
-          var r$1 = new Date(f);
-          if (Number.isNaN(r$1.getDate())) {
-            throw {
-                  RE_EXN_ID: $$TypeError,
-                  _1: "Invalid date " + f.toString(),
-                  Error: new Error()
-                };
-          }
-          return r$1;
-      
+    if (exit === 2 && !(!Array.isArray(untagged) && (untagged === null || typeof untagged !== "object") && typeof untagged !== "number" && typeof untagged !== "string" && typeof untagged !== "boolean")) {
+      switch (typeof untagged) {
+        case "string" :
+            var r = new Date(untagged);
+            if (isNaN(r.getDate())) {
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "Invalid date " + untagged,
+                    Error: new Error()
+                  };
+            }
+            return r;
+        case "number" :
+            var r$1 = new Date(untagged);
+            if (isNaN(r$1.getDate())) {
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "Invalid date " + untagged.toString(),
+                    Error: new Error()
+                  };
+            }
+            return r$1;
+        default:
+          
+      }
     }
+    throw {
+          RE_EXN_ID: $$TypeError,
+          _1: "Expected " + toString(shape) + ", but got " + _taggedToString(untagged) + " instead",
+          Error: new Error()
+        };
   };
 }
 
@@ -616,7 +512,7 @@ var Field = {
 
 function MakeDeserializer(S) {
   var fields = S.fields;
-  var name = "Deserializer " + "Deser" + ", " + "File \"Deser.res\", line 322, characters 39-47";
+  var name = "Deserializer " + "Deser" + ", " + "File \"Deser.res\", line 328, characters 39-47";
   var checkFieldsSanity$1 = function () {
     return checkFieldsSanity(name, fields, false);
   };