@greenlabs/ppx-spice 0.1.6 → 0.1.7-rc2

package/src/ppx/codecs.ml

@@ -27,165 +27,103 @@ and generate_constr_codecs { do_encode; do_decode }
     { Location.txt = identifier; loc } =
   let open Longident in
   match identifier with
-  | Lident "string" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.stringToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.stringFromJson]
-        | false -> None ))
-  | Lident "int" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.intToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.intFromJson]
-        | false -> None ))
-  | Lident "int64" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.int64ToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.int64FromJson]
-        | false -> None ))
-  | Lident "float" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.floatToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.floatFromJson]
-        | false -> None ))
-  | Lident "bool" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.boolToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.boolFromJson]
-        | false -> None ))
-  | Lident "unit" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.unitToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.unitFromJson]
-        | false -> None ))
-  | Lident "array" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.arrayToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.arrayFromJson]
-        | false -> None ))
-  | Lident "list" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.listToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.listFromJson]
-        | false -> None ))
-  | Lident "option" -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.optionToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.optionFromJson]
-        | false -> None ))
-  | Ldot (Ldot (Lident "Belt", "Result"), "t") -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.resultToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.resultFromJson]
-        | false -> None ))
-  | Ldot (Ldot (Lident "Js", "Dict"), "t") -> (
-      ( (match do_encode with
-        | true -> Some [%expr Spice.dictToJson]
-        | false -> None),
-        match do_decode with
-        | true -> Some [%expr Spice.dictFromJson]
-        | false -> None ))
-  | Ldot (Ldot (Lident "Js", "Json"), "t") -> (
-      ( (match do_encode with true -> Some [%expr fun v -> v] | false -> None),
-        match do_decode with
-        | true -> Some [%expr fun v -> Belt.Result.Ok v]
-        | false -> None ))
-  | Lident s -> (
-      ( (match do_encode with
-        | true -> Some (make_ident_expr (s ^ Utils.encoder_func_suffix))
-        | false -> None),
-        match do_decode with
-        | true -> Some (make_ident_expr (s ^ Utils.decoder_func_suffix))
-        | false -> None ))
-  | Ldot (left, right) -> (
-      ( (match do_encode with
-        | true ->
-            Some
-              (Exp.ident
-                 (mknoloc (Ldot (left, right ^ Utils.encoder_func_suffix))))
-        | false -> None),
-        match do_decode with
-        | true ->
-            Some
-              (Exp.ident
-                 (mknoloc (Ldot (left, right ^ Utils.decoder_func_suffix))))
-        | false -> None ))
+  | Lident "string" ->
+      ( some_if_true do_encode [%expr Spice.stringToJson],
+        some_if_true do_decode [%expr Spice.stringFromJson] )
+  | Lident "int" ->
+      ( some_if_true do_encode [%expr Spice.intToJson],
+        some_if_true do_decode [%expr Spice.intFromJson] )
+  | Lident "int64" ->
+      ( some_if_true do_encode [%expr Spice.int64ToJson],
+        some_if_true do_decode [%expr Spice.int64FromJson] )
+  | Lident "float" ->
+      ( some_if_true do_encode [%expr Spice.floatToJson],
+        some_if_true do_decode [%expr Spice.floatFromJson] )
+  | Lident "bool" ->
+      ( some_if_true do_encode [%expr Spice.boolToJson],
+        some_if_true do_decode [%expr Spice.boolFromJson] )
+  | Lident "unit" ->
+      ( some_if_true do_encode [%expr Spice.unitToJson],
+        some_if_true do_decode [%expr Spice.unitFromJson] )
+  | Lident "array" ->
+      ( some_if_true do_encode [%expr Spice.arrayToJson],
+        some_if_true do_decode [%expr Spice.arrayFromJson] )
+  | Lident "list" ->
+      ( some_if_true do_encode [%expr Spice.listToJson],
+        some_if_true do_decode [%expr Spice.listFromJson] )
+  | Lident "option" ->
+      ( some_if_true do_encode [%expr Spice.optionToJson],
+        some_if_true do_decode [%expr Spice.optionFromJson] )
+  | Ldot (Ldot (Lident "Belt", "Result"), "t") ->
+      ( some_if_true do_encode [%expr Spice.resultToJson],
+        some_if_true do_decode [%expr Spice.resultFromJson] )
+  | Ldot (Ldot (Lident "Js", "Dict"), "t") ->
+      ( some_if_true do_encode [%expr Spice.dictToJson],
+        some_if_true do_decode [%expr Spice.dictFromJson] )
+  | Ldot (Ldot (Lident "Js", "Json"), "t") ->
+      ( some_if_true do_encode [%expr fun v -> v],
+        some_if_true do_decode [%expr fun v -> Belt.Result.Ok v] )
+  | Lident s ->
+      ( some_if_true do_encode (make_ident_expr (s ^ Utils.encoder_func_suffix)),
+        some_if_true do_decode (make_ident_expr (s ^ Utils.decoder_func_suffix))
+      )
+  | Ldot (left, right) ->
+      ( some_if_true do_encode
+          (Exp.ident (mknoloc (Ldot (left, right ^ Utils.encoder_func_suffix)))),
+        some_if_true do_decode
+          (Exp.ident (mknoloc (Ldot (left, right ^ Utils.decoder_func_suffix))))
+      )
   | Lapply (_, _) -> fail loc "Lapply syntax not yet handled by spice"
 
