@greenlabs/ppx-spice 0.1.13 → 0.1.15-rc0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+# 0.1.14
+
+- Support both `ns.optional` and `res.optional` for backward compatability
+
+# 0.1.13
+
+- Rename the attribute used for optional records from `ns.optional` to `res.optional`.
+
 # 0.1.12
 
 - Fix build error where `@spice.encode`, `@spice.decode` are used

package/package.json

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

package/src/rescript/Spice.js

@@ -0,0 +1,446 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Js_json = require("rescript/lib/js/js_json.js");
+var Js_math = require("rescript/lib/js/js_math.js");
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var Js_array = require("rescript/lib/js/js_array.js");
+var Belt_List = require("rescript/lib/js/belt_List.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Caml_int64 = require("rescript/lib/js/caml_int64.js");
+var Belt_Result = require("rescript/lib/js/belt_Result.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Spice_Codecs = require("./Spice_Codecs.js");
+
+function error(path, message, value) {
+  var path$1 = path !== undefined ? path : "";
+  return {
+          TAG: "Error",
+          _0: {
+            path: path$1,
+            message: message,
+            value: value
+          }
+        };
+}
+
+function stringToJson(s) {
+  return s;
+}
+
+function stringFromJson(j) {
+  var s = Js_json.decodeString(j);
+  if (s !== undefined) {
+    return {
+            TAG: "Ok",
+            _0: s
+          };
+  } else {
+    return {
+            TAG: "Error",
+            _0: {
+              path: "",
+              message: "Not a string",
+              value: j
+            }
+          };
+  }
+}
+
+function intToJson(i) {
+  return i;
+}
+
+function intFromJson(j) {
+  var f = Js_json.decodeNumber(j);
+  if (f !== undefined) {
+    if (Js_math.floor(f) === f) {
+      return {
+              TAG: "Ok",
+              _0: Js_math.floor(f)
+            };
+    } else {
+      return {
+              TAG: "Error",
+              _0: {
+                path: "",
+                message: "Not an integer",
+                value: j
+              }
+            };
+    }
+  } else {
+    return {
+            TAG: "Error",
+            _0: {
+              path: "",
+              message: "Not a number",
+              value: j
+            }
+          };
+  }
+}
+
+var int64ToJson = Caml_int64.float_of_bits;
+
+function int64FromJson(j) {
+  var n = Js_json.decodeNumber(j);
+  if (n !== undefined) {
+    return {
+            TAG: "Ok",
+            _0: Caml_int64.bits_of_float(n)
+          };
+  } else {
+    return error(undefined, "Not a number", j);
+  }
+}
+
+var int64ToJsonUnsafe = Caml_int64.to_float;
+
+function int64FromJsonUnsafe(j) {
+  var n = Js_json.decodeNumber(j);
+  if (n !== undefined) {
+    return {
+            TAG: "Ok",
+            _0: Caml_int64.of_float(n)
+          };
+  } else {
+    return error(undefined, "Not a number", j);
+  }
+}
+
+function floatToJson(v) {
+  return v;
+}
+
+function floatFromJson(j) {
+  var f = Js_json.decodeNumber(j);
+  if (f !== undefined) {
+    return {
+            TAG: "Ok",
+            _0: f
+          };
+  } else {
+    return {
+            TAG: "Error",
+            _0: {
+              path: "",
+              message: "Not a number",
+              value: j
+            }
+          };
+  }
+}
+
+function boolToJson(v) {
+  return v;
+}
+
+function boolFromJson(j) {
+  var b = Js_json.decodeBoolean(j);
+  if (b !== undefined) {
+    return {
+            TAG: "Ok",
+            _0: b
+          };
+  } else {
+    return {
+            TAG: "Error",
+            _0: {
+              path: "",
+              message: "Not a boolean",
+              value: j
+            }
+          };
+  }
+}
+
+function unitToJson() {
+  return 0.0;
+}
+
+function unitFromJson(param) {
+  return {
+          TAG: "Ok",
+          _0: undefined
+        };
+}
+
+var arrayToJson = Js_array.map;
+
+function arrayFromJson(decoder, json) {
+  var arr = Js_json.decodeArray(json);
+  if (arr !== undefined) {
+    return Js_array.reducei((function (acc, jsonI, i) {
+                  var match = decoder(jsonI);
+                  if (acc.TAG !== "Ok") {
+                    return acc;
+                  }
+                  if (match.TAG === "Ok") {
+                    return {
+                            TAG: "Ok",
+                            _0: Js_array.concat([match._0], acc._0)
+                          };
+                  }
+                  var error = match._0;
+                  return {
+                          TAG: "Error",
+                          _0: {
+                            path: "[" + (String(i) + ("]" + error.path)),
+                            message: error.message,
+                            value: error.value
+                          }
+                        };
+                }), {
+                TAG: "Ok",
+                _0: []
+              }, arr);
+  } else {
+    return {
+            TAG: "Error",
+            _0: {
+              path: "",
+              message: "Not an array",
+              value: json
+            }
+          };
+  }
+}
+
+function listToJson(encoder, list) {
+  return Js_array.map(encoder, Belt_List.toArray(list));
+}
+
+function listFromJson(decoder, json) {
+  return Belt_Result.map(arrayFromJson(decoder, json), Belt_List.fromArray);
+}
+
+function filterOptional(arr) {
+  return Belt_Array.map(Belt_Array.keep(arr, (function (param) {
+                    return !(param[1] && Caml_obj.equal(param[2], null));
+                  })), (function (param) {
+                return [
+                        param[0],
+                        param[2]
+                      ];
+              }));
+}
+
+function optionToJson(encoder, opt) {
+  if (opt !== undefined) {
+    return encoder(Caml_option.valFromOption(opt));
+  } else {
+    return null;
+  }
+}
+
+function optionFromJson(decoder, json) {
+  var match = Js_json.decodeNull(json);
+  if (match !== undefined) {
+    return {
+            TAG: "Ok",
+            _0: undefined
+          };
+  } else {
+    return Belt_Result.map(decoder(json), (function (v) {
+                  return Caml_option.some(v);
+                }));
+  }
+}
+
+function resultToJson(okEncoder, errorEncoder, result) {
+  if (result.TAG === "Ok") {
+    return [
+            "Ok",
+            okEncoder(result._0)
+          ];
+  } else {
+    return [
+            "Error",
+            errorEncoder(result._0)
+          ];
+  }
+}
+
+function resultFromJson(okDecoder, errorDecoder, json) {
+  var match = Js_json.decodeArray(json);
+  if (match === undefined) {
+    return error(undefined, "Not an array", json);
+  }
+  if (match.length !== 2) {
+    return error(undefined, "Expected exactly 2 values in array", json);
+  }
+  var variantConstructorId = match[0];
+  var payload = match[1];
+  var match$1 = Js_json.decodeString(variantConstructorId);
+  if (match$1 === undefined) {
+    return error(undefined, "Not a string", variantConstructorId);
+  }
+  switch (match$1) {
+    case "Error" :
+        var v = errorDecoder(payload);
+        if (v.TAG === "Ok") {
+          return {
+                  TAG: "Ok",
+                  _0: {
+                    TAG: "Error",
+                    _0: v._0
+                  }
+                };
+        } else {
+          return {
+                  TAG: "Error",
+                  _0: v._0
+                };
+        }
+    case "Ok" :
+        return Belt_Result.map(okDecoder(payload), (function (v) {
+                      return {
+                              TAG: "Ok",
+                              _0: v
+                            };
+                    }));
+    default:
+      return error(undefined, "Expected either \"Ok\" or \"Error\"", variantConstructorId);
+  }
+}
+
+function dictToJson(encoder, dict) {
+  return Js_dict.map((function (a) {
+                return encoder(a);
+              }), dict);
+}
+
+function dictFromJson(decoder, json) {
+  var dict = Js_json.decodeObject(json);
+  if (dict !== undefined) {
+    return Belt_Array.reduce(Js_dict.entries(Caml_option.valFromOption(dict)), {
+                TAG: "Ok",
+                _0: {}
+              }, (function (acc, param) {
+                  var key = param[0];
+                  var match = decoder(param[1]);
+                  if (acc.TAG !== "Ok") {
+                    return acc;
+                  }
+                  var prev = acc._0;
+                  if (match.TAG === "Ok") {
+                    prev[key] = match._0;
+                    return {
+                            TAG: "Ok",
+                            _0: prev
+                          };
+                  }
+                  var error = match._0;
+                  return {
+                          TAG: "Error",
+                          _0: {
+                            path: "." + (key + error.path),
+                            message: error.message,
+                            value: error.value
+                          }
+                        };
+                }));
+  } else {
+    return {
+            TAG: "Error",
+            _0: {
+              path: "",
+              message: "Not a dict",
+              value: json
+            }
+          };
+  }
+}
+
+var string = [
+  stringToJson,
+  stringFromJson
+];
+
+var $$int = [
+  intToJson,
+  intFromJson
+];
+
+var int64Unsafe = [
+  int64ToJsonUnsafe,
+  int64FromJsonUnsafe
+];
+
+var $$float = [
+  floatToJson,
+  floatFromJson
+];
+
+var bool = [
+  boolToJson,
+  boolFromJson
+];
+
+var array = [
+  arrayToJson,
+  arrayFromJson
+];
+
+var list = [
+  listToJson,
+  listFromJson
+];
+
+var option = [
+  optionToJson,
+  optionFromJson
+];
+
+var unit = [
+  unitToJson,
+  unitFromJson
+];
+
+var Codecs = {
+  falseableEncode: Spice_Codecs.falseableEncode,
+  falseableDecode: Spice_Codecs.falseableDecode,
+  falseable: Spice_Codecs.falseable,
+  magicDecode: Spice_Codecs.magicDecode,
+  magic: Spice_Codecs.magic,
+  string: string,
+  $$int: $$int,
+  int64Unsafe: int64Unsafe,
+  $$float: $$float,
+  bool: bool,
+  array: array,
+  list: list,
+  option: option,
+  unit: unit
+};
+
+exports.error = error;
+exports.stringToJson = stringToJson;
+exports.stringFromJson = stringFromJson;
+exports.intToJson = intToJson;
+exports.intFromJson = intFromJson;
+exports.int64ToJson = int64ToJson;
+exports.int64FromJson = int64FromJson;
+exports.int64ToJsonUnsafe = int64ToJsonUnsafe;
+exports.int64FromJsonUnsafe = int64FromJsonUnsafe;
+exports.floatToJson = floatToJson;
+exports.floatFromJson = floatFromJson;
+exports.boolToJson = boolToJson;
+exports.boolFromJson = boolFromJson;
+exports.unitToJson = unitToJson;
+exports.unitFromJson = unitFromJson;
+exports.arrayToJson = arrayToJson;
+exports.arrayFromJson = arrayFromJson;
+exports.listToJson = listToJson;
+exports.listFromJson = listFromJson;
+exports.filterOptional = filterOptional;
+exports.optionToJson = optionToJson;
+exports.optionFromJson = optionFromJson;
+exports.resultToJson = resultToJson;
+exports.resultFromJson = resultFromJson;
+exports.dictToJson = dictToJson;
+exports.dictFromJson = dictFromJson;
+exports.Codecs = Codecs;
+/* No side effect */

package/src/rescript/Spice.res

@@ -24,7 +24,7 @@ let stringFromJson = j =>
   | None => Belt.Result.Error({path: "", message: "Not a string", value: j})
   }
 
-let intToJson = i => i |> float_of_int |> Js.Json.number
+let intToJson = i => Js.Json.number(float_of_int(i))
 let intFromJson = j =>
   switch Js.Json.decodeNumber(j) {
   | Some(f) =>
@@ -35,7 +35,7 @@ let intFromJson = j =>
   | _ => Belt.Result.Error({path: "", message: "Not a number", value: j})
   }
 
-let int64ToJson = i => i |> Int64.float_of_bits |> Js.Json.number
+let int64ToJson = i => Js.Json.number(Int64.float_of_bits(i))
 
 let int64FromJson = j =>
   switch Js.Json.decodeNumber(j) {
@@ -43,7 +43,7 @@ let int64FromJson = j =>
   | None => error("Not a number", j)
   }
 
-let int64ToJsonUnsafe = i => i |> Int64.to_float |> Js.Json.number
+let int64ToJsonUnsafe = i => Js.Json.number(Int64.to_float(i))
 
 let int64FromJsonUnsafe = j =>
   switch Js.Json.decodeNumber(j) {
@@ -51,14 +51,14 @@ let int64FromJsonUnsafe = j =>
   | None => error("Not a number", j)
   }
 
-let floatToJson = v => v |> Js.Json.number
+let floatToJson = v => Js.Json.number(v)
 let floatFromJson = j =>
   switch Js.Json.decodeNumber(j) {
   | Some(f) => Belt.Result.Ok(f)
   | None => Belt.Result.Error({path: "", message: "Not a number", value: j})
   }
 
-let boolToJson = v => v |> Js.Json.boolean
+let boolToJson = v => Js.Json.boolean(v)
 let boolFromJson = j =>
   switch Js.Json.decodeBoolean(j) {
   | Some(b) => Belt.Result.Ok(b)
@@ -68,7 +68,7 @@ let boolFromJson = j =>
 let unitToJson = () => Js.Json.number(0.0)
 let unitFromJson = _ => Belt.Result.Ok()
 
-let arrayToJson = (encoder, arr) => arr |> Js.Array.map(encoder) |> Js.Json.array
+let arrayToJson = (encoder, arr) => Js.Json.array(Js.Array.map(encoder, arr))
 
 let arrayFromJson = (decoder, json) =>
   switch Js.Json.decodeArray(json) {
@@ -87,10 +87,16 @@ let arrayFromJson = (decoder, json) =>
   | None => Belt.Result.Error({path: "", message: "Not an array", value: json})
   }
 
-let listToJson = (encoder, list) => list |> Array.of_list |> arrayToJson(encoder)
+let listToJson = (encoder, list) => arrayToJson(encoder, Belt.List.toArray(list))
 
 let listFromJson = (decoder, json) =>
-  json |> arrayFromJson(decoder) |> Belt.Result.map(_, Array.to_list)
+  Belt.Result.map(arrayFromJson(decoder, json), Belt.List.fromArray)
+
+let filterOptional = arr =>
+  Belt.Array.map(
+    Belt.Array.keep(arr, ((_, isOptional, x)) => !(isOptional && x == Js.Json.null)),
+    ((k, _, v)) => (k, v),
+  )
 
 let optionToJson = (encoder, opt) =>
   switch opt {
@@ -98,22 +104,19 @@ 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)
-  | None => decoder(json) |> Belt.Result.map(_, v => Some(v))
+  | None => Belt.Result.map(decoder(json), v => Some(v))
   }
 
 let resultToJson = (okEncoder, errorEncoder, result) =>
-  switch result {
-  | Belt.Result.Ok(v) => [Js.Json.string("Ok"), okEncoder(v)]
-  | Belt.Result.Error(e) => [Js.Json.string("Error"), errorEncoder(e)]
-  } |> Js.Json.array
+  Js.Json.array(
+    switch result {
+    | Belt.Result.Ok(v) => [Js.Json.string("Ok"), okEncoder(v)]
+    | Belt.Result.Error(e) => [Js.Json.string("Error"), errorEncoder(e)]
+    },
+  )
 
 let resultFromJson = (okDecoder, errorDecoder, json) =>
   switch Js.Json.decodeArray(json) {
@@ -134,7 +137,7 @@ let resultFromJson = (okDecoder, errorDecoder, json) =>
   | None => error("Not an array", json)
   }
 
-let dictToJson = (encoder, dict) => dict->Js.Dict.map((. a) => encoder(a), _)->Js.Json.object_
+let dictToJson = (encoder, dict) => Js.Json.object_(Js.Dict.map(a => encoder(a), dict))
 
 let dictFromJson = (decoder, json) =>
   switch Js.Json.decodeObject(json) {

package/src/rescript/Spice_Codecs.js

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Js_json = require("rescript/lib/js/js_json.js");
+var Belt_Result = require("rescript/lib/js/belt_Result.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+
+function falseableEncode(encoder, opt) {
+  if (opt !== undefined) {
+    return encoder(Caml_option.valFromOption(opt));
+  } else {
+    return false;
+  }
+}
+
+function falseableDecode(decoder, json) {
+  var match = Js_json.decodeBoolean(json);
+  if (match !== undefined && !match) {
+    return {
+            TAG: "Ok",
+            _0: undefined
+          };
+  }
+  return Belt_Result.map(decoder(json), (function (v) {
+                return Caml_option.some(v);
+              }));
+}
+
+var falseable = [
+  falseableEncode,
+  falseableDecode
+];
+
+function magicDecode(j) {
+  return {
+          TAG: "Ok",
+          _0: j
+        };
+}
+
+function magic_0(prim) {
+  return prim;
+}
+
+var magic = [
+  magic_0,
+  magicDecode
+];
+
+exports.falseableEncode = falseableEncode;
+exports.falseableDecode = falseableDecode;
+exports.falseable = falseable;
+exports.magicDecode = magicDecode;
+exports.magic = magic;
+/* No side effect */

package/src/rescript/Spice_Codecs.res

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