@kaiko.io/rescript-deser 3.0.0 → 3.1.1

package/README.md

@@ -60,6 +60,8 @@ module type Serializable = {
 
 - `String`, parses a JSON string into a ReScript `string`.
 
+- `Literal(expected)`, parses a JSON string that must match the expected value.
+
 - `Int`, parses a JSON number into a ReScript `int`
 
 - `Float`, parses a JSON number into a ReScript `float`

package/lib/bs/.bsdeps

@@ -0,0 +1,8 @@
+10.1.4
+/home/manu/src/kaiko/rescript-deser
+0
+bsconfig.json	0x1.928a985db325ep+30
+tests	0x1.928a985db325ep+30
+src/	0x1.928a966f225d1p+30
+===
+/home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/rescript.exe	0x1.92557f3109375p+30

package/lib/bs/.compiler.log

@@ -0,0 +1,2 @@
+#Start(1688380979802)
+#Done(1688380979840)

package/lib/bs/.ninja_log

@@ -0,0 +1,93 @@
+# ninja log v6
+0	8	1688379247615623387	tests/basic.test.ast	b18ba9a9379ce270
+1	9	1688379247615623387	src/JSON.ast	23930881e232c07e
+8	10	1688379247618956759	tests/basic.test.d	e38380efe2655d28
+9	11	1688379247618956759	src/JSON.d	d00ba87460d947fd
+11	29	1688379247635623618	src/JSON.cmj	67397b051f42aeaa
+11	29	1688379247635623618	src/JSON.cmi	67397b051f42aeaa
+11	29	1688379247635623618	../js/src/JSON.js	67397b051f42aeaa
+29	42	1688379247648957107	tests/basic.test.cmj	264790990402e165
+29	42	1688379247648957107	tests/basic.test.cmi	264790990402e165
+29	42	1688379247648957107	../js/tests/basic.test.js	264790990402e165
+1	4	1688379247615623387	src/JSON.d	fc2c0e0c4fe5285f
+1	4	1688379866579377605	tests/basic.test.d	596a67a62e5625fe
+0	8	1688379866582710976	tests/Vitest.ast	28d80820c52df4e6
+8	12	1688379866586044348	tests/Vitest.d	284003306f693a77
+12	20	1688379866592711090	tests/Vitest.cmj	99911ce485217725
+12	20	1688379866592711090	tests/Vitest.cmi	99911ce485217725
+12	20	1688379866592711090	../js/tests/Vitest.js	99911ce485217725
+0	12	1688379868009393830	tests/Vitest.ast	28d80820c52df4e6
+12	15	1688379868009393830	tests/Vitest.d	284003306f693a77
+15	43	1688379868042727542	tests/Vitest.cmj	99911ce485217725
+15	43	1688379868042727542	tests/Vitest.cmi	99911ce485217725
+15	43	1688379868042727542	../js/tests/Vitest.js	99911ce485217725
+43	57	1688379868039394170	tests/basic.test.cmj	264790990402e165
+43	57	1688379868039394170	tests/basic.test.cmi	264790990402e165
+43	57	1688379868039394170	../js/tests/basic.test.js	264790990402e165
+0	34	1688379868009393830	tests/Vitest.cmj	5cdaa44fe168d6d
+0	34	1688379868009393830	tests/Vitest.cmi	5cdaa44fe168d6d
+0	34	1688379868009393830	../js/tests/Vitest.js	5cdaa44fe168d6d
+0	18	1688379247618956759	src/JSON.cmj	fa5cf520a8be3344
+0	18	1688379247618956759	src/JSON.cmi	fa5cf520a8be3344
+0	18	1688379247618956759	../js/src/JSON.js	fa5cf520a8be3344
+0	30	1688379868009393830	tests/Vitest.cmj	cc2f06b9e262dacc
+0	30	1688379868009393830	tests/Vitest.cmi	cc2f06b9e262dacc
+0	30	1688379868009393830	../js/tests/Vitest.js	cc2f06b9e262dacc
+30	42	1688379891392992407	tests/basic.test.cmj	68fbf486ceda534b
+30	42	1688379891392992407	tests/basic.test.cmi	68fbf486ceda534b
+30	42	1688379891392992407	../js/tests/basic.test.js	68fbf486ceda534b
+0	17	1688379247618956759	src/JSON.cmj	e156d0c178c482e3
+0	17	1688379247618956759	src/JSON.cmi	e156d0c178c482e3
+0	17	1688379247618956759	../js/src/JSON.js	e156d0c178c482e3
+0	29	1688379868009393830	tests/Vitest.cmj	2125bb8631fd6b6f
+0	29	1688379868009393830	tests/Vitest.cmi	2125bb8631fd6b6f
+0	29	1688379868009393830	../js/tests/Vitest.js	2125bb8631fd6b6f
+29	42	1688379891392992407	tests/basic.test.cmj	796dce8c08df8f5f
+29	42	1688379891392992407	tests/basic.test.cmi	796dce8c08df8f5f
+29	42	1688379891392992407	../js/tests/basic.test.js	796dce8c08df8f5f
+0	3	1688379247615623387	src/JSON.d	d00ba87460d947fd
+0	3	1688379935600160219	tests/basic.test.d	e38380efe2655d28
+3	15	1688379935600160219	tests/basic.test.cmj	796dce8c08df8f5f
+3	15	1688379935600160219	tests/basic.test.cmi	796dce8c08df8f5f
+3	15	1688379935600160219	../js/tests/basic.test.js	796dce8c08df8f5f
+0	3	1688379946993622648	tests/basic.test.d	6f90ecc99fcd468a
+1	10	1688379947003622761	src/Deser.ast	cd0b25377a211e66
+10	13	1688379947006956132	src/Deser.d	a9b5860301395adf
+13	31	1688379947023622987	src/Deser.cmj	5c89bf2838f6ce97
+13	31	1688379947023622987	src/Deser.cmi	5c89bf2838f6ce97
+13	31	1688379947023622987	../js/src/Deser.js	5c89bf2838f6ce97
+0	12	1688379977457301032	tests/basic.test.ast	b18ba9a9379ce270
+12	15	1688379977460634403	tests/basic.test.d	6f90ecc99fcd468a
+0	10	1688379985814062321	tests/basic.test.ast	b18ba9a9379ce270
+10	13	1688379985814062321	tests/basic.test.d	6f90ecc99fcd468a
+0	14	1688380005404284107	tests/basic.test.ast	b18ba9a9379ce270
+14	17	1688380005404284107	tests/basic.test.d	6f90ecc99fcd468a
+17	29	1688380005404284107	tests/basic.test.cmj	796dce8c08df8f5f
+17	29	1688380005404284107	tests/basic.test.cmi	796dce8c08df8f5f
+17	29	1688380005404284107	../js/tests/basic.test.js	796dce8c08df8f5f
+0	3	1688380455412698631	tests/basic.test.d	e38380efe2655d28
+0	10	1688380455419365372	src/JSON.ast	23930881e232c07e
+10	13	1688380455422698743	src/JSON.d	d00ba87460d947fd
+13	32	1688380455442698969	src/JSON.cmj	e156d0c178c482e3
+13	32	1688380455442698969	src/JSON.cmi	e156d0c178c482e3
+13	32	1688380455442698969	../js/src/JSON.js	e156d0c178c482e3
+0	7	1688380477149610260	tests/basic.test.ast	b18ba9a9379ce270
+7	10	1688380477152943631	tests/basic.test.d	e38380efe2655d28
+10	23	1688380477152943631	tests/basic.test.cmj	796dce8c08df8f5f
+10	23	1688380477152943631	tests/basic.test.cmi	796dce8c08df8f5f
+10	23	1688380477152943631	../js/tests/basic.test.js	796dce8c08df8f5f
+0	7	1688380979805268331	tests/QUnit.ast	ae640b6aefd35348
+0	7	1688380979805268331	tests/index.ast	b5b685b3adc59946
+0	8	1688380979805268331	src/JSON.ast	23930881e232c07e
+7	9	1688380979808601702	tests/QUnit.d	4a2631c992d93ce7
+7	9	1688380979808601702	tests/index.d	5a4db9cdecd186b3
+8	10	1688380979805268331	src/JSON.d	cd2d6773c781340f
+9	18	1688380979815268443	tests/QUnit.cmj	743026e625d40f7c
+9	18	1688380979815268443	tests/QUnit.cmi	743026e625d40f7c
+9	18	1688380979815268443	../js/tests/QUnit.js	743026e625d40f7c
+10	27	1688380979805268331	src/JSON.cmj	a900e769d0db9273
+10	27	1688380979805268331	src/JSON.cmi	a900e769d0db9273
+10	27	1688380979805268331	../js/src/JSON.js	a900e769d0db9273
+27	38	1688380979835268668	tests/index.cmj	a7f18a4fafd85d7d
+27	38	1688380979835268668	tests/index.cmi	a7f18a4fafd85d7d
+27	38	1688380979835268668	../js/tests/index.js	a7f18a4fafd85d7d

package/lib/bs/.sourcedirs.json

@@ -0,0 +1 @@
+{ "dirs" : [ "tests" , "src/" ] , "pkgs" : [ [ "@kaiko.io/rescript-prelude" , "/home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude" ] ] , "generated" : [] }

package/lib/bs/build.ninja

@@ -0,0 +1,27 @@
+rescript = 1
+g_finger := /home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude/lib/ocaml/install.stamp
+rule astj
+  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe  -warn-error +8+11+26+27+33+56 -bs-v 10.1.4  -absname -bs-ast -o $out $i
+o tests/index.ast : astj ../../tests/index.res
+rule deps_dev
+  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsb_helper.exe -g -hash 84aecc33f8594375b23a1a137b057f93 $in
+  restat = 1
+o tests/index.d : deps_dev tests/index.ast
+rule mij_dev
+  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe -I tests -I src/ -I /home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude/lib/ocaml    -warn-error +8+11+26+27+33+56 -bs-package-name @kaiko.io/rescript-deser -bs-package-output commonjs:lib/js/$in_d:.js -bs-v $g_finger $i
+  dyndep = 1
+  restat = 1
+o tests/index.cmj tests/index.cmi ../js/tests/index.js : mij_dev tests/index.ast
+o tests/QUnit.ast : astj ../../tests/QUnit.res
+o tests/QUnit.d : deps_dev tests/QUnit.ast
+o tests/QUnit.cmj tests/QUnit.cmi ../js/tests/QUnit.js : mij_dev tests/QUnit.ast
+o src/JSON.ast : astj ../../src/JSON.res
+rule deps
+  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsb_helper.exe -hash 84aecc33f8594375b23a1a137b057f93 $in
+  restat = 1
+o src/JSON.d : deps src/JSON.ast
+rule mij
+  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe -I src/ -I /home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude/lib/ocaml   -warn-error +8+11+26+27+33+56 -bs-package-name @kaiko.io/rescript-deser -bs-package-output commonjs:lib/js/$in_d:.js -bs-v $g_finger $i
+  dyndep = 1
+  restat = 1
+o src/JSON.cmj src/JSON.cmi ../js/src/JSON.js : mij src/JSON.ast

package/lib/bs/install.ninja

@@ -0,0 +1,10 @@
+rescript = 1
+rule cp
+  command = cp $i $out
+rule touch
+ command = touch $out
+o JSON.cmi : cp ../bs/src/JSON.cmi
+o JSON.cmj : cp ../bs/src/JSON.cmj
+o JSON.cmt : cp ../bs/src/JSON.cmt
+o JSON.res : cp ../../src/JSON.res
+build install.stamp : touch JSON.cmi JSON.cmj 

package/lib/bs/tests/index.d

@@ -0,0 +1 @@
+tests/index.cmj : src/JSON.cmj src/JSON.cmi tests/QUnit.cmj tests/QUnit.cmi

package/lib/js/src/JSON.js

@@ -0,0 +1,627 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Curry = require("rescript/lib/js/curry.js");
+var Js_json = require("rescript/lib/js/js_json.js");
+var Prelude = require("@kaiko.io/rescript-prelude/lib/js/src/Prelude.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var FieldValue = {};
+
+var $$TypeError = /* @__PURE__ */Caml_exceptions.create("JSON.TypeError");
+
+function usingString(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingInt(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingFloat(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingBoolean(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingArray(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingObject(f, value) {
+  return Curry._1(f, value);
+}
+
+function variadicInt(hint, fromJs) {
+  return {
+          TAG: /* Morphism */10,
+          _0: /* Int */2,
+          _1: (function (param) {
+              var internalValue = Curry._1(fromJs, param);
+              if (internalValue !== undefined) {
+                return Caml_option.valFromOption(internalValue);
+              }
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "This Int(" + String(param) + ") not a valid value here. Hint: " + hint + "",
+                    Error: new Error()
+                  };
+            })
+        };
+}
+
+function variadicString(hint, fromJs) {
+  return {
+          TAG: /* Morphism */10,
+          _0: /* String */1,
+          _1: (function (param) {
+              var internalValue = Curry._1(fromJs, param);
+              if (internalValue !== undefined) {
+                return Caml_option.valFromOption(internalValue);
+              }
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "This String(\"" + param + "\") not a valid value here. Hint: " + hint + "",
+                    Error: new Error()
+                  };
+            })
+        };
+}
+
+function toString(type_) {
+  if (typeof type_ === "number") {
+    switch (type_) {
+      case /* Any */0 :
+          return "Any";
+      case /* String */1 :
+          return "String";
+      case /* Int */2 :
+          return "Integer";
+      case /* Float */3 :
+          return "Float";
+      case /* Boolean */4 :
+          return "Boolean";
+      case /* Date */5 :
+      case /* Datetime */6 :
+          return "Date";
+      case /* Self */7 :
+          return "Self (recursive)";
+      
+    }
+  } else {
+    switch (type_.TAG | 0) {
+      case /* Literal */0 :
+          return "Literal: " + type_._0 + "";
+      case /* Array */1 :
+          return "Array of " + toString(type_._0);
+      case /* Tuple */2 :
+          return "Tuple of (" + Curry._2(Prelude.$$Array.map, type_._0, toString).join(", ") + ")";
+      case /* Object */3 :
+          var desc = Curry._2(Prelude.$$Array.map, type_._0, (function (param) {
+                    return "" + param[0] + ": " + toString(param[1]) + "";
+                  })).join(", ");
+          return "Object of {" + desc + "}";
+      case /* Optional */4 :
+      case /* OptionalWithDefault */5 :
+          return "Null of " + toString(type_._0);
+      case /* Mapping */6 :
+          return "Mapping of " + toString(type_._0) + "";
+      case /* Deserializer */7 :
+          return type_._0.name;
+      case /* Collection */8 :
+          return "Collection of " + type_._0.name;
+      case /* DefaultWhenInvalid */9 :
+          return "Protected " + toString(type_._0) + "";
+      case /* Morphism */10 :
+          return toString(type_._0) + " to apply a morphism";
+      
+    }
+  }
+}
+
+function _taggedToString(tagged) {
+  if (typeof tagged === "number") {
+    switch (tagged) {
+      case /* JSONFalse */0 :
+          return "Boolean(false)";
+      case /* JSONTrue */1 :
+          return "Boolean(true)";
+      case /* JSONNull */2 :
+          return "Null";
+      
+    }
+  } else {
+    switch (tagged.TAG | 0) {
+      case /* JSONString */0 :
+          return "String(\"" + tagged._0 + "\")";
+      case /* JSONNumber */1 :
+          return "Number(" + String(tagged._0) + ")";
+      case /* JSONObject */2 :
+          return "Object(" + Prelude.$$default(JSON.stringify(tagged._0), "...") + ")";
+      case /* JSONArray */3 :
+          return "Array(" + Prelude.$$default(JSON.stringify(tagged._0), "...") + ")";
+      
+    }
+  }
+}
+
+function extractValue(values, field, shape, self) {
+  var value = Curry._2(Prelude.Dict.get, values, field);
+  if (value !== undefined) {
+    return fromUntagged(Caml_option.valFromOption(value), shape, self);
+  }
+  if (typeof shape !== "number") {
+    switch (shape.TAG | 0) {
+      case /* OptionalWithDefault */5 :
+          return shape._1;
+      case /* Optional */4 :
+      case /* DefaultWhenInvalid */9 :
+          return fromUntagged(null, shape, self);
+      default:
+        
+    }
+  }
+  throw {
+        RE_EXN_ID: $$TypeError,
+        _1: "Missing non-optional field '" + field + "'",
+        Error: new Error()
+      };
+}
+
+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 === "number") {
+      switch (shape) {
+        case /* Any */0 :
+            return untagged;
+        case /* String */1 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONString */0) {
+                return match._0;
+              }
+              exit = 1;
+            }
+            break;
+        case /* Int */2 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONNumber */1) {
+                return match._0 | 0;
+              }
+              exit = 1;
+            }
+            break;
+        case /* Float */3 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONNumber */1) {
+                return match._0;
+              }
+              exit = 1;
+            }
+            break;
+        case /* Boolean */4 :
+            if (typeof match === "number") {
+              switch (match) {
+                case /* JSONFalse */0 :
+                    return false;
+                case /* JSONTrue */1 :
+                    return true;
+                case /* JSONNull */2 :
+                    exit = 1;
+                    break;
+                
+              }
+            } else {
+              exit = 1;
+            }
+            break;
+        case /* Date */5 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              switch (match.TAG | 0) {
+                case /* JSONString */0 :
+                    s = match._0;
+                    exit = 2;
+                    break;
+                case /* JSONNumber */1 :
+                    f = match._0;
+                    exit = 3;
+                    break;
+                default:
+                  exit = 1;
+              }
+            }
+            break;
+        case /* Datetime */6 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              switch (match.TAG | 0) {
+                case /* JSONString */0 :
+                    s = match._0;
+                    exit = 2;
+                    break;
+                case /* JSONNumber */1 :
+                    f = match._0;
+                    exit = 3;
+                    break;
+                default:
+                  exit = 1;
+              }
+            }
+            break;
+        case /* Self */7 :
+            _shape = self;
+            continue ;
+        
+      }
+    } else {
+      switch (shape.TAG | 0) {
+        case /* Literal */0 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONString */0) {
+                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()
+                    };
+              }
+              exit = 1;
+            }
+            break;
+        case /* Array */1 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONArray */3) {
+                var shape$1 = shape._0;
+                return Curry._2(Prelude.$$Array.map, match._0, (function(shape$1){
+                          return function (item) {
+                            return fromUntagged(item, shape$1, self);
+                          }
+                          }(shape$1)));
+              }
+              exit = 1;
+            }
+            break;
+        case /* Tuple */2 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONArray */3) {
+                var items = match._0;
+                var bases = shape._0;
+                var lenbases = bases.length;
+                var lenitems = items.length;
+                if (lenbases === lenitems) {
+                  return Curry._3(Prelude.$$Array.zipBy, items, bases, (function (i, b) {
+                                return fromUntagged(i, b, self);
+                              }));
+                }
+                throw {
+                      RE_EXN_ID: $$TypeError,
+                      _1: "Expecting " + String(lenbases) + " items, got " + String(lenitems) + "",
+                      Error: new Error()
+                    };
+              }
+              exit = 1;
+            }
+            break;
+        case /* Object */3 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONObject */2) {
+                var values = match._0;
+                return Curry._1(Prelude.Dict.fromArray, Curry._2(Prelude.$$Array.map, shape._0, (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;
+                                }
+                                return [
+                                        field,
+                                        value
+                                      ];
+                              }
+                              }(values))));
+              }
+              exit = 1;
+            }
+            break;
+        case /* Optional */4 :
+            var shape$2 = shape._0;
+            if (typeof match === "number") {
+              if (match >= 2) {
+                return undefined;
+              }
+              _shape = shape$2;
+              continue ;
+            }
+            _shape = shape$2;
+            continue ;
+        case /* OptionalWithDefault */5 :
+            var shape$3 = shape._0;
+            if (typeof match === "number") {
+              if (match >= 2) {
+                return shape._1;
+              }
+              _shape = shape$3;
+              continue ;
+            }
+            _shape = shape$3;
+            continue ;
+        case /* Mapping */6 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONObject */2) {
+                var f$1 = shape._0;
+                return Prelude.Dict.mapValues(match._0, (function(f$1){
+                          return function (v) {
+                            return fromUntagged(v, f$1, self);
+                          }
+                          }(f$1)));
+              }
+              exit = 1;
+            }
+            break;
+        case /* Deserializer */7 :
+            var res = Curry._1(shape._0.fromJSON, untagged);
+            if (res.TAG === /* Ok */0) {
+              return res._0;
+            }
+            throw {
+                  RE_EXN_ID: $$TypeError,
+                  _1: res._0,
+                  Error: new Error()
+                };
+        case /* Collection */8 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONArray */3) {
+                return Curry._2(Prelude.$$Array.map, Prelude.$$Array.keepSome(Curry._2(Prelude.$$Array.map, Curry._2(Prelude.$$Array.map, match._0, shape._0.fromJSON), Prelude.Result.warn)), (function (prim) {
+                              return prim;
+                            }));
+              }
+              exit = 1;
+            }
+            break;
+        case /* DefaultWhenInvalid */9 :
+            try {
+              return fromUntagged(untagged, shape._0, self);
+            }
+            catch (raw_msg){
+              var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
+              if (msg.RE_EXN_ID === $$TypeError) {
+                console.warn("Detected and ignore (with default): ", msg._1);
+                return shape._1;
+              }
+              throw msg;
+            }
+        case /* Morphism */10 :
+            return Curry._1(shape._1, fromUntagged(untagged, shape._0, 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;
+      
+    }
+  };
+}
+
+function checkFieldsSanity(name, _fields, _optional) {
+  while(true) {
+    var optional = _optional;
+    var fields = _fields;
+    var exit = 0;
+    if (typeof fields === "number") {
+      switch (fields) {
+        case /* Any */0 :
+        case /* Boolean */4 :
+        case /* Date */5 :
+        case /* Datetime */6 :
+            return {
+                    TAG: /* Ok */0,
+                    _0: undefined
+                  };
+        case /* Self */7 :
+            if (optional) {
+              return {
+                      TAG: /* Ok */0,
+                      _0: undefined
+                    };
+            } else {
+              return {
+                      TAG: /* Error */1,
+                      _0: "" + name + ": Trivial infinite recursion 'let fields = Self'"
+                    };
+            }
+        default:
+          return {
+                  TAG: /* Ok */0,
+                  _0: undefined
+                };
+      }
+    } else {
+      switch (fields.TAG | 0) {
+        case /* Tuple */2 :
+            return Curry._2(Prelude.ManyResults.map, Prelude.ManyResults.bailU(Curry._2(Prelude.$$Array.mapWithIndex, fields._0, (function(optional){
+                              return function (index, field, param) {
+                                return checkFieldsSanity("" + name + "[" + String(index) + "]", field, optional);
+                              }
+                              }(optional)))), (function (param) {
+                          
+                        }));
+        case /* Object */3 :
+            return Curry._2(Prelude.ManyResults.map, Prelude.ManyResults.bailU(Curry._2(Prelude.$$Array.map, fields._0, (function(optional){
+                              return function (param, param$1) {
+                                return checkFieldsSanity("" + name + "::" + param[0] + "", param[1], optional);
+                              }
+                              }(optional)))), (function (param) {
+                          
+                        }));
+        case /* Array */1 :
+        case /* Mapping */6 :
+            _optional = true;
+            _fields = fields._0;
+            continue ;
+        case /* Deserializer */7 :
+        case /* Collection */8 :
+            exit = 2;
+            break;
+        case /* Optional */4 :
+        case /* OptionalWithDefault */5 :
+        case /* DefaultWhenInvalid */9 :
+            exit = 1;
+            break;
+        case /* Morphism */10 :
+            return {
+                    TAG: /* Ok */0,
+                    _0: undefined
+                  };
+        default:
+          return {
+                  TAG: /* Ok */0,
+                  _0: undefined
+                };
+      }
+    }
+    switch (exit) {
+      case 1 :
+          _optional = true;
+          _fields = fields._0;
+          continue ;
+      case 2 :
+          var msg = Curry._1(fields._0.checkFieldsSanity, undefined);
+          if (msg.TAG === /* Ok */0) {
+            return {
+                    TAG: /* Ok */0,
+                    _0: undefined
+                  };
+          } else {
+            return {
+                    TAG: /* Error */1,
+                    _0: "" + name + "/ " + msg._0 + ""
+                  };
+          }
+      
+    }
+  };
+}
+
+var Field = {
+  usingString: usingString,
+  usingInt: usingInt,
+  usingFloat: usingFloat,
+  usingBoolean: usingBoolean,
+  usingArray: usingArray,
+  usingObject: usingObject,
+  variadicInt: variadicInt,
+  variadicString: variadicString,
+  toString: toString,
+  _taggedToString: _taggedToString,
+  extractValue: extractValue,
+  fromUntagged: fromUntagged,
+  checkFieldsSanity: checkFieldsSanity
+};
+
+function MakeDeserializer(S) {
+  var fields = S.fields;
+  var name = "Deserializer " + "JSON" + ", " + "File \"JSON.res\", line 321, characters 39-47" + "";
+  var checkFieldsSanity$1 = function (param) {
+    return checkFieldsSanity(name, fields, false);
+  };
+  var fromJSON = function (json) {
+    var res;
+    try {
+      res = fromUntagged(json, fields, fields);
+    }
+    catch (raw_e){
+      var e = Caml_js_exceptions.internalToOCamlException(raw_e);
+      if (e.RE_EXN_ID === $$TypeError) {
+        return {
+                TAG: /* Error */1,
+                _0: e._1
+              };
+      }
+      throw e;
+    }
+    return {
+            TAG: /* Ok */0,
+            _0: res
+          };
+  };
+  return {
+          name: name,
+          fromJSON: fromJSON,
+          checkFieldsSanity: checkFieldsSanity$1
+        };
+}
+
+exports.FieldValue = FieldValue;
+exports.$$TypeError = $$TypeError;
+exports.Field = Field;
+exports.MakeDeserializer = MakeDeserializer;
+/* No side effect */