-and generate_codecs ({ do_encode; do_decode } as generator_settings)
+and generate_codecs ?(is_optional = false)
+    ({ 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"
   | Ptyp_arrow (_, _, _) ->
       fail ptyp_loc "Can't generate codecs for function type"
   | Ptyp_package _ -> fail ptyp_loc "Can't generate codecs for module type"
-  | Ptyp_tuple types -> (
+  | Ptyp_tuple types ->
       let composite_codecs =
-        List.map (generate_codecs generator_settings) types
+        List.map (generate_codecs ~is_optional generator_settings) types
       in
-      ( (match do_encode with
-        | true ->
-            Some
-              (composite_codecs
-              |> List.map (fun (e, _) -> Option.get e)
-              |> Tuple.generate_encoder)
-        | false -> None),
-        match do_decode with
-        | true ->
-            Some
-              (composite_codecs
-              |> List.map (fun (_, d) -> Option.get d)
-              |> Tuple.generate_decoder)
-        | false -> None ))
-  | Ptyp_var s -> (
-      ( (match do_encode with
-        | true -> Some (make_ident_expr (encoder_var_prefix ^ s))
-        | false -> None),
-        match do_decode with
-        | true -> Some (make_ident_expr (decoder_var_prefix ^ s))
-        | false -> None ))
+      ( some_if_true do_encode
+          (composite_codecs
+          |> List.map (fun (e, _) -> Option.get e)
+          |> Tuple.generate_encoder),
+        some_if_true do_decode
+          (composite_codecs
+          |> List.map (fun (_, d) -> Option.get d)
+          |> Tuple.generate_decoder) )
+  | Ptyp_var s ->
+      ( some_if_true do_encode (make_ident_expr (encoder_var_prefix ^ s)),
+        some_if_true do_decode (make_ident_expr (decoder_var_prefix ^ s)) )
   | Ptyp_constr (constr, typeArgs) -> (
       let custom_codec = get_attribute_by_name ptyp_attributes "spice.codec" in
       let encode, decode =
         match custom_codec with
         | Ok None -> generate_constr_codecs generator_settings constr
-        | Ok (Some attribute) -> (
+        | Ok (Some attribute) ->
             let expr = get_expression_from_payload attribute in
-            ( (match do_encode with
-              | true ->
-                  Some
-                    [%expr
-                      let e, _ = [%e expr] in
-                      e]
-              | false -> None),
-              match do_decode with
-              | true ->
-                  Some
-                    [%expr
-                      let _, d = [%e expr] in
-                      d]
-              | false -> None ))
+            ( some_if_true do_encode
+                [%expr
+                  let e, _ = [%e expr] in
+                  e],
+              some_if_true do_decode
+                [%expr
+                  let _, d = [%e expr] in
+                  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/polyvariants.ml

@@ -219,15 +219,12 @@ let generate_codecs ({ do_encode; do_decode } as generator_settings) row_fields
   in
 
   let encoder =
-    match do_encode with
-    | true ->
-        List.map
-          (generate_encoder_case generator_settings unboxed has_attr_as)
-          parsed_fields
-        |> Exp.match_ [%expr v]
-        |> Exp.fun_ Asttypes.Nolabel None [%pat? v]
-        |> Option.some
-    | false -> None
+    some_if_true do_encode
+      (List.map
+         (generate_encoder_case generator_settings unboxed has_attr_as)
+         parsed_fields
+      |> Exp.match_ [%expr v]
+      |> Exp.fun_ Asttypes.Nolabel None [%pat? v])
   in
 
   let decoder =

package/src/ppx/records.ml

@@ -11,8 +11,16 @@ type parsed_decl = {
   field : expression;
   codecs : expression option * expression option;
   default : expression option;
+  is_optional : bool;
 }
 
+let optional_attr : Ppxlib.Parsetree.attribute =
+  {
+    attr_name = { txt = "ns.optional"; loc = Location.none };
+    attr_payload = PStr [];
+    attr_loc = Location.none;
+  }
+
 let generate_encoder decls unboxed =
   match unboxed with
   | true ->
@@ -22,11 +30,17 @@ let generate_encoder decls unboxed =
   | false ->
       let arrExpr =
         decls
-        |> List.map (fun { key; field; codecs = encoder, _ } ->
-               [%expr [%e key], [%e Option.get encoder] [%e field]])
+        |> List.map (fun { key; field; codecs = encoder, _; is_optional } ->
+               let is_optional =
+                 if is_optional then [%expr true] else [%expr false]
+               in
+               [%expr
+                 [%e key], [%e is_optional], [%e Option.get encoder] [%e field]])
         |> Exp.array
       in
-      [%expr [%e arrExpr] |> Js.Dict.fromArray |> Js.Json.object_]
+      [%expr
+        [%e arrExpr] |> Spice.filterOptional |> Js.Dict.fromArray
+        |> Js.Json.object_]
       |> Exp.fun_ Asttypes.Nolabel None [%pat? v]
 
 let generate_dict_get { key; codecs = _, decoder; default } =
@@ -53,7 +67,10 @@ let generate_error_case { key } =
   }
 
 let generate_final_record_expr decls =
-  decls |> List.map (fun { name } -> (lid name, make_ident_expr name))
+  decls
+  |> List.map (fun { name; is_optional } ->
+         let attrs = if is_optional then [ optional_attr ] else [] in
+         (lid name, make_ident_expr ~attrs name))
   |> fun l -> [%expr Belt.Result.Ok [%e Exp.record l None]]
 
 let generate_success_case { name } success_expr =
@@ -113,20 +130,24 @@ let parse_decl generator_settings
     | Ok None -> Exp.constant (Pconst_string (txt, Location.none, None))
     | Error s -> fail pld_loc s
   in
+  let optional_attrs = [ "ns.optional"; "res.optional" ] in
+  let is_optional =
+    optional_attrs
+    |> List.map (fun attr -> get_attribute_by_name pld_attributes attr)
+    |> List.exists (function Ok (Some _) -> true | _ -> false)
+  in
+
   {
     name = txt;
     key;
     field = Exp.field [%expr v] (lid txt);
-    codecs = Codecs.generate_codecs generator_settings pld_type;
+    codecs = Codecs.generate_codecs ~is_optional generator_settings pld_type;
     default;
+    is_optional;
   }
 
 let generate_codecs ({ do_encode; do_decode } as generator_settings) decls
     unboxed =
   let parsed_decls = List.map (parse_decl generator_settings) decls in
-  ( (match do_encode with
-    | true -> Some (generate_encoder parsed_decls unboxed)
-    | false -> None),
-    match do_decode with
-    | true -> Some (generate_decoder parsed_decls unboxed)
-    | false -> None )
+  ( some_if_true do_encode (generate_encoder parsed_decls unboxed),
+    some_if_true do_decode (generate_decoder parsed_decls unboxed) )

package/src/ppx/utils.ml

@@ -24,7 +24,7 @@ let mknoloc txt = mkloc txt Location.none
 
 let lid ?(loc = Location.none) s = mkloc (Longident.parse s) loc
 
-let make_ident_expr s = Exp.ident (mknoloc (longident_parse s))
+let make_ident_expr ?attrs s = Exp.ident ?attrs (mknoloc (longident_parse s))
 
 let tuple_or_singleton tuple l =
   match List.length l > 1 with true -> tuple l | false -> List.hd l
@@ -113,3 +113,5 @@ let attr_warning expr =
     attr_payload = PStr [ { pstr_desc = Pstr_eval (expr, []); pstr_loc = loc } ];
     attr_loc = loc;
   }
+
+let some_if_true cond a = match cond with true -> Some a | false -> None

package/src/ppx/variants.ml

@@ -188,15 +188,11 @@ let generate_codecs ({ do_encode; do_decode } as generator_settings)
   in
 
   let encoder =
-    match do_encode with
-    | true ->
-        parsed_decls
-        |> List.map
-             (generate_encoder_case generator_settings unboxed has_attr_as)
-        |> Exp.match_ [%expr v]
-        |> Exp.fun_ Asttypes.Nolabel None [%pat? v]
-        |> Option.some
-    | false -> None
+    some_if_true do_encode
+      (parsed_decls
+      |> List.map (generate_encoder_case generator_settings unboxed has_attr_as)
+      |> Exp.match_ [%expr v]
+      |> Exp.fun_ Asttypes.Nolabel None [%pat? v])
   in
 
   let decoder =

package/src/ppx_spice.opam

@@ -0,0 +1,21 @@
+opam-version: "2.0"
+name: "ppx_spice"
+version: "0.1.7"
+synopsis: "ReScript PPX which generate JSON (de)serializer"
+description: """
+ReScript PPX which generate JSON (de)serializer
+"""
+maintainer: "Greenlabs Dev <developer@greenlabs.co.kr>"
+authors: "Greenlabs Dev <developer@greenlabs.co.kr>"
+license: "MIT"
+homepage: "https://github.com/green-labs/ppx_spice"
+bug-reports: "https://github.com/green-labs/ppx_spice/issues"
+dev-repo: "git+https://github.com/green-labs/ppx_spice.git"
+depends: [
+  "ocaml" { = "4.12.1"}
+  "dune" { >= "2.7"}
+  "ppxlib" { = "0.23.0"}
+]
+build: [
+  ["dune" "build" "-p" name "-j" jobs]
+]

package/src/rescript/Spice.res

@@ -14,7 +14,7 @@ let error = (~path=?, message, value) => {
   | None => ""
   | Some(s) => s
   }
-  Belt.Result.Error({path: path, message: message, value: value})
+  Belt.Result.Error({path, message, value})
 }
 
 let stringToJson = s => Js.Json.string(s)
@@ -98,6 +98,11 @@ let optionToJson = (encoder, opt) =>
   | None => Js.Json.null
   }
 
+let filterOptional = arr =>
+  arr
+  |> Belt.Array.keep(_, ((_, isOptional, x)) => !(isOptional && x == Js.Json.null))
+  |> Belt.Array.map(_, ((k, _, v)) => (k, v))
+
 let optionFromJson = (decoder, json) =>
   switch Js.Json.decodeNull(json) {
   | Some(_) => Belt.Result.Ok(None)

package/test/__tests__/test_polyvariants.js

@@ -5,28 +5,28 @@ var Jest = require("@glennsl/bs-jest/src/jest.js");
 var Polyvariants = require("../src/Polyvariants.js");
 
 Jest.describe("polymorphic variants with attribute", (function (param) {
-        Jest.test("encode \xed\x95\x98\xeb\x82\x98", (function (param) {
+        Jest.test("encode 하나", (function (param) {
                 var polyvariantEncoded = Polyvariants.t_encode("one");
                 return Jest.Expect.toEqual("하나", Jest.Expect.expect(polyvariantEncoded));
               }));
-        Jest.test("encode \xeb\x91\x98", (function (param) {
+        Jest.test("encode 둘", (function (param) {
                 var polyvariantEncoded = Polyvariants.t_encode("two");
                 return Jest.Expect.toEqual("둘", Jest.Expect.expect(polyvariantEncoded));
               }));
-        Jest.test("decode \xed\x95\x98\xeb\x82\x98", (function (param) {
+        Jest.test("decode 하나", (function (param) {
                 var polyvariantDecoded = Polyvariants.t_decode("하나");
                 return Jest.Expect.toEqual({
                             TAG: /* Ok */0,
                             _0: "one"
                           }, Jest.Expect.expect(polyvariantDecoded));
               }));
-        return Jest.test("decode \xeb\x91\x98", (function (param) {
-                      var polyvariantDecoded = Polyvariants.t_decode("둘");
-                      return Jest.Expect.toEqual({
-                                  TAG: /* Ok */0,
-                                  _0: "two"
-                                }, Jest.Expect.expect(polyvariantDecoded));
-                    }));
+        Jest.test("decode 둘", (function (param) {
+                var polyvariantDecoded = Polyvariants.t_decode("둘");
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: "two"
+                          }, Jest.Expect.expect(polyvariantDecoded));
+              }));
       }));
 
 Jest.describe("polymorphic variants", (function (param) {
@@ -45,13 +45,13 @@ Jest.describe("polymorphic variants", (function (param) {
                             _0: "one"
                           }, Jest.Expect.expect(polyvariantDecoded));
               }));
-        return Jest.test("decode two", (function (param) {
-                      var polyvariantDecoded = Polyvariants.t1_decode(["two"]);
-                      return Jest.Expect.toEqual({
-                                  TAG: /* Ok */0,
-                                  _0: "two"
-                                }, Jest.Expect.expect(polyvariantDecoded));
-                    }));
+        Jest.test("decode two", (function (param) {
+                var polyvariantDecoded = Polyvariants.t1_decode(["two"]);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: "two"
+                          }, Jest.Expect.expect(polyvariantDecoded));
+              }));
       }));
 
 /*  Not a pure module */

package/test/__tests__/test_records.js

@@ -16,13 +16,13 @@ Jest.describe("record with @spice.key", (function (param) {
                 var encoded = Records.t_encode(sampleRecord);
                 return Jest.Expect.toEqual(sample, Jest.Expect.expect(encoded));
               }));
-        return Jest.test("decode", (function (param) {
-                      var decoded = Records.t_decode(sample);
-                      return Jest.Expect.toEqual({
-                                  TAG: /* Ok */0,
-                                  _0: sampleRecord
-                                }, Jest.Expect.expect(decoded));
-                    }));
+        Jest.test("decode", (function (param) {
+                var decoded = Records.t_decode(sample);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord
+                          }, Jest.Expect.expect(decoded));
+              }));
       }));
 
 Jest.describe("record without @spice.key", (function (param) {
@@ -37,13 +37,64 @@ Jest.describe("record without @spice.key", (function (param) {
                 var encoded = Records.t1_encode(sampleRecord);
                 return Jest.Expect.toEqual(sample, Jest.Expect.expect(encoded));
               }));
-        return Jest.test("decode", (function (param) {
-                      var decoded = Records.t1_decode(sample);
-                      return Jest.Expect.toEqual({
-                                  TAG: /* Ok */0,
-                                  _0: sampleRecord
-                                }, Jest.Expect.expect(decoded));
-                    }));
+        Jest.test("decode", (function (param) {
+                var decoded = Records.t1_decode(sample);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord
+                          }, Jest.Expect.expect(decoded));
+              }));
+      }));
+
+Jest.describe("record with optional field", (function (param) {
+        var sample1 = {};
+        sample1["label"] = "sample";
+        sample1["value"] = 1.0;
+        var sampleRecord1 = {
+          label: "sample",
+          value: 1
+        };
+        Jest.test("encode", (function (param) {
+                var encoded = Records.tOp_encode(sampleRecord1);
+                return Jest.Expect.toEqual(sample1, Jest.Expect.expect(encoded));
+              }));
+        Jest.test("decode", (function (param) {
+                var decoded = Records.tOp_decode(sample1);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord1
+                          }, Jest.Expect.expect(decoded));
+              }));
+        var sample2 = {};
+        sample2["label"] = "sample";
+        var sampleRecord2 = {
+          label: "sample"
+        };
+        Jest.test("encode omit optional field", (function (param) {
+                var encoded = Records.tOp_encode(sampleRecord2);
+                return Jest.Expect.toEqual(sample2, Jest.Expect.expect(encoded));
+              }));
+        Jest.test("decode omit optional field", (function (param) {
+                var decoded = Records.tOp_decode(sample2);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord2
+                          }, Jest.Expect.expect(decoded));
+              }));
+        var sample3 = {};
+        sample3["label"] = null;
+        var sampleRecord3 = {};
+        Jest.test("encode omit optional field with None field", (function (param) {
+                var encoded = Records.tOp_encode(sampleRecord3);
+                return Jest.Expect.toEqual(sample3, Jest.Expect.expect(encoded));
+              }));
+        Jest.test("decode omit optional field with None field", (function (param) {
+                var decoded = Records.tOp_decode(sample3);
+                return Jest.Expect.toEqual({
+                            TAG: /* Ok */0,
+                            _0: sampleRecord3
+                          }, Jest.Expect.expect(decoded));
+              }));
       }));
 
 /*  Not a pure module */

