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

package/README.md

@@ -104,8 +104,7 @@ module type Serializable = {
   `Optional`, `OptionalWithDefault`.
 
 - `Mapping(Field.t)`, parses a JSON object with unknown keys (of type string)
-  and a given type of value.  Valid values have the internal type
-  `Prelude.Dict.t`.
+  and a given type of value.  Valid values have the internal type `dict<_>`.
 
 - `Deserializer(module(Deserializer))`, parses an JSON object with the function
   `fromJSON` of another deserializer.  This allows the composition of
@@ -136,6 +135,18 @@ type rec Node<'t> = Leave('t) | (Branch(array<Node<'t>>)
 Cannot be automatically deserialized.
 
 
+# Type safety disclaimer
+
+`Deser` cannot guarantee type safety for ill-defined deserializers, the following deserializer will accept JSON payloads of the wrong type that can cause runtime type errors:
+
+```rescript
+module X = Deser.MakeDeserializer({
+  type t = string
+  let fields = Deser.Field.Array(Int)
+})
+```
+
+
 ## License
 
 The MIT License

package/lib/bs/.compiler.log

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

package/lib/bs/build.ninja

@@ -1,27 +0,0 @@
-rescript = 1
-g_finger := /home/manu/src/kaiko/rescript-deser/node_modules/@rescript/core/lib/ocaml/install.stamp
-rule astj
-  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe  -warn-error +8+11+26+33+56 -bs-v 11.1.4 -uncurried  -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 9a7a4be86983dcab705bb67a1ec483c7 $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/@rescript/core/lib/ocaml    -warn-error +8+11+26+33+56 -uncurried -bs-package-name @kaiko.io/rescript-deser -bs-package-output commonjs:lib/js/$in_d:.js -bs-package-output esmodule:lib/es6/$in_d:.js -bs-v $g_finger $i
-  dyndep = 1
-  restat = 1
-o tests/index.cmj tests/index.cmi ../es6/tests/index.js ../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 ../es6/tests/QUnit.js ../js/tests/QUnit.js : mij_dev tests/QUnit.ast
-o src/Deser.ast : astj ../../src/Deser.res
-rule deps
-  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsb_helper.exe -hash 9a7a4be86983dcab705bb67a1ec483c7 $in
-  restat = 1
-o src/Deser.d : deps src/Deser.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/@rescript/core/lib/ocaml   -warn-error +8+11+26+33+56 -uncurried -bs-package-name @kaiko.io/rescript-deser -bs-package-output commonjs:lib/js/$in_d:.js -bs-package-output esmodule:lib/es6/$in_d:.js -bs-v $g_finger $i
-  dyndep = 1
-  restat = 1
-o src/Deser.cmj src/Deser.cmi ../es6/src/Deser.js ../js/src/Deser.js : mij src/Deser.ast

package/lib/bs/compiler-info.json

@@ -0,0 +1,8 @@
+{
+  "version": "12.0.1",
+  "bsc_path": "/home/manu/src/kaiko/rescript-deser/node_modules/@rescript/linux-x64/bin/bsc.exe",
+  "bsc_hash": "a2b93197b8c05fc70981fe131a9ed75f8462a9f615f71055f306c9deb058d3cf",
+  "rescript_config_hash": "6e13fe97e162573c9ab73327567294583b34d549775f8391e1d5c8ccc0c5d580",
+  "runtime_path": "/home/manu/src/kaiko/rescript-deser/node_modules/@rescript/runtime",
+  "generated_at": "1766181917582"
+}

package/lib/bs/{___incremental → src}/Deser.res

@@ -1,5 +1,3 @@
-open RescriptCore
-
 module FieldValue = {
   type t
   external string: string => t = "%identity"
@@ -7,8 +5,8 @@ module FieldValue = {
   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 object: dict<t> => t = "%identity"
+  external mapping: dict<t> => t = "%identity"
   external any: 'a => t = "%identity"
   @val external null: t = "undefined"
 
@@ -46,7 +44,6 @@ module Field = {
     // We also allow floats and then use Date.fromTime
     | Date
     | Datetime // alias of Date
-
     | Tuple(array<t>)
     | Object(array<(string, t)>)
     | Optional(t)
@@ -55,21 +52,17 @@ module Field = {
     // 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
@@ -85,7 +78,7 @@ module Field = {
       switch i->fromJs {
       | Some(internalValue) => internalValue
       | None =>
-        raise(TypeError(`This Int(${i->Int.toString}) not a valid value here. Hint: ${hint}`))
+        throw(TypeError(`This Int(${i->Int.toString}) not a valid value here. Hint: ${hint}`))
       }
     }),
   )
@@ -94,7 +87,7 @@ module Field = {
     usingString(i => {
       switch i->fromJs {
       | Some(internalValue) => internalValue
-      | None => raise(TypeError(`This String("${i}") not a valid value here. Hint: ${hint}`))
+      | None => throw(TypeError(`This String("${i}") not a valid value here. Hint: ${hint}`))
       }
     }),
   )
@@ -147,12 +140,7 @@ module Field = {
     }
   }
 
-  let rec extractValue = (
-    values: Dict.t<JSON.t>,
-    field: string,
-    shape: t,
-    self: t,
-  ): FieldValue.t => {
+  let rec extractValue = (values: dict<JSON.t>, field: string, shape: t, self: t): FieldValue.t => {
     switch values->Dict.get(field) {
     | Some(value) => value->fromUntagged(shape, self)
     | None =>
@@ -160,7 +148,7 @@ module Field = {
       | DefaultWhenInvalid(_, _) => JSON.Null->fromUntagged(shape, self)
       | Optional(_) => JSON.Null->fromUntagged(shape, self)
       | OptionalWithDefault(_, default) => default
-      | _ => raise(TypeError(`Missing non-optional field '${field}'`))
+      | _ => throw(TypeError(`Missing non-optional field '${field}'`))
       }
     }
   }
@@ -170,7 +158,7 @@ module Field = {
 
     | (Literal(expected), String(text)) if text == expected => FieldValue.string(text)
     | (Literal(expected), String(text)) =>
-      raise(TypeError(`Expecting literal ${expected}, got ${text}`))
+      throw(TypeError(`Expecting literal ${expected}, got ${text}`))
 
     | (String, String(text)) => FieldValue.string(text)
 
@@ -187,7 +175,7 @@ module Field = {
           let values = Belt.Array.zipBy(items, bases, (i, b) => fromUntagged(i, b, self))
           values->FieldValue.array
         } else {
-          raise(
+          throw(
             TypeError(`Expecting ${lenbases->Int.toString} items, got ${lenitems->Int.toString}`),
           )
         }
@@ -196,14 +184,14 @@ module Field = {
     | (Datetime | Date, String(s)) =>
       let r = Date.fromString(s)
       if r->Date.getDate->Int.toFloat->Float.isNaN {
-        raise(TypeError(`Invalid date ${s}`))
+        throw(TypeError(`Invalid date ${s}`))
       }
       r->FieldValue.any
 
     | (Datetime | Date, Number(f)) =>
       let r = Date.fromTime(f)
       if r->Date.getDate->Int.toFloat->Float.isNaN {
-        raise(TypeError(`Invalid date ${f->Float.toString}`))
+        throw(TypeError(`Invalid date ${f->Float.toString}`))
       }
       r->FieldValue.any
 
@@ -218,7 +206,7 @@ module Field = {
       ->Array.map(((field, shape)) => {
         let value = switch extractValue(values, field, shape, self) {
         | value => value
-        | exception TypeError(msg) => raise(TypeError(`Field "${field}": ${msg}`))
+        | exception TypeError(msg) => throw(TypeError(`Field "${field}": ${msg}`))
         }
         (field, value)
       })
@@ -251,7 +239,7 @@ module Field = {
         module M = unpack(m: Deserializer)
         switch untagged->M.fromJSON {
         | Ok(res) => res->FieldValue.any
-        | Error(msg) => raise(TypeError(msg))
+        | Error(msg) => throw(TypeError(msg))
         }
       }
 
@@ -265,7 +253,7 @@ module Field = {
       }
     | (Self, _) => untagged->fromUntagged(self, self)
     | (expected, actual) =>
-      raise(TypeError(`Expected ${expected->toString}, but got ${actual->_taggedToString} instead`))
+      throw(TypeError(`Expected ${expected->toString}, but got ${actual->_taggedToString} instead`))
     }
   }
 
@@ -295,8 +283,9 @@ module Field = {
 
     | (Object(fields), optional) =>
       fields
-      ->Array.map(((fieldName, field)) => () =>
-        checkFieldsSanity(`${name}::${fieldName}`, field, optional))
+      ->Array.map(((fieldName, field)) =>
+        () => checkFieldsSanity(`${name}::${fieldName}`, field, optional)
+      )
       ->Array.reduce(Ok([]), (res, nextitem) =>
         res->Result.flatMap(arr => nextitem()->Result.map(i => arr->Array.concat([i])))
       )
@@ -308,8 +297,9 @@ module Field = {
 
     | (Tuple(fields), optional) =>
       fields
-      ->Array.mapWithIndex((field, index) => () =>
-        checkFieldsSanity(`${name}[${index->Int.toString}]`, field, optional))
+      ->Array.mapWithIndex((field, index) =>
+        () => checkFieldsSanity(`${name}[${index->Int.toString}]`, field, optional)
+      )
       ->Array.reduce(Ok([]), (res, nextitem) =>
         res->Result.flatMap(arr => nextitem()->Result.map(i => arr->Array.concat([i])))
       )

package/lib/bs/tests/QUnit.res

@@ -0,0 +1,72 @@
+type description = string
+type message = string
+
+type result<'a> = {
+  result: bool,
+  actual: 'a,
+  expected: 'a,
+  message: string,
+}
+
+type assertion
+type block = assertion => unit
+type matcher<'a> = 'a => bool
+
+// Library stuff
+
+@scope("QUnit") external start: unit => unit = "start"
+@scope("QUnit") external done: (unit => unit) => unit = "done"
+
+@send external expect: (assertion, int) => unit = "expect"
+@send external pushResult: (assertion, result<'a>) => unit = "notOk"
+@send external step: (assertion, description) => unit = "step"
+@send external verifySteps: (assertion, array<description>) => unit = "verifySteps"
+
+// Values
+
+@send external equal: (assertion, 'a, 'a, description) => unit = "equal"
+@send external notEqual: (assertion, 'a, 'a, description) => unit = "notEqual"
+
+@send external isFalse: (assertion, 'a, description) => unit = "false"
+@send external isTrue: (assertion, 'a, description) => unit = "true"
+
+@send external deepEqual: (assertion, 'a, 'a, description) => unit = "deepEqual"
+@send external notDeepEqual: (assertion, 'a, 'a, description) => unit = "notDeepEqual"
+
+@send external strictEqual: (assertion, 'a, 'a, description) => unit = "strictEqual"
+@send external notStrictEqual: (assertion, 'a, 'a, description) => unit = "notStrictEqual"
+
+@send external ok: (assertion, 'a, 'a) => unit = "ok"
+@send external notOk: (assertion, 'a, 'a) => unit = "notOk"
+
+@send external propEqual: (assertion, 'a, 'a) => unit = "propEqual"
+@send external notPropEqual: (assertion, 'a, 'a) => unit = "notPropEqual"
+
+// Promises
+
+type done = unit => unit
+
+@send external async: assertion => done = "async"
+@send external asyncMany: (assertion, int) => done = "async"
+@send external rejects: (assertion, promise<'a>, message) => unit = "rejects"
+@send external rejectsM: (assertion, promise<'a>, message) => unit = "rejects"
+@send
+external rejectMatches: (assertion, promise<'a>, matcher<'a>, message) => unit = "rejects"
+@send
+external rejectMatchesM: (assertion, promise<'a>, matcher<'a>, message) => unit = "rejects"
+@send external timeout: (assertion, int) => unit = "timeout"
+
+// Exceptions
+
+@send external throws: (assertion, block, message) => unit = "throws"
+@send
+external throwMatches: (assertion, block, matcher<'a>, message) => unit = "throws"
+
+type hooks
+@send external before: (hooks, block) => unit = "before"
+@send external beforeEach: (hooks, block) => unit = "beforeEach"
+@send external afterEach: (hooks, block) => unit = "afterEach"
+@send external after: (hooks, block) => unit = "after"
+
+@module("qunit") @val external module_: (description, hooks => unit) => unit = "module"
+@module("qunit") @val external test: (description, block) => unit = "test"

package/lib/bs/{___incremental → tests}/index.res

@@ -1,5 +1,4 @@
 open QUnit
-open RescriptCore
 
 module Appointment = {
   type t = {
@@ -187,3 +186,27 @@ module_("Recursive deserializer", _ => {
     qunit->deepEqual(data->Ledger.fromJSON->Obj.magic, Ok(expected), "nice ledger")
   })
 })
+
+module_("Type safety limits", _ => {
+  test("ill-defined deserializer can cheat the type system", qunit => {
+    module X = Deser.MakeDeserializer({
+      type t = string
+      let fields = Deser.Field.Array(Int)
+    })
+
+    let data = %raw("[1]")
+    qunit->throws(
+      _ => {
+        let illString = data->X.fromJSON->Result.getOr("")
+        try {
+          Console.info3(__MODULE__, "This will fail with a type error", illString->String.charAt(0))
+        } catch {
+        | e =>
+          Console.error(e)
+          throw(e)
+        }
+      },
+      "Expected: TypeError: illString.charAt is not a function",
+    )
+  })
+})