@greenlabs/ppx-spice 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+# 0.1.8
+
+- Fix type error where using tuple constructor type, such as `array<int>` for optional field in the record. https://github.com/green-labs/ppx_spice/pull/32
+
 # 0.1.7
 
 #### :rocket: New Feature

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@greenlabs/ppx-spice",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "ReScript PPX which generate JSON (de)serializer",
   "license": "MIT",
   "author": "Greenlabs Dev <developer@greenlabs.co.kr>",

package/src/ppx/codecs.ml

@@ -75,8 +75,7 @@ and generate_constr_codecs { do_encode; do_decode }
       )
   | Lapply (_, _) -> fail loc "Lapply syntax not yet handled by spice"
 
-and generate_codecs ?(is_optional = false)
-    ({ do_encode; do_decode } as generator_settings)
+and generate_codecs ({ do_encode; do_decode } as generator_settings)
     { ptyp_desc; ptyp_loc; ptyp_attributes } =
   match ptyp_desc with
   | Ptyp_any -> fail ptyp_loc "Can't generate codecs for `any` type"
@@ -85,7 +84,7 @@ and generate_codecs ?(is_optional = false)
   | Ptyp_package _ -> fail ptyp_loc "Can't generate codecs for module type"
   | Ptyp_tuple types ->
       let composite_codecs =
-        List.map (generate_codecs ~is_optional generator_settings) types
+        List.map (generate_codecs generator_settings) types
       in
       ( some_if_true do_encode
           (composite_codecs
@@ -115,15 +114,6 @@ and generate_codecs ?(is_optional = false)
                   d] )
         | Error s -> fail ptyp_loc s
       in
-      let encode, decode =
-        if is_optional then
-          match (encode, decode) with
-          | Some encode, Some decode ->
-              ( Some [%expr Spice.optionToJson [%e encode]],
-                Some [%expr Spice.optionFromJson [%e decode]] )
-          | _ -> (encode, decode)
-        else (encode, decode)
-      in
       match List.length typeArgs = 0 with
       | true -> (encode, decode)
       | false -> parameterize_codecs typeArgs encode decode generator_settings)

package/src/ppx/records.ml

@@ -136,12 +136,22 @@ let parse_decl generator_settings
     |> List.map (fun attr -> get_attribute_by_name pld_attributes attr)
     |> List.exists (function Ok (Some _) -> true | _ -> false)
   in
+  let codecs = Codecs.generate_codecs generator_settings pld_type in
+  let codecs =
+    if is_optional then
+      match codecs with
+      | Some encode, Some decode ->
+          ( Some [%expr Spice.optionToJson [%e encode]],
+            Some [%expr Spice.optionFromJson [%e decode]] )
+      | _ -> codecs
+    else codecs
+  in
 
   {
     name = txt;
     key;
     field = Exp.field [%expr v] (lid txt);
-    codecs = Codecs.generate_codecs ~is_optional generator_settings pld_type;
+    codecs;
     default;
     is_optional;
   }

package/src/ppx_spice.opam

@@ -1,6 +1,6 @@
 opam-version: "2.0"
 name: "ppx_spice"