package/test/__tests__/test_records.res

@@ -49,3 +49,63 @@ describe("record without @spice.key", _ => {
     expect(decoded) |> toEqual(Belt.Result.Ok(sampleRecord))
   })
 })
+
+describe("record with optional field", _ => {
+  open Records
+
+  let sample1 = Js.Dict.empty()
+  sample1->Js.Dict.set("label", Js.Json.string("sample"))
+  sample1->Js.Dict.set("value", Js.Json.number(1.0))
+  let sampleJson1 = sample1->Js.Json.object_
+
+  let sampleRecord1: tOp = {
+    label: Some("sample"),
+    value: 1,
+  }
+
+  test(`encode`, _ => {
+    let encoded = sampleRecord1->tOp_encode
+    expect(encoded) |> toEqual(sampleJson1)
+  })
+
+  test(`decode`, _ => {
+    let decoded = sampleJson1->Records.tOp_decode
+    expect(decoded) |> toEqual(Belt.Result.Ok(sampleRecord1))
+  })
+
+  let sample2 = Js.Dict.empty()
+  sample2->Js.Dict.set("label", Js.Json.string("sample"))
+  let sampleJson2 = sample2->Js.Json.object_
+
+  let sampleRecord2: tOp = {
+    label: Some("sample"),
+  }
+
+  test(`encode omit optional field`, _ => {
+    let encoded = sampleRecord2->tOp_encode
+    expect(encoded) |> toEqual(sampleJson2)
+  })
+
+  test(`decode omit optional field`, _ => {
+    let decoded = sampleJson2->Records.tOp_decode
+    expect(decoded) |> toEqual(Belt.Result.Ok(sampleRecord2))
+  })
+
+  let sample3 = Js.Dict.empty()
+  sample3->Js.Dict.set("label", Js.Json.null)
+  let sampleJson3 = sample3->Js.Json.object_
+
+  let sampleRecord3: tOp = {
+    label: None,
+  }
+
+  test(`encode omit optional field with None field`, _ => {
+    let encoded = sampleRecord3->tOp_encode
+    expect(encoded) |> toEqual(sampleJson3)
+  })
+
+  test(`decode omit optional field with None field`, _ => {
+    let decoded = sampleJson3->Records.tOp_decode
+    expect(decoded) |> toEqual(Belt.Result.Ok(sampleRecord3))
+  })
+})