@greenlabs/ppx-spice 0.2.8 → 0.3.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # CHANGELOG
 
+## 0.3.0
+
+- BREAKING: changes to support rescript v12, will now generate codecs that use Stdlib instead of Js or Belt.
+- Updates codec generation to handle the `result` type in addition to `Belt.Result.t`
+- Polyvariant codecs no longer have an intermediate `Js.Json.tagged` type / function calls.
+
+## 0.2.9
+
+- Update test project for compiler v12. https://github.com/green-labs/ppx_spice/pull/94
+- Fix bigint codec on rescript v12. https://github.com/green-labs/ppx_spice/pull/93
+
 ## 0.2.8
 
 - Dropped support for curried mode in accordance with compiler v12 changes.
@@ -33,7 +44,7 @@
 ## 0.2.1
 
 - a190663 Utilize Js.Json.Boolean(bool) instead oif Js.Json.True, False https://github.com/green-labs/ppx_spice/pull/58
-- a190663 Add support of uncurried mode for interface(*.resi) https://github.com/green-labs/ppx_spice/pull/58
+- a190663 Add support of uncurried mode for interface(\*.resi) https://github.com/green-labs/ppx_spice/pull/58
 - Support the compiler v11-rc.5 https://github.com/green-labs/ppx_spice/pull/61
 - Add the feature of encoding/decoding between the number and (polymorphic)variant with `@spice.as` https://github.com/green-labs/ppx_spice/pull/64
 - Fix generating encode, decode function when `@spice.as` with number https://github.com/green-labs/ppx_spice/pull/74

package/README.md

@@ -128,11 +128,13 @@ Read our [Guide with examples](docs/GUIDE.md)
 
 ### Compatibility on the compiler versions
 
-| Compiler | Ppx_spice                    |
-| -------- | ---------------------------- |
-| v12      | v0.2.3 >=                    | 
-| v11      | v0.2.2 >= && > v0.2.0        |
-| v10      | v0.2.0 >=                    |
+| Compiler      | Ppx_spice             | Note                          |
+| ------------- | --------------------- | ----------------------------- |
+| v12-alpha.14  | v0.2.9 >=             | Bigint.fromFloat type changed |
+| v12-alpha.5   | v0.2.8                | Curried mode deprecated       |
+| v12-alpha.4   | v0.2.7 >= && > v0.2.2 |                               |
+| v11           | v0.2.2 >= && > v0.2.0 |                               |
+| v10           | v0.2.0 >=             |                               |
 
 NOTE: Starting from v0.2.8, support for curried mode is discontinued to align with the changes in compiler v12.
 

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@greenlabs/ppx-spice",
-  "version": "0.2.8",
+  "version": "0.3.0-next.0",
+  "packageManager": "yarn@1.22.22",
   "description": "ReScript PPX which generate JSON (de)serializer",
   "license": "MIT",
   "author": "Greenlabs Dev <developer@greenlabs.co.kr>",
@@ -19,6 +20,7 @@
     "postinstall": "node ./postInstall.js"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.26.2"
+    "@changesets/cli": "^2.26.2",
+    "rescript": "^12.0.0"
   }
-}
+}

package/rescript.json

@@ -3,20 +3,16 @@
   "sources": [
     {
       "dir": "src",
-      "subdirs": [
-        "rescript"
-      ]
+      "subdirs": ["rescript"]
     },
     {
       "dir": "test",
       "type": "dev"
     }
   ],
-  "ppx-flags": [
-    "./ppx"
-  ],
+  "ppx-flags": ["./ppx"],
   "warnings": {
     "number": "+A-9-40-42"
   },
   "bsc-flags": []
-}
+}

package/src/rescript/Spice.res

@@ -1,12 +1,12 @@
 type decodeError = {
   path: string,
   message: string,
-  value: Js.Json.t,
+  value: JSON.t,
 }
 
 type result<'a> = result<'a, decodeError>
