@kaiko.io/rescript-deser 4.0.0-rc.3 → 4.0.0-rc.5

package/lib/js/tests/index.js

@@ -0,0 +1,283 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var $$JSON = require("../src/JSON.js");
+var Curry = require("rescript/lib/js/curry.js");
+var Qunit = require("qunit");
+var Prelude = require("@kaiko.io/rescript-prelude/lib/js/src/Prelude.js");
+
+var fields = {
+  TAG: "Object",
+  _0: [
+    [
+      "note",
+      "String"
+    ],
+    [
+      "date",
+      "Date"
+    ],
+    [
+      "extra",
+      {
+        TAG: "Optional",
+        _0: "String"
+      }
+    ]
+  ]
+};
+
+var Deserializer = $$JSON.MakeDeserializer({
+      fields: fields
+    });
+
+var Appointment = {
+  Deserializer: Deserializer
+};
+
+Qunit.module("Basic deserializer", (function (param) {
+        var valid = [
+          [
+            {"note": "Bicentennial doctor's appointment", "date": "2100-01-01"},
+            {
+              note: "Bicentennial doctor's appointment",
+              date: new Date("2100-01-01"),
+              extra: undefined
+            }
+          ],
+          [
+            {
+      "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: new Date("2100-01-01"),
+              extra: "Don't take your stop-aging pills the night before the appointment"
+            }
+          ]
+        ];
+        Qunit.test("Correctly deserializes data", (function (qunit) {
+                qunit.expect(valid.length);
+                Curry._2(Prelude.$$Array.forEach, valid, (function (param) {
+                        var data = param[0];
+                        console.log("Running sample", data);
+                        var result = Deserializer.fromJSON(data);
+                        if (result.TAG === "Ok") {
+                          qunit.deepEqual(result._0, param[1], "result == expected");
+                          return ;
+                        }
+                        console.error(result._0);
+                      }));
+              }));
+        var invalid = [[
+            "Missing non-optional field",
+            {"extra": "Bicentennial doctor's appointment", "date": "2100-01-01"}
+          ]];
+        Qunit.test("Correctly catches invalid data", (function (qunit) {
+                qunit.expect(invalid.length);
+                Curry._2(Prelude.$$Array.forEach, invalid, (function (param) {
+                        var data = param[1];
+                        console.log("Running sample", param[0], data);
+                        var result = Deserializer.fromJSON(data);
+                        if (result.TAG === "Ok") {
+                          console.error("Invalid being accepted: ", result._0);
+                          return ;
+                        }
+                        console.log("Correctly detected:", result._0);
+                        qunit.ok(true, true);
+                      }));
+              }));
+      }));
+
+Qunit.module("Recursive deserializer", (function (param) {
+        var fields = {
+          TAG: "Object",
+          _0: [
+            [
+              "data",
+              "Any"
+            ],
+            [
+              "children",
+              {
+                TAG: "Array",
+                _0: "Self"
+              }
+            ]
+          ]
+        };
+        var DeserializerImpl = $$JSON.MakeDeserializer({
+              fields: fields
+            });
+        var checkFieldsSanity = DeserializerImpl.checkFieldsSanity;
+        var fromJSON = function (data) {
+          return Curry._2(Prelude.Result.map, DeserializerImpl.fromJSON(data), (function (prim) {
+                        return prim;
+                      }));
+        };
+        var valid = [[
+            {"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: []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]];
+        Qunit.test("Trivial recursion detection: Ok", (function (qunit) {
+                qunit.expect(1);
+                qunit.deepEqual(checkFieldsSanity(), {
+                      TAG: "Ok",
+                      _0: undefined
+                    }, "Ok");
+              }));
+        Qunit.test("Infinite list", (function (qunit) {
+                var fields = {
+                  TAG: "Object",
+                  _0: [
+                    [
+                      "head",
+                      "String"
+                    ],
+                    [
+                      "tail",
+                      "Self"
+                    ]
+                  ]
+                };
+                var InfiniteList = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                qunit.expect(1);
+                qunit.deepEqual(Curry._1(Prelude.Result.isError, InfiniteList.checkFieldsSanity()), true, "Ok");
+              }));
+        Qunit.test("Finite list", (function (qunit) {
+                var fields = {
+                  TAG: "Object",
+                  _0: [
+                    [
+                      "head",
+                      "String"
+                    ],
+                    [
+                      "tail",
+                      {
+                        TAG: "Optional",
+                        _0: "Self"
+                      }
+                    ]
+                  ]
+                };
+                var List = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                qunit.expect(1);
+                qunit.deepEqual(List.checkFieldsSanity(), {
+                      TAG: "Ok",
+                      _0: undefined
+                    }, "Ok");
+              }));
+        Qunit.test("Correctly deserializes recursive data", (function (qunit) {
+                qunit.expect(valid.length);
+                Curry._2(Prelude.$$Array.forEach, valid, (function (param) {
+                        var data = param[0];
+                        console.log("Running sample", data);
+                        var result = fromJSON(data);
+                        if (result.TAG === "Ok") {
+                          qunit.deepEqual(result._0, param[1], "result == expected");
+                          return ;
+                        }
+                        console.error(result._0);
+                      }));
+              }));
+        Qunit.test("Recursion in sub-deserializer", (function (qunit) {
+                var fields = {
+                  TAG: "Object",
+                  _0: [
+                    [
+                      "head",
+                      "String"
+                    ],
+                    [
+                      "tail",
+                      {
+                        TAG: "Optional",
+                        _0: "Self"
+                      }
+                    ]
+                  ]
+                };
+                var List = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                var fields$1 = {
+                  TAG: "Object",
+                  _0: [
+                    [
+                      "records",
+                      {
+                        TAG: "Deserializer",
+                        _0: List
+                      }
+                    ],
+                    [
+                      "next",
+                      {
+                        TAG: "Optional",
+                        _0: "Self"
+                      }
+                    ]
+                  ]
+                };
+                var Ledger = $$JSON.MakeDeserializer({
+                      fields: fields$1
+                    });
+                var data = {"records": {"head": "A", "tail": {"head": "B"}},
+        "next": {"records": {"head": "A", "tail": {"head": "B"}}}};
+                var expected = {
+                  records: {
+                    head: "A",
+                    tail: {
+                      head: "B",
+                      tail: undefined
+                    }
+                  },
+                  next: {
+                    records: {
+                      head: "A",
+                      tail: {
+                        head: "B",
+                        tail: undefined
+                      }
+                    },
+                    next: undefined
+                  }
+                };
+                qunit.expect(1);
+                qunit.deepEqual(Ledger.fromJSON(data), {
+                      TAG: "Ok",
+                      _0: expected
+                    }, "nice ledger");
+              }));
+      }));
+
+exports.Appointment = Appointment;
+/* Deserializer Not a pure module */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaiko.io/rescript-deser",
-  "version": "4.0.0-rc.3",
+  "version": "4.0.0-rc.5",
   "keywords": [
     "json",
     "deserializer",
@@ -20,11 +20,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@kaiko.io/rescript-prelude": "7.0.0-rc.3"
+    "@kaiko.io/rescript-prelude": "7.0.0-rc.6"
   },
   "devDependencies": {
     "esbuild": "^0.15.7",
     "qunit": "^2.16.0",
-    "rescript": "11.0.0-rc.6"
+    "rescript": "11.0.0-rc.7"
   }
 }

package/lib/ocaml/.compiler.log

@@ -1,2 +0,0 @@
-#Start(1700763106532)
-#Done(1700763106537)

package/lib/ocaml/.ninja_log

@@ -1,6 +0,0 @@
-# ninja log v6
-0	3	1700763106533253326	JSON.cmi	bafb789a597a23fb
-0	3	1700763106533253326	JSON.cmj	e0df0c7e15c09f8e
-0	3	1700763106533253326	JSON.cmt	cb51be205f02087e
-1	3	1700763106533253326	JSON.res	b4c17270ea3dc72d
-3	4	1700763106536586783	install.stamp	cff5a5b4c02d30cf

package/lib/ocaml/JSON.res

@@ -1,343 +0,0 @@
-@@uncurried
-open Prelude
-
-module FieldValue = {
-  type t
-  external string: string => t = "%identity"
-  external int: int => t = "%identity"
-  external float: float => t = "%identity"
-  external boolean: bool => t = "%identity"
-  external array: array<t> => t = "%identity"
-  external object: Dict.t<t> => t = "%identity"
-  external mapping: Dict.t<t> => t = "%identity"
-  external any: 'a => t = "%identity"
-  @val external null: t = "undefined"
-
-  external asString: t => string = "%identity"
-  external asInt: t => int = "%identity"
-  external asFloat: t => float = "%identity"
-  external asBoolean: t => bool = "%identity"
-  external asArray: t => array<'a> = "%identity"
-  external asObject: t => 'a = "%identity"
-}
-
-exception TypeError(string)
-
-@doc("The module type of a built deserializer which is suitable to add as a subparser.")
-module type Deserializer = {
-  type t
-  let name: string
-  let fromJSON: Js.Json.t => result<t, string>
-  let checkFieldsSanity: unit => result<unit, string>
-}
-
-module Field = {
-  type rec t =
-    | Any
-    | String
-    | Literal(string)
-    | Int
-    | Float
-    | Boolean
-    | Array(t)
-    /// These SHOULD strings in ISO format, but we only validate the string
-    /// can be represented in Js.Date without spewing NaN all over the place;
-    /// Js.Date.fromString("xxx") returns an object that is mostly unusable.
-    ///
-    /// We also allow floats and then use Js.Date.fromFloat.
-    | Date
-    | Datetime // alias of Date
-
-    | Tuple(array<t>)
-    | Object(array<(string, t)>)
-    | Optional(t)
-    | OptionalWithDefault(t, FieldValue.t)
-    /// An arbitrary mapping from names to other arbitrary fields.  The
-    /// difference with Object, is that you don't know the names of the
-    /// expected entries.
-    | Mapping(t)
-
-    | Deserializer(module(Deserializer))
-
-    /// A specialized Array of deserialized items that ignores unparsable
-    /// items and returns the valid collection.  This saves the user from
-    /// writing 'Array(DefaultWhenInvalid(Optional(Deserializer(module(M)))))'
-    /// and then post-process the list of items with 'Array.keepSome'
-    | Collection(module(Deserializer))
-    | DefaultWhenInvalid(t, FieldValue.t)
-
-    // FIXME: this is used to add additional restrictions like variadictInt or
-    // variadicString; but I find it too type-unsafe.  I might consider having
-    // a Constraints for this in the future.
-    | Morphism(t, FieldValue.t => FieldValue.t)
-
-    | Self
-
-  let usingString = (f: string => 'a) => value => value->FieldValue.asString->f->FieldValue.any
-  let usingInt = (f: int => 'a) => value => value->FieldValue.asInt->f->FieldValue.any
-  let usingFloat = (f: float => 'a) => value => value->FieldValue.asFloat->f->FieldValue.any
-  let usingBoolean = (f: bool => 'a) => value => value->FieldValue.asBoolean->f->FieldValue.any
-  let usingArray = (f: array<'a> => 'b) => value => value->FieldValue.asArray->f->FieldValue.any
-  let usingObject = (f: 'a => 'b) => value => value->FieldValue.asObject->f->FieldValue.any
-
-  let variadicInt = (hint: string, fromJs: int => option<'variadicType>) => Morphism(
-    Int,
-    usingInt(i => {
-      switch i->fromJs {
-      | Some(internalValue) => internalValue
-      | None =>
-        raise(TypeError(`This Int(${i->Int.toString}) not a valid value here. Hint: ${hint}`))
-      }
-    }),
-  )
-  let variadicString = (hint: string, fromJs: string => option<'variadicType>) => Morphism(
-    String,
-    usingString(i => {
-      switch i->fromJs {
-      | Some(internalValue) => internalValue
-      | None => raise(TypeError(`This String("${i}") not a valid value here. Hint: ${hint}`))
-      }
-    }),
-  )
-
-  let rec toString = (type_: t) =>
-    switch type_ {
-    | Any => "Any"
-    | String => "String"
-    | Literal(lit) => `Literal: ${lit}`
-    | Int => "Integer"
-    | Float => "Float"
-    | Boolean => "Boolean"
-    | Datetime
-    | Date => "Date"
-    | Self => "Self (recursive)"
-    | Collection(m) => {
-        module M = unpack(m: Deserializer)
-        "Collection of " ++ M.name
-      }
-
-    | Array(t) => "Array of " ++ t->toString
-    | Tuple(bases) => `Tuple of (${bases->Array.map(toString)->Array.join(", ")})`
-    | Object(fields) => {
-        let desc = fields->Array.map(((field, t)) => `${field}: ${t->toString}`)->Array.join(", ")
-        `Object of {${desc}}`
-      }
-
-    | OptionalWithDefault(t, _)
-    | Optional(t) =>
-      "Null of " ++ t->toString
-    | Mapping(t) => `Mapping of ${t->toString}`
-    | Morphism(t, _) => t->toString ++ " to apply a morphism"
-    | Deserializer(m) => {
-        module M = unpack(m: Deserializer)
-        M.name
-      }
-
-    | DefaultWhenInvalid(t, _) => `Protected ${t->toString}`
-    }
-
-  let _taggedToString = (tagged: Js.Json.tagged_t) => {
-    switch tagged {
-    | Js.Json.JSONFalse => "Boolean(false)"
-    | Js.Json.JSONTrue => "Boolean(true)"
-    | Js.Json.JSONNull => "Null"
-    | Js.Json.JSONString(text) => `String("${text}")`
-    | Js.Json.JSONNumber(number) => `Number(${number->Float.toString})`
-    | Js.Json.JSONObject(obj) => `Object(${obj->Js.Json.stringifyAny->default("...")})`
-    | Js.Json.JSONArray(array) => `Array(${array->Js.Json.stringifyAny->default("...")})`
-    }
-  }
-
-  let rec extractValue = (
-    values: Dict.t<Js.Json.t>,
-    field: string,
-    shape: t,
-    self: t,
-  ): FieldValue.t => {
-    switch values->Dict.get(field) {
-    | Some(value) => value->fromUntagged(shape, self)
-    | None =>
-      switch shape {
-      | DefaultWhenInvalid(_, _) => Js.Json.null->fromUntagged(shape, self)
-      | Optional(_) => Js.Json.null->fromUntagged(shape, self)
-      | OptionalWithDefault(_, default) => default
-      | _ => raise(TypeError(`Missing non-optional field '${field}'`))
-      }
-    }
-  }
-  and fromUntagged = (untagged: Js.Json.t, shape: t, self: t): FieldValue.t => {
-    switch (shape, untagged->Js.Json.classify) {
-    | (Any, _) => untagged->FieldValue.any
-    | (Literal(expected), Js.Json.JSONString(text)) =>
-      if text == expected {
-        FieldValue.string(text)
-      } else {
-        raise(TypeError(`Expecting literal ${expected}, got ${text}`))
-      }
-    | (String, Js.Json.JSONString(text)) => FieldValue.string(text)
-    | (Int, Js.Json.JSONNumber(number)) => FieldValue.int(number->Float.toInt)
-    | (Float, Js.Json.JSONNumber(number)) => FieldValue.float(number)
-    | (Boolean, Js.Json.JSONTrue) => FieldValue.boolean(true)
-    | (Boolean, Js.Json.JSONFalse) => FieldValue.boolean(false)
-    | (Tuple(bases), Js.Json.JSONArray(items)) => {
-        let lenbases = bases->Array.length
-        let lenitems = items->Array.length
-        if lenbases == lenitems {
-          let values = Array.zipBy(items, bases, (i, b) => fromUntagged(i, b, self))
-          values->FieldValue.array
-        } else {
-          raise(
-            TypeError(`Expecting ${lenbases->Int.toString} items, got ${lenitems->Int.toString}`),
-          )
-        }
-      }
-
-    | (Datetime, Js.Json.JSONString(s))
-    | (Date, Js.Json.JSONString(s)) => {
-        let r = Js.Date.fromString(s)
-        if r->Js.Date.getDate->Js.Float.isNaN {
-          raise(TypeError(`Invalid date ${s}`))
-        }
-        r->FieldValue.any
-      }
-
-    | (Datetime, Js.Json.JSONNumber(f))
-    | (Date, Js.Json.JSONNumber(f)) => {
-        let r = Js.Date.fromFloat(f)
-        if r->Js.Date.getDate->Js.Float.isNaN {
-          raise(TypeError(`Invalid date ${f->Js.Float.toString}`))
-        }
-        r->FieldValue.any
-      }
-
-    | (Array(shape), Js.Json.JSONArray(items)) =>
-      FieldValue.array(items->Array.map(item => item->fromUntagged(shape, self)))
-    | (Mapping(f), Js.Json.JSONObject(values)) =>
-      values->Dict.mapValues(v => v->fromUntagged(f, self))->FieldValue.mapping
-    | (Object(fields), Js.Json.JSONObject(values)) =>
-      FieldValue.object(
-        fields
-        ->Array.map(((field, shape)) => {
-          let value = switch extractValue(values, field, shape, self) {
-          | value => value
-          | exception TypeError(msg) => raise(TypeError(`Field "${field}": ${msg}`))
-          }
-          (field, value)
-        })
-        ->Dict.fromArray,
-      )
-
-    | (OptionalWithDefault(_, value), Js.Json.JSONNull) => value
-    | (OptionalWithDefault(shape, _), _) => untagged->fromUntagged(shape, self)
-    | (Optional(_), Js.Json.JSONNull) => FieldValue.null
-    | (Optional(shape), _) => untagged->fromUntagged(shape, self)
-    | (Morphism(shape, f), _) => untagged->fromUntagged(shape, self)->f->FieldValue.any
-
-    | (Collection(m), Js.Json.JSONArray(items)) => {
-        module M = unpack(m: Deserializer)
-        items
-        ->Array.map(M.fromJSON)
-        ->Array.map(Result.warn)
-        ->Array.keepSome
-        ->Array.map(FieldValue.any)
-        ->FieldValue.array
-      }
-
-    | (Deserializer(m), _) => {
-        module M = unpack(m: Deserializer)
-        switch untagged->M.fromJSON {
-        | Ok(res) => res->FieldValue.any
-        | Error(msg) => raise(TypeError(msg))
-        }
-      }
-
-    | (DefaultWhenInvalid(t, default), _) =>
-      switch untagged->fromUntagged(t, self) {
-      | res => res
-      | exception TypeError(msg) => {
-          Js.Console.warn2("Detected and ignore (with default): ", msg)
-          default
-        }
-      }
-    | (Self, _) => untagged->fromUntagged(self, self)
-    | (expected, actual) =>
-      raise(TypeError(`Expected ${expected->toString}, but got ${actual->_taggedToString} instead`))
-    }
-  }
-
-  let rec checkFieldsSanity = (name: string, fields: t, optional: bool): result<unit, string> =>
-    switch (fields, optional) {
-    | (Self, false) => Error(`${name}: Trivial infinite recursion 'let fields = Self'`)
-    | (Self, true) => Ok()
-
-    | (Any, _) => Ok()
-    | (String, _) | (Float, _) | (Int, _) | (Literal(_), _) => Ok()
-    | (Boolean, _) | (Date, _) | (Datetime, _) => Ok()
-    | (Morphism(_, _), _) => Ok()
-
-    | (Collection(mod), _)
-    | (Deserializer(mod), _) => {
-        module M = unpack(mod: Deserializer)
-        switch M.checkFieldsSanity() {
-        | Ok() => Ok()
-        | Error(msg) => Error(`${name}/ ${msg}`)
-        }
-      }
-
-    | (DefaultWhenInvalid(fields, _), _)
-    | (OptionalWithDefault(fields, _), _)
-    | (Optional(fields), _) =>
-      checkFieldsSanity(name, fields, true)
-
-    | (Object(fields), optional) =>
-      fields
-      ->Array.map(((fieldName, field)) => () =>
-        checkFieldsSanity(`${name}::${fieldName}`, field, optional))
-      ->ManyResults.bailU
-      ->ManyResults.map(_ => ())
-
-    /// Mappings and arrays can be empty, so their payloads are
-    /// automatically optional.
-    | (Mapping(field), _) | (Array(field), _) => checkFieldsSanity(name, field, true)
-
-    | (Tuple(fields), optional) =>
-      fields
-      ->Array.mapWithIndex((field, index) => () =>
-        checkFieldsSanity(`${name}[${index->Int.toString}]`, field, optional))
-      ->ManyResults.bailU
-      ->ManyResults.map(_ => ())
-    }
-}
-
-module type Serializable = {
-  type t
-  let fields: Field.t
-}
-
-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 name = `Deserializer ${__MODULE__}, ${loc}`
-
-  %%private(external _toNativeType: FieldValue.t => t = "%identity")
-
-  @doc("Checks for trivial infinite-recursion in the fields of the module.
-
-  Notice this algorithm is just an heuristic, and it might happen that are
-  cases of infinite-recursion not detected and cases where detection is a
-  false positive.
-
-  You should use this only while debugging/developing to verify your data.
-
-  ")
-  let checkFieldsSanity = () => Field.checkFieldsSanity(name, fields, false)
-
-  @doc("Parse a `Js.Json.t` into `result<t, string>`")
-  let fromJSON = (json: Js.Json.t): result<t, _> => {
-    switch json->Field.fromUntagged(fields, fields) {
-    | res => Ok(res->_toNativeType)
-    | exception TypeError(e) => Error(e)
-    }
-  }
-}