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

package/rescript.json

@@ -10,16 +10,14 @@
       "type": "dev"
     }
   ],
-  "bs-dependencies": [
-    "@rescript/core"
-  ],
-  "uncurried": true,
   "package-specs": [
     {
-      "module": "esmodule"
+      "module": "esmodule",
+      "in-source": false
     },
     {
-      "module": "commonjs"
+      "module": "commonjs",
+      "in-source": false
     }
   ],
   "warnings": {

package/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/tests/QUnit.res

@@ -48,12 +48,12 @@ type done = unit => unit
 
 @send external async: assertion => done = "async"
 @send external asyncMany: (assertion, int) => done = "async"
-@send external rejects: (assertion, Js.Promise.t<'a>, message) => unit = "rejects"
-@send external rejectsM: (assertion, Js.Promise.t<'a>, message) => unit = "rejects"
+@send external rejects: (assertion, promise<'a>, message) => unit = "rejects"
+@send external rejectsM: (assertion, promise<'a>, message) => unit = "rejects"
 @send
-external rejectMatches: (assertion, Js.Promise.t<'a>, matcher<'a>, message) => unit = "rejects"
+external rejectMatches: (assertion, promise<'a>, matcher<'a>, message) => unit = "rejects"
 @send
-external rejectMatchesM: (assertion, Js.Promise.t<'a>, matcher<'a>, message) => unit = "rejects"
+external rejectMatchesM: (assertion, promise<'a>, matcher<'a>, message) => unit = "rejects"
 @send external timeout: (assertion, int) => unit = "timeout"
 
 // Exceptions

package/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",
+    )
+  })
+})