-type decoder<'a> = Js.Json.t => result<'a>
-type encoder<'a> = 'a => Js.Json.t
+type decoder<'a> = JSON.t => result<'a>
+type encoder<'a> = 'a => JSON.t
 type codec<'a> = (encoder<'a>, decoder<'a>)
 
 let error = (~path=?, message, value) => {
@@ -17,149 +17,154 @@ let error = (~path=?, message, value) => {
   Error({path, message, value})
 }
 
-let stringToJson = (s): Js.Json.t => Js.Json.String(s)
+let stringToJson = (s): JSON.t => JSON.String(s)
 let stringFromJson = j =>
-  switch (j: Js.Json.t) {
-  | Js.Json.String(s) => Ok(s)
+  switch (j: JSON.t) {
+  | JSON.String(s) => Ok(s)
   | _ => Error({path: "", message: "Not a string", value: j})
   }
 
-let intToJson = (i): Js.Json.t => Js.Json.Number(Float.fromInt(i))
+let intToJson = (i): JSON.t => JSON.Number(Float.fromInt(i))
 let intFromJson = j =>
-  switch (j: Js.Json.t) {
-  | Js.Json.Number(f) =>
-    Float.fromInt(Js.Math.floor(f)) == f
-      ? Ok(Js.Math.floor(f))
+  switch (j: JSON.t) {
+  | JSON.Number(f) =>
+    Math.floor(f) == f
+      ? Ok(Math.Int.floor(f))
       : Error({path: "", message: "Not an integer", value: j})
 
   | _ => Error({path: "", message: "Not a number", value: j})
   }
 
-let bigintToJson = (i): Js.Json.t => Js.Json.Number(BigInt.toFloat(i))
+let bigintToJson = (i): JSON.t => JSON.Number(BigInt.toFloat(i))
 
 let bigintFromJson = j =>
-  switch (j: Js.Json.t) {
-  | Js.Json.Number(n) => Ok(BigInt.fromFloat(n))
+  switch (j: JSON.t) {
+  | JSON.Number(n) =>
+    switch BigInt.fromFloat(n) {
+    | Some(v) => v->Ok
+    | None => error("Not a bigint", j)
+    }
   | _ => error("Not a number", j)
   }
 
-let floatToJson = (v): Js.Json.t => Js.Json.Number(v)
+let floatToJson = (v): JSON.t => JSON.Number(v)
 let floatFromJson = j =>
-  switch (j: Js.Json.t) {
-  | Js.Json.Number(f) => Ok(f)
+  switch (j: JSON.t) {
+  | JSON.Number(f) => Ok(f)
   | _ => Error({path: "", message: "Not a number", value: j})
   }
 
-let boolToJson = (v): Js.Json.t =>
+let boolToJson = (v): JSON.t =>
   switch v {
-  | true => Js.Json.Boolean(true)
-  | false => Js.Json.Boolean(false)
+  | true => JSON.Boolean(true)
+  | false => JSON.Boolean(false)
   }
 let boolFromJson = j =>
-  switch (j: Js.Json.t) {
-  | Js.Json.Boolean(true) => Ok(true)
-  | Js.Json.Boolean(false) => Ok(false)
+  switch (j: JSON.t) {
+  | JSON.Boolean(true) => Ok(true)
+  | JSON.Boolean(false) => Ok(false)
   | _ => Error({path: "", message: "Not a boolean", value: j})
   }
 
-let unitToJson = (): Js.Json.t => Js.Json.Number(0.0)
+let unitToJson = (): JSON.t => JSON.Number(0.0)
 let unitFromJson = _ => Ok()
 
-let arrayToJson = (encoder, arr): Js.Json.t => Js.Json.Array(Js.Array.map(encoder, arr))
+let arrayToJson = (encoder, arr): JSON.t => JSON.Array(Array.map(arr, encoder))
 
 let arrayFromJson = (decoder, json) =>
-  switch (json: Js.Json.t) {
-  | Js.Json.Array(arr) => Js.Array.reducei((acc, jsonI, i) =>
+  switch (json: JSON.t) {
+  | JSON.Array(arr) =>
+    Array.reduceWithIndex(arr, Ok([]), (acc, jsonI, i) =>
       switch (acc, decoder(jsonI)) {
       | (Error(_), _) => acc
 
       | (_, Error({path} as error)) =>
         Error({...error, path: "[" ++ (Int.toString(i) ++ ("]" ++ path))})
 
-      | (Ok(prev), Ok(newVal)) =>
-        Ok(Js.Array.concat([newVal], prev))
+      | (Ok(prev), Ok(newVal)) => Ok(Array.concat([newVal], prev))
       }
-    , Ok([]), arr)
+    )
 
   | _ => Error({path: "", message: "Not an array", value: json})
   }
 
-let listToJson = (encoder, list) => arrayToJson(encoder, Belt.List.toArray(list))
+let listToJson = (encoder, list) => arrayToJson(encoder, List.toArray(list))
 
-let listFromJson = (decoder, json) =>
-  Belt.Result.map(arrayFromJson(decoder, json), Belt.List.fromArray)
+let listFromJson = (decoder, json) => Result.map(arrayFromJson(decoder, json), List.fromArray)
 
 let filterOptional = arr =>
-  Belt.Array.keepMap(arr, ((k, v)) => switch v {
+  Array.filterMap(arr, ((k, v)) =>
+    switch v {
     | Some(v) => Some(k, v)
     | None => None
-  })
+    }
+  )
 
-let optionToJson = (encoder, opt): option<Js.Json.t> =>
+let optionToJson = (encoder, opt): option<JSON.t> =>
   switch opt {
   | Some(x) => Some(encoder(x))
   | None => None
   }
 
 let optionFromJson = (decoder, json) =>
-  switch (json: Js.Json.t) {
-  | Js.Json.Null => Ok(None)
-  | _ => Belt.Result.map(decoder(json), v => Some(v))
+  switch (json: JSON.t) {
+  | JSON.Null => Ok(None)
+  | _ => Result.map(decoder(json), v => Some(v))
   }
 
-let nullToJson = (encoder, opt): Js.Json.t =>
+let nullToJson = (encoder, opt): JSON.t =>
   switch opt {
-  | Js.Null.Value(x) => encoder(x)
-  | Null => Js.Json.Null
+  | Null.Value(x) => encoder(x)
+  | Null => JSON.Null
   }
 
 let nullFromJson = (decoder, json) =>
-  switch (json: Js.Json.t) {
-  | Js.Json.Null => Ok(Js.Null.Null)
-  | _ => Belt.Result.map(decoder(json), v => Js.Null.Value(v))
+  switch (json: JSON.t) {
+  | JSON.Null => Ok(Null.Null)
+  | _ => Result.map(decoder(json), v => Null.Value(v))
   }
 
-let resultToJson = (okEncoder, errorEncoder, result): Js.Json.t => Js.Json.Array(
+let resultToJson = (okEncoder, errorEncoder, result): JSON.t => JSON.Array(
   switch result {
-  | Ok(v) => [Js.Json.String("Ok"), okEncoder(v)]
-  | Error(e) => [Js.Json.String("Error"), errorEncoder(e)]
+  | Ok(v) => [JSON.String("Ok"), okEncoder(v)]
+  | Error(e) => [JSON.String("Error"), errorEncoder(e)]
   },
 )
 
 let resultFromJson = (okDecoder, errorDecoder, json) =>
-  switch (json: Js.Json.t) {
-  | Js.Json.Array([variantConstructorId, payload]) =>
+  switch (json: JSON.t) {
+  | JSON.Array([variantConstructorId, payload]) =>
     switch variantConstructorId {
-    | Js.Json.String("Ok") => okDecoder(payload)->Belt.Result.map(v => Ok(v))
+    | JSON.String("Ok") => okDecoder(payload)->Result.map(v => Ok(v))
 
-    | Js.Json.String("Error") =>
+    | JSON.String("Error") =>
       switch errorDecoder(payload) {
       | Ok(v) => Ok(Error(v))
       | Error(e) => Error(e)
       }
 
-    | Js.Json.String(_) => error("Expected either \"Ok\" or \"Error\"", variantConstructorId)
+    | JSON.String(_) => error("Expected either \"Ok\" or \"Error\"", variantConstructorId)
     | _ => error("Not a string", variantConstructorId)
     }
-  | Js.Json.Array(_) => error("Expected exactly 2 values in array", json)
+  | JSON.Array(_) => error("Expected exactly 2 values in array", json)
   | _ => error("Not an array", json)
   }
 
-let dictToJson = (encoder, dict): Js.Json.t => Js.Json.Object(Js.Dict.map((. a) => encoder(a), dict))
+let dictToJson = (encoder, dict): JSON.t => JSON.Object(Dict.mapValues(dict, encoder))
 
 let dictFromJson = (decoder, json) =>
-  switch (json: Js.Json.t) {
-  | Js.Json.Object(dict) =>
+  switch (json: JSON.t) {
+  | JSON.Object(dict) =>
     dict
-    ->Js.Dict.entries
-    ->Belt.Array.reduce(Ok(Js.Dict.empty()), (acc, (key, value)) =>
+    ->Dict.toArray
+    ->Array.reduce(Ok(Dict.make()), (acc, (key, value)) =>
       switch (acc, decoder(value)) {
       | (Error(_), _) => acc
 
       | (_, Error({path} as error)) => Error({...error, path: "." ++ (key ++ path)})
 
       | (Ok(prev), Ok(newVal)) =>
-        let () = prev->Js.Dict.set(key, newVal)
+        let () = prev->Dict.set(key, newVal)
         Ok(prev)
       }
     )

package/src/rescript/Spice_Codecs.res

@@ -1,12 +1,12 @@
 let falseableEncode = (encoder, opt) =>
   switch opt {
-  | None => Js.Json.Boolean(false)
+  | None => JSON.Boolean(false)
   | Some(v) => encoder(v)
   }
 let falseableDecode = (decoder, json) =>
   switch json {
-  | Js.Json.Boolean(false) => Ok(None)
-  | _ => Belt.Result.map(decoder(json), v => Some(v))
+  | JSON.Boolean(false) => Ok(None)
+  | _ => Result.map(decoder(json), v => Some(v))
   }
 let falseable = (falseableEncode, falseableDecode)