package/lib/js/tests/QUnit.js

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

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 */3,
+  _0: [
+    [
+      "note",
+      /* String */1
+    ],
+    [
+      "date",
+      /* Date */5
+    ],
+    [
+      "extra",
+      {
+        TAG: /* Optional */4,
+        _0: /* String */1
+      }
+    ]
+  ]
+};
+
+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 = Curry._1(Deserializer.fromJSON, data);
+                        if (result.TAG === /* Ok */0) {
+                          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 = Curry._1(Deserializer.fromJSON, data);
+                        if (result.TAG === /* Ok */0) {
+                          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 */3,
+          _0: [
+            [
+              "data",
+              /* Any */0
+            ],
+            [
+              "children",
+              {
+                TAG: /* Array */1,
+                _0: /* Self */7
+              }
+            ]
+          ]
+        };
+        var DeserializerImpl = $$JSON.MakeDeserializer({
+              fields: fields
+            });
+        var checkFieldsSanity = DeserializerImpl.checkFieldsSanity;
+        var fromJSON = function (data) {
+          return Curry._2(Prelude.Result.map, Curry._1(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(Curry._1(checkFieldsSanity, undefined), {
+                      TAG: /* Ok */0,
+                      _0: undefined
+                    }, "Ok");
+              }));
+        Qunit.test("Infinite list", (function (qunit) {
+                var fields = {
+                  TAG: /* Object */3,
+                  _0: [
+                    [
+                      "head",
+                      /* String */1
+                    ],
+                    [
+                      "tail",
+                      /* Self */7
+                    ]
+                  ]
+                };
+                var InfiniteList = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                qunit.expect(1);
+                qunit.deepEqual(Curry._1(Prelude.Result.isError, Curry._1(InfiniteList.checkFieldsSanity, undefined)), true, "Ok");
+              }));
+        Qunit.test("Finite list", (function (qunit) {
+                var fields = {
+                  TAG: /* Object */3,
+                  _0: [
+                    [
+                      "head",
+                      /* String */1
+                    ],
+                    [
+                      "tail",
+                      {
+                        TAG: /* Optional */4,
+                        _0: /* Self */7
+                      }
+                    ]
+                  ]
+                };
+                var List = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                qunit.expect(1);
+                qunit.deepEqual(Curry._1(List.checkFieldsSanity, undefined), {
+                      TAG: /* Ok */0,
+                      _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 */0) {
+                          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 */3,
+                  _0: [
+                    [
+                      "head",
+                      /* String */1
+                    ],
+                    [
+                      "tail",
+                      {
+                        TAG: /* Optional */4,
+                        _0: /* Self */7
+                      }
+                    ]
+                  ]
+                };
+                var List = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                var fields$1 = {
+                  TAG: /* Object */3,
+                  _0: [
+                    [
+                      "records",
+                      {
+                        TAG: /* Deserializer */7,
+                        _0: List
+                      }
+                    ],
+                    [
+                      "next",
+                      {
+                        TAG: /* Optional */4,
+                        _0: /* Self */7
+                      }
+                    ]
+                  ]
+                };
+                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(Curry._1(Ledger.fromJSON, data), {
+                      TAG: /* Ok */0,
+                      _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": "3.0.0",
+  "version": "3.1.1",
   "keywords": [
     "json",
     "deserializer",
@@ -11,12 +11,19 @@
   "author": "Kaiko Systems <info@kaikosystems.com>",
   "license": "MIT",
   "private": false,
+  "files": [
+    "lib",
+    "src",
+    "tests",
+    "www",
+    "README.md"
+  ],
   "dependencies": {
-    "@kaiko.io/rescript-prelude": "^6.0.0"
+    "@kaiko.io/rescript-prelude": "^6.2.1",
+    "rescript": "^10.1.4"
   },
   "devDependencies": {
     "esbuild": "^0.15.7",
-    "qunit": "^2.16.0",
-    "rescript": "^10.1.4"
+    "qunit": "^2.16.0"
   }
 }

package/src/JSON.res

@@ -34,6 +34,7 @@ module Field = {
   type rec t =
     | Any
     | String
+    | Literal(string)
     | Int
     | Float
     | Boolean
@@ -102,6 +103,7 @@ module Field = {
     switch type_ {
     | Any => "Any"
     | String => "String"
+    | Literal(lit) => `Literal: ${lit}`
     | Int => "Integer"
     | Float => "Float"
     | Boolean => "Boolean"
@@ -165,6 +167,12 @@ module 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)
@@ -262,7 +270,7 @@ module Field = {
     | (Self, true) => Ok()
 
     | (Any, _) => Ok()
-    | (String, _) | (Float, _) | (Int, _) => Ok()
+    | (String, _) | (Float, _) | (Int, _) | (Literal(_), _) => Ok()
     | (Boolean, _) | (Date, _) | (Datetime, _) => Ok()
     | (Morphism(_, _), _) => Ok()
 

package/.dir-locals.el

@@ -1,6 +0,0 @@
-;;; Directory Local Variables
-;;; For more information see (info "(emacs) Directory Variables")
-
-( (rescript-mode . ((projectile-project-compilation-cmd . "make compile-rescript")
-                     (indent-tabs-mode . nil)))
-  (nil . ((projectile-project-compilation-cmd . "make compile-rescript"))))

package/.gitlab-ci.yml

@@ -1,52 +0,0 @@
-stages:
-  - compile
-
-.x-compile: &with-compilation-script
-  image: node
-  script:
-    - make compile
-
-.x-when-mr: &when-merge-request
-  interruptible: true
-  only:
-    - merge_requests
-
-.x-when-stable: &when-in-stable
-  only:
-    - main
-
-.x-when-stable-or-mr: &when-stable-or-merging
-  interruptible: true
-  only:
-    - main
-    - merge_requests
-
-lint:
-  <<: *when-stable-or-merging
-  stage: compile
-  image: node
-  tags:
-    - docker
-  script:
-    - |
-      make format
-      touched=$(git status --porcelain | wc -l) || touched=0
-      if [ $touched -gt 0 ]; then
-          git status
-          exit 1
-      fi
-
-check that we can compile the whole thing before merging:
-  <<: *with-compilation-script
-  <<: *when-merge-request
-  stage: compile
-  tags:
-    - docker
-
-compile:
-  <<: *with-compilation-script
-  <<: *when-in-stable
-  interruptible: true
-  stage: compile
-  tags:
-    - docker

package/Makefile

@@ -1,32 +0,0 @@
-PATH := ./node_modules/.bin/:$(PATH)
-
-yarn.lock: bsconfig.json package.json
-	yarn install
-
-compile: yarn.lock
-	@if [ -n "$(INSIDE_EMACS)" ]; then \
-	    NINJA_ANSI_FORCED=0 rescript build -with-deps; \
-	else \
-		rescript build -with-deps; \
-	fi
-
-format: yarn.lock
-	rescript format -all
-
-publish: compile
-	yarn publish --access public
-
-.PHONY: format compile publish
-
-RESCRIPT_FILES := $(shell find src -type f -name '*.res')
-
-compile-rescript: $(RESCRIPT_FILES) yarn.lock
-	@if [ -n "$(INSIDE_EMACS)" ]; then \
-	    NINJA_ANSI_FORCED=0 rescript build -with-deps; \
-	else \
-		rescript build -with-deps; \
-	fi
-
-
-test: compile
-	esbuild lib/js/tests/index.js --bundle --outdir=www --servedir=www --serve=4369

package/bsconfig.json

@@ -1,20 +0,0 @@
-{
-  "name": "@kaiko.io/rescript-deser",
-  "sources": [
-    {
-      "dir": "src/",
-      "subdirs": true
-    },
-    {
-      "dir": "tests",
-      "type": "dev"
-    }
-  ],
-  "suffix": ".js",
-  "bs-dependencies": [
-    "@kaiko.io/rescript-prelude"
-  ],
-  "warnings": {
-    "error": "+8+11+26+27+33+56"
-  }
-}