@colisweb/rescript-toolkit 4.29.2 → 5.0.0

package/src/decoders/Toolkit__Decoders.res

@@ -1,437 +1,199 @@
+module Option = {
+  let encoder = (encoder, value) =>
+    switch value {
+    | None => %raw("undefined")
+    | Some(value) => encoder(value)
+    }
+
+  let decoder = (decoder, json) =>
+    json !== %raw("undefined") ? Spice.optionFromJson(decoder, json) : Ok(None)
+
+  let codec = (encoder, decoder)
+
+  @spice
+  type t<'a> = @spice.codec((encoder, decoder)) option<'a>
+}
+
+module Coordinates = {
+  @spice
+  type t = {
+    latitude: float,
+    longitude: float,
+  }
+  let make = (~lat: float, ~lng: float): t => {latitude: lat, longitude: lng}
+  let areEquals = (a: t, b: t): bool => a.latitude === b.latitude && a.longitude === b.longitude
+  let fromJs = value => {
+    latitude: (value->Obj.magic)["lat"](),
+    longitude: (value->Obj.magic)["lng"](),
+  }
+  type gmaps = {
+    lat: float,
+    lng: float,
+  }
+  let toGmaps = (t: t): gmaps => {lat: t.latitude, lng: t.longitude}
+  let fromGmaps = (gmaps: gmaps) => {
+    latitude: gmaps.lat,
+    longitude: gmaps.lng,
+  }
+}
+
 module Datetime = {
   type date = Js.Date.t
 
-  let encoder: Decco.encoder<date> = value => value->Js.Date.toISOString->Decco.stringToJson
+  let encoder: Spice.encoder<date> = value => value->Js.Date.toISOString->Spice.stringToJson
 
-  let decoder: Decco.decoder<date> = json =>
-    switch Decco.stringFromJson(json) {
+  let decoder: Spice.decoder<date> = json =>
+    switch Spice.stringFromJson(json) {
     | Ok(value) => Ok(value->Js.Date.fromString)
     | Error(_) as error => error
     }
 
-  let codec: Decco.codec<date> = (encoder, decoder)
+  let codec: Spice.codec<date> = (encoder, decoder)
 
-  @decco
-  type t = @decco.codec(codec) date
+  @spice
+  type t = @spice.codec(codec) date
 }
 
 module Date = {
   type date = Js.Date.t
 
-  let encoder: Decco.encoder<date> = date =>
-    date->DateFns.formatWithPattern("yyyy-MM-dd")->Decco.stringToJson
+  let encoder: Spice.encoder<date> = date =>
+    date->DateFns.formatWithPattern("yyyy-MM-dd")->Spice.stringToJson
 
-  let decoder: Decco.decoder<date> = json =>
-    switch Decco.stringFromJson(json) {
+  let decoder: Spice.decoder<date> = json =>
+    switch Spice.stringFromJson(json) {
     | Ok(v) => Js.Date.fromString(v)->Ok
     | Error(_) as err => err
     }
 
-  let codec: Decco.codec<date> = (encoder, decoder)
+  let codec: Spice.codec<date> = (encoder, decoder)
 
-  @decco
-  type t = @decco.codec(codec) date
+  @spice
+  type t = @spice.codec(codec) date
 }
 
-module Int = {
-  let encoder = value => value->Decco.intToJson
+module DatetimeTimeSlot = {
+  @spice
+  type t = {
+    start: Datetime.t,
+    @as("end") @spice.key("end")
+    end_: Datetime.t,
+  }
 
-  let decoder = json =>
-    switch Js.Json.classify(json) {
-    | JSONNumber(_) =>
-      switch Decco.intFromJson(json) {
-      | Ok(_) as value => value
-      | Error(_) as error => error
-      }
-    | JSONString(_) =>
-      switch Decco.stringFromJson(json) {
-      | Ok(value) =>
-        switch Decco.intFromJson(value->Js.Float.fromString->Js.Json.number) {
-        | Ok(_) as value => value
-        | Error(_) as error => error
-        }
-      | Error(_) => Decco.error(~path="", "Not an integer", json)
-      }
-    | _ => Decco.error(~path="", "Not a number", json)
-    }
+  let isEqual = (a: t, b: t): bool => {
+    a.start->Js.Date.toString === b.start->Js.Date.toString &&
+      a.end_->Js.Date.toString === b.end_->Js.Date.toString
+  }
+}
 
-  let codec = (encoder, decoder)
+module DateTimeSlot = {
+  @spice
+  type t = {
+    start: Date.t,
+    @as("end") @spice.key("end")
+    end_: Date.t,
+  }
 
-  @decco
-  type t = @decco.codec(codec) int
+  let isEqual = (a: t, b: t): bool => {
+    a.start->Js.Date.toString === b.start->Js.Date.toString &&
+      a.end_->Js.Date.toString === b.end_->Js.Date.toString
+  }
 }
 
-module Boolean = {
-  let encoder = value => value->Decco.boolToJson
+module Float = {
+  let encoder = value => value->Spice.floatToJson
 
   let decoder = json =>
     switch Js.Json.classify(json) {
-    | JSONFalse => Ok(false)
-    | JSONTrue => Ok(true)
+    | JSONNumber(_) =>
+      switch Spice.floatFromJson(json) {
+      | Ok(_) as value => value
+      | Error(_) as error => error
+      }
     | JSONString(_) =>
-      switch Decco.stringFromJson(json) {
+      switch Spice.stringFromJson(json) {
       | Ok(value) =>
-        switch Decco.boolFromJson(value->bool_of_string->Js.Json.boolean) {
+        switch Spice.floatFromJson(value->Js.Float.fromString->Js.Json.number) {
         | Ok(_) as value => value
         | Error(_) as error => error
         }
-      | Error(_) => Decco.error(~path="", "Not a boolean", json)
+      | Error(_) => Spice.error(~path="", "Not a number", json)
       }
-    | _ => Decco.error(~path="", "Not a boolean", json)
+    | _ => Spice.error(~path="", "Not a number", json)
     }
 
   let codec = (encoder, decoder)
 
-  @decco
-  type t = @decco.codec(codec) bool
+  @spice
+  type t = @spice.codec(codec) float
 }
 
-module Float = {
-  let encoder = value => value->Decco.floatToJson
+module Int = {
+  let encoder = value => value->Spice.intToJson
 
   let decoder = json =>
     switch Js.Json.classify(json) {
     | JSONNumber(_) =>
-      switch Decco.floatFromJson(json) {
+      switch Spice.intFromJson(json) {
       | Ok(_) as value => value
       | Error(_) as error => error
       }
     | JSONString(_) =>
-      switch Decco.stringFromJson(json) {
+      switch Spice.stringFromJson(json) {
       | Ok(value) =>
-        switch Decco.floatFromJson(value->Js.Float.fromString->Js.Json.number) {
+        switch Spice.intFromJson(value->Js.Float.fromString->Js.Json.number) {
         | Ok(_) as value => value
         | Error(_) as error => error
         }
-      | Error(_) => Decco.error(~path="", "Not a number", json)
+      | Error(_) => Spice.error(~path="", "Not an integer", json)
       }
-    | _ => Decco.error(~path="", "Not a number", json)
+    | _ => Spice.error(~path="", "Not a number", json)
     }
 
   let codec = (encoder, decoder)
 
-  @decco
-  type t = @decco.codec(codec) float
-}
-
-module type EnumConfig = {
-  type enum
-  let enumToJs: enum => string
-  let enumFromJs: string => option<enum>
+  @spice
+  type t = @spice.codec(codec) int
 }
 
-module Enum = (Config: EnumConfig) => {
-  %%private(
-    let encoder = value => value->Config.enumToJs->Decco.stringToJson
+module Boolean = {
+  let encoder = value => value->Spice.boolToJson
 
-    let decoder = json =>
-      switch Decco.stringFromJson(json) {
+  let decoder = json =>
+    switch Js.Json.classify(json) {
+    | JSONFalse => Ok(false)
+    | JSONTrue => Ok(true)
+    | JSONString(_) =>
+      switch Spice.stringFromJson(json) {
       | Ok(value) =>
-        switch Config.enumFromJs(value) {
-        | None => Decco.error(~path="", "Invalid enum " ++ value, json)
-        | Some(value) => Ok(value)
+        switch Spice.boolFromJson(value->bool_of_string->Js.Json.boolean) {
+        | Ok(_) as value => value
+        | Error(_) as error => error
         }
-      | Error(_) as error => error
+      | Error(_) => Spice.error(~path="", "Not a boolean", json)
       }
-
-    let codec = (encoder, decoder)
-  )
-
-  let toString = v => v->Config.enumToJs
-  let fromString = v => v->Config.enumFromJs
-
-  @decco
-  type t = @decco.codec(codec) Config.enum
-}
-
-module Option = {
-  let encoder = (encoder, value) =>
-    switch value {
-    | None => %raw("undefined")
-    | Some(value) => encoder(value)
+    | _ => Spice.error(~path="", "Not a boolean", json)
     }
 
-  let decoder = (decoder, json) =>
-    json !== %raw("undefined") ? Decco.optionFromJson(decoder, json) : Ok(None)
-
   let codec = (encoder, decoder)
 
-  @decco
-  type t<'a> = @decco.codec((encoder, decoder)) option<'a>
+  @spice
+  type t = @spice.codec(codec) bool
 }
 
-module UnitMeasure = {
-  module type MakeConfig = {
-    type t
-    let toString: t => string
-    let toValue: t => float
-    let display: (t, ~digits: int=?, unit) => string
-
-    let wrapValue: float => t
-  }
-
-  module Make = (C: MakeConfig) => {
-    type dimension = C.t
-
-    let encoder: Decco.encoder<C.t> = value => value->C.toString->Decco.stringToJson
-
-    let decoder: Decco.decoder<C.t> = json =>
-      switch Decco.floatFromJson(json) {
-      | Ok(v) => v->C.wrapValue->Ok
-      | Error(_) as err => err
-      }
-
-    let codec: Decco.codec<dimension> = (encoder, decoder)
-
-    let toValue = C.toValue
-    let display = C.display
-    let toString = C.toString
-
-    @decco
-    type t = @decco.codec(codec) C.t
-  }
-
-  module type MakeWithUnitConfig = {
-    type t
-    let toString: t => string
-    let toValue: t => float
-    let display: (t, ~digits: int=?, unit) => string
-
-    type unitEnum
-    let unitEnum_decode: Js.Json.t => result<unitEnum, Decco.decodeError>
-    let unitEnum_encode: unitEnum => Js.Json.t
-
-    let wrapValue: (unitEnum, float) => t
-
-    let errorPrefix: string
-  }
-
-  module MakeWithUnit = (Config: MakeWithUnitConfig) => {
-    let decodeFromString = (string: string) => {
-      // match a positive int or float followed by it's unit (capturing int/float in group1 and unit in group2)
-      let regexp = %re("/^(\d+(?:\.\d*)?)\s*(\D*)$/")
-
-      // regexpCaptures: [match , captureGroup1, captureGroup2]
-      let regexpCaptures =
-        Js.Re.exec_(regexp, string)->Belt.Option.map(r =>
-          r->Js.Re.captures->Array.map(Js.Nullable.toOption)
-        )
-
-      let jsonString = string->Js.Json.string
-
-      let errorPrefix = Config.errorPrefix
-
-      switch regexpCaptures {
-      | None => Decco.error(`${errorPrefix} unhandled format`, jsonString)
-      | Some([None, _value, _unit]) => Decco.error(`${errorPrefix} unhandled format`, jsonString)
-      | Some([_match, _value, None]) => Decco.error(`${errorPrefix} unhandled no unit`, jsonString)
-      | Some([_match, None, _unit]) => Decco.error(`${errorPrefix} unhandled no value`, jsonString)
-      | Some([Some(_match), Some(value), Some(unit)]) => {
-          let value = value->Js.Float.fromString
-          switch unit
-          // regex captures adjacent to spaces to slashes and deletes them (for composite units)
-          ->Js.String2.replaceByRe(%re("/ *\/ */"), "/")
-          ->Js.Json.string
-          ->Config.unitEnum_decode {
-          | Ok(unit) => Config.wrapValue(unit, value)->Ok
-          | Error(_) => Decco.error(`${errorPrefix} unhandled unit '${unit}'`, jsonString)
-          }
-        }
-
-      | Some(_) => Decco.error(`${errorPrefix} regex capture group error`, jsonString)
-      }
-    }
-
-    %%private(
-      let encoder: Decco.encoder<Config.t> = value => value->Config.toString->Decco.stringToJson
-      let decoder: Decco.decoder<Config.t> = json =>
-        switch Decco.stringFromJson(json) {
-        | Ok(v) => v->decodeFromString
-        | Error(_) as err => err
-        }
-      let codec: Decco.codec<Config.t> = (encoder, decoder)
-    )
-
-    let toValue = Config.toValue
-    let toString = Config.toString
-    let display = Config.display
-
-    @decco
-    type t = @decco.codec(codec) Config.t
-  }
-
-  module Dimension = {
-    module Config = Toolkit__Utils_UnitMeasure.Dimension
-
-    module WithUnit = MakeWithUnit({
-      include Config
-      let errorPrefix = "Dimension with unit"
-    })
-
-    module Mm = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#mm)
-    })
-    module Cm = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#cm)
-    })
-    module Dm = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#dm)
-    })
-    module M = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#m)
-    })
-    module Km = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#km)
-    })
-  }
-
-  module Speed = {
-    module Config = Toolkit__Utils_UnitMeasure.Speed
-
-    module WithUnit = MakeWithUnit({
-      include Config
-      let errorPrefix = "Speed with unit"
-    })
-
-    module Km_h = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#km_h)
-    })
-  }
-
-  module Volume = {
-    module Config = Toolkit__Utils_UnitMeasure.Volume
-
-    module WithUnit = MakeWithUnit({
-      include Config
-      let errorPrefix = "Volume with unit"
-    })
-
-    module M3 = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#m3)
-    })
-  }
-
-  module EnergyCapacity = {
-    module Config = Toolkit__Utils_UnitMeasure.EnergyCapacity
-
-    module WithUnit = MakeWithUnit({
-      include Config
-      let errorPrefix = "EnergyCapacity with unit"
-    })
-
-    module KWh = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#kWh)
-    })
-  }
-
-  module Weight = {
-    module Config = Toolkit__Utils_UnitMeasure.Weight
-
-    module WithUnit = MakeWithUnit({
-      include Config
-      let errorPrefix = "Weight with unit"
-    })
-
-    module G = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#g)
-    })
-    module Kg = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#kg)
-    })
-  }
-
-  module Time = {
-    module Config = Toolkit__Utils_UnitMeasure.Time
-
-    module WithUnit = MakeWithUnit({
-      include Config
-      let errorPrefix = "Time with unit"
-    })
-
-    module S = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#s)
-    })
-    module Min = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#min)
-    })
-    module H = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#h)
-    })
-  }
-
-  module Currency = {
-    module Config = Toolkit__Utils_UnitMeasure.Currency
-
-    module WithUnit = MakeWithUnit({
-      include Config
-      let errorPrefix = "Curency with unit"
-    })
-
-    module EUR = Make({
-      include Config
-      let wrapValue = Config.wrapValue(#EUR)
-    })
-  }
-
-  module CompositeUnits = {
-    module CurrencyPerDistance = {
-      module Config = Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance
-
-      module WithUnit = MakeWithUnit({
-        include Config
-        let errorPrefix = "Curency per distance with unit"
-      })
-
-      module EUR_km = Make({
-        include Config
-        let wrapValue = Config.wrapValue(#EUR_km)
-      })
-    }
-    module CurrencyPerTime = {
-      module Config = Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerTime
-
-      module WithUnit = MakeWithUnit({
-        include Config
-        let errorPrefix = "Curency per time with unit"
-      })
-
-      module EUR_h = Make({
-        include Config
-        let wrapValue = Config.wrapValue(#EUR_h)
-      })
-    }
-  }
-}
-
-// StringArray
-//  This coddec is intended for encoding the array params of API requests of scala services
-//  Ex decode: Js.Json.string("1 cm,40 m,3 km") => [|`cm(1),`m(40),`km(3)|]: array(Toolkit.Utils.UnitMeasure.Dimension.t)
-//  Ex encode: [|`cm(1.),`m(40.),`km(3.)|] => "1.00 cm,40.00 m,3.00 km": Js.Json.t
+module UnitMeasure = Decoders__UnitMeasure
 
 module StringArray = {
   let encoder = (encoder, value) =>
-    value->Array.map(encoder)->Js.Array2.joinWith(",")->Decco.stringToJson
+    value->Array.map(encoder)->Js.Array2.joinWith(",")->Spice.stringToJson
 
   let decoder = (decoder, json) =>
-    switch json->Decco.stringFromJson {
+    switch json->Spice.stringFromJson {
     | Ok(string) =>
       let resultArray = string->Js.String2.split(",")->Array.map(e => e->Js.Json.string->decoder)
       let error = resultArray->Array.getBy(Result.isError)
       switch error {
-      | Some(_) => Decco.error(~path="", "Invalid content", json)
+      | Some(_) => Spice.error(~path="", "Invalid content", json)
       | None => Ok(resultArray->Array.map(Result.getExn))
       }
     | Error(_) as error => error
@@ -439,62 +201,6 @@ module StringArray = {
 
   let codec = (encoder, decoder)
 
-  @decco
-  type t<'a> = @decco.codec((encoder, decoder)) array<'a>
-}
-
-module SortOrder = Enum({
-  @deriving(jsConverter)
-  type enum = [#asc | #desc]
-})
-
-module Coordinates = {
-  @decco
-  type t = {
-    latitude: float,
-    longitude: float,
-  }
-  let make = (~lat: float, ~lng: float): t => {latitude: lat, longitude: lng}
-  let areEquals = (a: t, b: t): bool => a.latitude === b.latitude && a.longitude === b.longitude
-  let fromJs = value => {
-    latitude: (value->Obj.magic)["lat"](),
-    longitude: (value->Obj.magic)["lng"](),
-  }
-  type gmaps = {
-    lat: float,
-    lng: float,
-  }
-  let toGmaps = (t: t): gmaps => {lat: t.latitude, lng: t.longitude}
-  let fromGmaps = (gmaps: gmaps) => {
-    latitude: gmaps.lat,
-    longitude: gmaps.lng,
-  }
-}
-
-module DatetimeTimeSlot = {
-  @decco
-  type t = {
-    start: Datetime.t,
-    @as("end") @decco.key("end")
-    end_: Datetime.t,
-  }
-
-  let isEqual = (a: t, b: t): bool => {
-    a.start->Js.Date.toString === b.start->Js.Date.toString &&
-      a.end_->Js.Date.toString === b.end_->Js.Date.toString
-  }
-}
-
-module DateTimeSlot = {
-  @decco
-  type t = {
-    start: Date.t,
-    @as("end") @decco.key("end")
-    end_: Date.t,
-  }
-
-  let isEqual = (a: t, b: t): bool => {
-    a.start->Js.Date.toString === b.start->Js.Date.toString &&
-      a.end_->Js.Date.toString === b.end_->Js.Date.toString
-  }
+  @spice
+  type t<'a> = @spice.codec((encoder, decoder)) array<'a>
 }

package/src/decoders/index.md

@@ -19,7 +19,7 @@ module Lift = Toolkit.Decoder.Enum(LiftEnum);
 /**
  * Later
  **/
-[@decco]
+[@spice]
 type response = {
   lift: Lift.t
 }
@@ -28,7 +28,7 @@ type response = {
 ### Decode a date
 
 ```rescript
-[@decco]
+[@spice]
 type response = {
   createdAt: Toolkit.Decoder.Date.t
 }
@@ -44,7 +44,7 @@ There are 2 options :
 #### Automatic unit handling
 
 ```rescript
-[@decco]
+[@spice]
 type response = {
   length: Toolkit.Decoder.UnitMeasure.Dimension.WithUnit.t
 }
@@ -53,7 +53,7 @@ type response = {
 #### Known unit
 
 ```rescript
-[@decco]
+[@spice]
 type response = {
   weight: Toolkit.Decoder.UnitMeasure.Weight.Kg.t
 }
@@ -64,7 +64,7 @@ type response = {
 This codec is intended for encoding the array params of API requests of scala services.
 
 ```rescript
-[@decco]
+[@spice]
 type params = {
   lengths: Toolkit.Decoder.StringArray(Toolkit.Decoder.UnitMeasure.Dimension.WithUnit.t)
 };