-version: "0.1.7"
+version: "0.1.8"
 synopsis: "ReScript PPX which generate JSON (de)serializer"
 description: """
 ReScript PPX which generate JSON (de)serializer

package/test/__tests__/test_optional_field_records.js

@@ -0,0 +1,91 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Jest = require("@glennsl/bs-jest/src/jest.js");
+var OptionalFieldRecords = require("../src/OptionalFieldRecords.js");
+
+Jest.describe("optional field record", (function (param) {
+        var sample = {};
+        sample["a"] = 1;
+        sample["b"] = 1;
+        var sampleRecord = {
+          a: 1,
+          b: 1
+        };
+        Jest.test("encode", (function (param) {
+                var encoded = OptionalFieldRecords.t0_encode(sampleRecord);
+                return Jest.Expect.toEqual(sample, Jest.Expect.expect(encoded));
+              }));
+        Jest.test("decode", (function (param) {
+                var decoded = OptionalFieldRecords.t0_decode(sample);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord
+                          }, Jest.Expect.expect(decoded));
+              }));
+      }));
+
+Jest.describe("optional field record: array<int>", (function (param) {
+        var sample = {};
+        sample["a"] = 1;
+        sample["bs"] = [1];
+        var sampleRecord_bs = [1];
+        var sampleRecord = {
+          a: 1,
+          bs: sampleRecord_bs
+        };
+        Jest.test("encode", (function (param) {
+                var encoded = OptionalFieldRecords.t1_encode(sampleRecord);
+                return Jest.Expect.toEqual(sample, Jest.Expect.expect(encoded));
+              }));
+        Jest.test("decode", (function (param) {
+                var decoded = OptionalFieldRecords.t1_decode(sample);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord
+                          }, Jest.Expect.expect(decoded));
+              }));
+      }));
+
+Jest.describe("optional field record: array<variant>", (function (param) {
+        var sample = {};
+        sample["a"] = 1;
+        sample["bs"] = ["B1"];
+        var sampleRecord_bs = [/* B1 */1];
+        var sampleRecord = {
+          a: 1,
+          bs: sampleRecord_bs
+        };
+        Jest.test("encode", (function (param) {
+                var encoded = OptionalFieldRecords.t2_encode(sampleRecord);
+                return Jest.Expect.toEqual(sample, Jest.Expect.expect(encoded));
+              }));
+        Jest.test("decode", (function (param) {
+                var decoded = OptionalFieldRecords.t2_decode(sample);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord
+                          }, Jest.Expect.expect(decoded));
+              }));
+      }));
+
+Jest.describe("optional field record: omit array<variant>", (function (param) {
+        var sample = {};
+        sample["a"] = 1;
+        var sampleRecord = {
+          a: 1
+        };
+        Jest.test("encode", (function (param) {
+                var encoded = OptionalFieldRecords.t2_encode(sampleRecord);
+                return Jest.Expect.toEqual(sample, Jest.Expect.expect(encoded));
+              }));
+        Jest.test("decode", (function (param) {
+                var decoded = OptionalFieldRecords.t2_decode(sample);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord
+                          }, Jest.Expect.expect(decoded));
+              }));
+      }));
+
+/*  Not a pure module */

package/test/__tests__/test_optional_field_records.res

@@ -0,0 +1,98 @@
+open Jest
+open Expect
+// open Belt
+
+describe("optional field record", _ => {
+  open OptionalFieldRecords
+
+  let sample = Js.Dict.empty()
+  sample->Js.Dict.set("a", Js.Json.number(1.))
+  sample->Js.Dict.set("b", Js.Json.number(1.))
+  let sampleJson = sample->Js.Json.object_
+
+  let sampleRecord: t0 = {
+    a: 1,
+    b: 1,
+  }
+
+  test(`encode`, _ => {
+    let encoded = sampleRecord->t0_encode
+    expect(encoded) |> toEqual(sampleJson)
+  })
+
+  test(`decode`, _ => {
+    let decoded = sampleJson->t0_decode
+    expect(decoded) |> toEqual(Belt.Result.Ok(sampleRecord))
+  })
+})
+
+describe("optional field record: array<int>", _ => {
+  open OptionalFieldRecords
+
+  let sample = Js.Dict.empty()
+  sample->Js.Dict.set("a", Js.Json.number(1.))
+  sample->Js.Dict.set("bs", Js.Json.array([Js.Json.number(1.)]))
+  let sampleJson = sample->Js.Json.object_
+
+  let sampleRecord: t1 = {
+    a: 1,
+    bs: [1],
+  }
+
+  test(`encode`, _ => {
+    let encoded = sampleRecord->t1_encode
+    expect(encoded) |> toEqual(sampleJson)
+  })
+
+  test(`decode`, _ => {
+    let decoded = sampleJson->t1_decode
+    expect(decoded) |> toEqual(Belt.Result.Ok(sampleRecord))
+  })
+})
+
+describe("optional field record: array<variant>", _ => {
+  open OptionalFieldRecords
+
+  let sample = Js.Dict.empty()
+  sample->Js.Dict.set("a", Js.Json.number(1.))
+  sample->Js.Dict.set("bs", Js.Json.array([Js.Json.string("B1")]))
+  let sampleJson = sample->Js.Json.object_
+
+  let sampleRecord: t2 = {
+    a: 1,
+    bs: [B1],
+  }
+
+  test(`encode`, _ => {
+    let encoded = sampleRecord->t2_encode
+    expect(encoded) |> toEqual(sampleJson)
+  })
+
+  test(`decode`, _ => {
+    let decoded = sampleJson->t2_decode
+    expect(decoded) |> toEqual(Belt.Result.Ok(sampleRecord))
+  })
+})
+
+describe("optional field record: omit array<variant>", _ => {
+  open OptionalFieldRecords
+
+  let sample = Js.Dict.empty()
+  sample->Js.Dict.set("a", Js.Json.number(1.))
+
+  let sampleJson = sample->Js.Json.object_
+
+  let sampleRecord: t2 = {
+    a: 1,
+  }
+
+  test(`encode`, _ => {
+    let encoded = sampleRecord->t2_encode
+    expect(encoded) |> toEqual(sampleJson)
+  })
+
+  test(`decode`, _ => {
+    let decoded = sampleJson->t2_decode
+    expect(decoded) |> toEqual(Belt.Result.Ok(sampleRecord))
+  })
+})

package/test/src/OptionalFieldRecords.js

@@ -0,0 +1,237 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Spice = require("./Spice.js");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Js_json = require("rescript/lib/js/js_json.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+
+function t0_encode(v) {
+  return Js_dict.fromArray(Spice.filterOptional([
+                  [
+                    "a",
+                    false,
+                    Spice.intToJson(v.a)
+                  ],
+                  [
+                    "b",
+                    true,
+                    Spice.optionToJson(Spice.intToJson, v.b)
+                  ]
+                ]));
+}
+
+function t0_decode(v) {
+  var dict = Js_json.classify(v);
+  if (typeof dict === "number") {
+    return Spice.error(undefined, "Not an object", v);
+  }
+  if (dict.TAG !== /* JSONObject */2) {
+    return Spice.error(undefined, "Not an object", v);
+  }
+  var dict$1 = dict._0;
+  var a = Spice.intFromJson(Belt_Option.getWithDefault(Js_dict.get(dict$1, "a"), null));
+  if (a.TAG === /* Ok */0) {
+    var b = Spice.optionFromJson(Spice.intFromJson, Belt_Option.getWithDefault(Js_dict.get(dict$1, "b"), null));
+    if (b.TAG === /* Ok */0) {
+      return {
+              TAG: /* Ok */0,
+              _0: {
+                a: a._0,
+                b: b._0
+              }
+            };
+    }
+    var e = b._0;
+    return {
+            TAG: /* Error */1,
+            _0: {
+              path: ".b" + e.path,
+              message: e.message,
+              value: e.value
+            }
+          };
+  }
+  var e$1 = a._0;
+  return {
+          TAG: /* Error */1,
+          _0: {
+            path: ".a" + e$1.path,
+            message: e$1.message,
+            value: e$1.value
+          }
+        };
+}
+
+function t1_encode(v) {
+  return Js_dict.fromArray(Spice.filterOptional([
+                  [
+                    "a",
+                    false,
+                    Spice.intToJson(v.a)
+                  ],
+                  [
+                    "bs",
+                    true,
+                    Spice.optionToJson((function (param) {
+                            return Spice.arrayToJson(Spice.intToJson, param);
+                          }), v.bs)
+                  ]
+                ]));
+}
+
+function t1_decode(v) {
+  var dict = Js_json.classify(v);
+  if (typeof dict === "number") {
+    return Spice.error(undefined, "Not an object", v);
+  }
+  if (dict.TAG !== /* JSONObject */2) {
+    return Spice.error(undefined, "Not an object", v);
+  }
+  var dict$1 = dict._0;
+  var a = Spice.intFromJson(Belt_Option.getWithDefault(Js_dict.get(dict$1, "a"), null));
+  if (a.TAG === /* Ok */0) {
+    var bs = Spice.optionFromJson((function (param) {
+            return Spice.arrayFromJson(Spice.intFromJson, param);
+          }), Belt_Option.getWithDefault(Js_dict.get(dict$1, "bs"), null));
+    if (bs.TAG === /* Ok */0) {
+      return {
+              TAG: /* Ok */0,
+              _0: {
+                a: a._0,
+                bs: bs._0
+              }
+            };
+    }
+    var e = bs._0;
+    return {
+            TAG: /* Error */1,
+            _0: {
+              path: ".bs" + e.path,
+              message: e.message,
+              value: e.value
+            }
+          };
+  }
+  var e$1 = a._0;
+  return {
+          TAG: /* Error */1,
+          _0: {
+            path: ".a" + e$1.path,
+            message: e$1.message,
+            value: e$1.value
+          }
+        };
+}
+
+function b_encode(v) {
+  switch (v) {
+    case /* B0 */0 :
+        return "B0";
+    case /* B1 */1 :
+        return "B1";
+    case /* B2 */2 :
+        return "B2";
+    
+  }
+}
+
+function b_decode(v) {
+  var str = Js_json.classify(v);
+  if (typeof str === "number") {
+    return Spice.error(undefined, "Not a JSONString", v);
+  }
+  if (str.TAG !== /* JSONString */0) {
+    return Spice.error(undefined, "Not a JSONString", v);
+  }
+  var str$1 = str._0;
+  if ("B0" === str$1) {
+    return {
+            TAG: /* Ok */0,
+            _0: /* B0 */0
+          };
+  } else if ("B1" === str$1) {
+    return {
+            TAG: /* Ok */0,
+            _0: /* B1 */1
+          };
+  } else if ("B2" === str$1) {
+    return {
+            TAG: /* Ok */0,
+            _0: /* B2 */2
+          };
+  } else {
+    return Spice.error(undefined, "Not matched", v);
+  }
+}
+
+function t2_encode(v) {
+  return Js_dict.fromArray(Spice.filterOptional([
+                  [
+                    "a",
+                    false,
+                    Spice.intToJson(v.a)
+                  ],
+                  [
+                    "bs",
+                    true,
+                    Spice.optionToJson((function (param) {
+                            return Spice.arrayToJson(b_encode, param);
+                          }), v.bs)
+                  ]
+                ]));
+}
+
+function t2_decode(v) {
+  var dict = Js_json.classify(v);
+  if (typeof dict === "number") {
+    return Spice.error(undefined, "Not an object", v);
+  }
+  if (dict.TAG !== /* JSONObject */2) {
+    return Spice.error(undefined, "Not an object", v);
+  }
+  var dict$1 = dict._0;
+  var a = Spice.intFromJson(Belt_Option.getWithDefault(Js_dict.get(dict$1, "a"), null));
+  if (a.TAG === /* Ok */0) {
+    var bs = Spice.optionFromJson((function (param) {
+            return Spice.arrayFromJson(b_decode, param);
+          }), Belt_Option.getWithDefault(Js_dict.get(dict$1, "bs"), null));
+    if (bs.TAG === /* Ok */0) {
+      return {
+              TAG: /* Ok */0,
+              _0: {
+                a: a._0,
+                bs: bs._0
+              }
+            };
+    }
+    var e = bs._0;
+    return {
+            TAG: /* Error */1,
+            _0: {
+              path: ".bs" + e.path,
+              message: e.message,
+              value: e.value
+            }
+          };
+  }
+  var e$1 = a._0;
+  return {
+          TAG: /* Error */1,
+          _0: {
+            path: ".a" + e$1.path,
+            message: e$1.message,
+            value: e$1.value
+          }
+        };
+}
+
+exports.t0_encode = t0_encode;
+exports.t0_decode = t0_decode;
+exports.t1_encode = t1_encode;
+exports.t1_decode = t1_decode;
+exports.b_encode = b_encode;
+exports.b_decode = b_decode;
+exports.t2_encode = t2_encode;
+exports.t2_decode = t2_decode;
+/* No side effect */

package/test/src/OptionalFieldRecords.res

@@ -0,0 +1,23 @@
+@spice
+type t0 = {
+  a: int,
+  b?: int,
+}
+
+@spice
+type t1 = {
+  a: int,
+  bs?: array<int>,
+}
+
+@spice
+type b =
+  | @spice.as("B0") B0
+  | @spice.as("B1") B1
+  | @spice.as("B2") B2
+
+@spice
+type t2 = {
+  a: int,
+  bs?: array<b>,
+}