@colisweb/rescript-toolkit 2.8.5 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colisweb/rescript-toolkit",
-  "version": "2.8.5",
+  "version": "2.10.0",
   "scripts": {
     "clean": "rescript clean",
     "build": "rescript build",
@@ -55,6 +55,7 @@
     "postcss-loader": "4.2.0",
     "postcss-preset-env": "6.7.0",
     "prismjs": "1.25.0",
+    "react-datepicker": "3.8.0",
     "react-icons": "4.3.1",
     "react-select": "5.2.1",
     "react-table": "7.7.0",
@@ -67,12 +68,11 @@
     "rescript-logger": "2.0.2",
     "rescript-react-update": "5.0.0",
     "restorative": "0.4.0-beta.1",
+    "sanitize-html": "2.6.1",
     "swr": "1.1.1",
-    "tailwindcss": "3.0.2",
-    "react-datepicker": "3.8.0"
+    "tailwindcss": "3.0.2"
   },
   "devDependencies": {
-    "highlight.js": "11.3.1",
     "@babel/core": "7.16.5",
     "@storybook/addon-actions": "6.1.21",
     "@storybook/addon-essentials": "6.1.21",
@@ -82,6 +82,7 @@
     "@storybook/react": "6.1.21",
     "@storybook/theming": "6.1.21",
     "babel-loader": "8.2.3",
+    "highlight.js": "11.3.1",
     "raw-loader": "4.0.2",
     "react": "17.0.2",
     "react-dom": "17.0.2",

package/src/request/Toolkit__Request.res

@@ -203,37 +203,3 @@ let delete = (
   | Some(c) =>
     request->Axios.Instance.deletec(url, c)->toResult(~mapError?, ~errorDecoder?, mapData)
   }
-
-module Error = {
-  type rec errorType = [
-    | #overlappingActivations(array<activation>)
-    | #compileError(string)
-    | #accessRefused
-    | #unknown
-  ]
-  @decco and activation = {ruleTitle: string}
-
-  let encoder: Decco.encoder<errorType> = _v => ""->Decco.stringToJson
-
-  let decoder: Decco.decoder<errorType> = json => {
-    let error = json->Obj.magic
-    let value = switch error["code"] {
-    | Some("OVERLAPPING_ACTIVATIONS") =>
-      #overlappingActivations(
-        error["overlapped"]->Obj.magic->Array.map(a => a->activation_decode->Result.getExn),
-      )
-
-    | Some("COMPILE_ERROR") => #compileError(error["compileError"]->Obj.magic)
-    | Some("ACCESS_REFUSED") => #accessRefused
-
-    | _ => #unknown
-    }
-
-    value->Ok
-  }
-
-  let codec: Decco.codec<errorType> = (encoder, decoder)
-
-  @decco
-  type t = @decco.codec(codec) errorType
-}

package/src/request/Toolkit__Request2.res

@@ -0,0 +1,12 @@
+module type Config = {
+  type argument
+  type response
+  type error
+  let exec: argument => Promise.promise<
+    result<response, Axios2.WithResult.customError<error, 'res, 'header, 'req>>,
+  >
+}
+
+module Make = (Config: Config) => {
+  include Config
+}

package/src/ui/Toolkit__Ui_RichText.res

@@ -1,7 +1,22 @@
 let transformUrl = text =>
   text |> Js.String.unsafeReplaceBy0(%re("/(https?:\\/\\/[^\\s]+)/g"), (url, _, _) =>
-    j`<a target='_blank' class='text-blue-500 underline' href="$url">$url</a>`
+    j`<a target='_blank' class='text-info-500 underline' href="$url">$url</a>`
   )
 
+@module("sanitize-html")
+external sanitizeHtml: (string, Js.t<'a>) => string = "default"
+
 @react.component
-let make = (~text) => <span dangerouslySetInnerHTML={"__html": text->transformUrl} />
+let make = (~text) =>
+  <span
+    dangerouslySetInnerHTML={
+      "__html": text
+      ->sanitizeHtml({
+        "allowedTags": ["a"],
+        "allowedAttributes": {
+          "a": ["href"],
+        },
+      })
+      ->transformUrl,
+    }
+  />

package/src/unleash/Toolkit__Unleash.res

@@ -27,19 +27,10 @@ module MakeFeature = (C: Config) => {
   type t = config<C.argument>
 
   let exec = (var: C.input) =>
-    (Axios.get(C.envUrl ++ C.featureName)
-    |> Js.Promise.then_(res => res["data"]->Js.Promise.resolve)
-    |> Js.Promise.then_(data =>
-      switch t_decode(data) {
-      | Result.Ok(feat) => Js.Promise.resolve(feat)
-      | Result.Error(_err) =>
-        %log.error(
-          "unleash decode"
-          ("err", _err)
-        )
-        Js.Promise.reject(Js.Exn.raiseError(C.featureName ++ " : parse error"))
-      }
-    )
-    |> Promise.Js.fromBsPromise
-    |> Promise.Js.toResult)->Promise.mapOk(C.exec(var))
+    Axios2.get(C.envUrl ++ C.featureName, ())
+    ->Promise.Js.toResult
+    ->Promise.flatMapOk(({data}) => {
+      Promise.resolved(t_decode(data))
+    })
+    ->Promise.mapOk(C.exec(var))
 }

package/src/vendors/Axios2.res

@@ -0,0 +1,203 @@
+type config
+
+module Headers = {
+  type t
+
+  external fromObj: Js.t<{..}> => t = "%identity"
+  external fromDict: Js.Dict.t<string> => t = "%identity"
+}
+
+module CancelToken = {
+  type t
+
+  @module("axios")
+  external source: unit => t = "source"
+}
+
+type requestTransformer<'data, 'a, 'transformedData> = ('data, Js.t<'a>) => 'transformedData
+type responseTransformer<'data, 'transformedData> = 'data => 'transformedData
+type paramsSerializer<'params, 'serializedParams> = 'params => 'serializedParams
+type auth = {
+  username: string,
+  password: string,
+}
+type proxy = {host: int, port: int, auth: auth}
+
+type response<'data, 'header> = {
+  data: 'data,
+  status: int,
+  statusText: string,
+  headers: Js.t<'header>,
+  config: config,
+}
+
+type error<'responseData, 'responseHeader, 'request> = {
+  request: option<'request>,
+  response: option<response<'responseData, 'responseHeader>>,
+  message: string,
+}
+
+type adapter<'a, 'b, 'err> = config => Promise.Js.t<response<'a, 'b>, 'err>
+
+@module("axios")
+external isAxiosError: error<'a, 'b, 'c> => bool = "isAxiosError"
+
+@obj
+external makeConfig: (
+  ~url: string=?,
+  ~_method: string=?,
+  ~baseURL: string=?,
+  ~transformRequest: array<requestTransformer<'data, Js.t<'a>, 'tranformedData>>=?,
+  ~transformResponse: array<responseTransformer<'data, 'tranformedData>>=?,
+  ~headers: Headers.t=?,
+  ~params: Js.t<'params>=?,
+  ~paramsSerializer: paramsSerializer<'params, 'serializedParams>=?,
+  ~data: Js.t<'data>=?,
+  ~timeout: int=?,
+  ~withCredentials: bool=?,
+  ~adapter: adapter<'a, 'b, 'err>=?,
+  ~auth: auth=?,
+  ~responseType: string=?,
+  ~xsrfCookieName: string=?,
+  ~xsrfHeaderName: string=?,
+  ~onUploadProgress: 'uploadProgress => unit=?,
+  ~onDownloadProgress: 'downloadProgress => unit=?,
+  ~maxContentLength: int=?,
+  ~validateStatus: int => bool=?,
+  ~maxRedirects: int=?,
+  ~socketPath: string=?,
+  ~proxy: proxy=?,
+  ~cancelToken: CancelToken.t=?,
+  unit,
+) => config = ""
+
+@module("axios")
+external get: (string, ~config: config=?, unit) => Promise.Js.t<response<'data, 'headers>, 'err> =
+  "get"
+
+@module("axios")
+external post: (
+  string,
+  ~data: 'a,
+  ~config: config=?,
+  unit,
+) => Promise.Js.t<response<'data, 'headers>, 'err> = "post"
+
+@module("axios")
+external put: (
+  string,
+  ~data: 'a,
+  ~config: config=?,
+  unit,
+) => Promise.Js.t<response<'data, 'headers>, 'err> = "put"
+
+@module("axios")
+external patch: (
+  string,
+  ~data: 'a,
+  ~config: config=?,
+  unit,
+) => Promise.Js.t<response<'data, 'headers>, 'err> = "patch"
+
+@module("axios")
+external delete: (
+  string,
+  ~config: config=?,
+  unit,
+) => Promise.Js.t<response<'data, 'headers>, 'err> = "delete"
+
+@module("axios")
+external options: (
+  string,
+  ~config: config=?,
+  unit,
+) => Promise.Js.t<response<'data, 'headers>, 'err> = "options"
+
+module Interceptors = {
+  @module("axios") @scope(("default", "interceptors", "request"))
+  external requestInterceptor: ('config => Promise.Js.t<'updatedConfig, 'error>) => unit = "use"
+
+  @module("axios") @scope(("default", "interceptors", "response"))
+  external responseInterceptor: ('response => Promise.Js.t<'updatedResponse, 'error>) => unit =
+    "use"
+}
+
+module WithResult = {
+  type customError<'apiError, 'response, 'headers, 'request> = [
+    | #default(error<'response, 'headers, 'request>)
+    | #decodeError(Decco.decodeError)
+    | #custom('apiError)
+  ]
+
+  type decodeData<'newData, 'err> = Js.Json.t => result<'newData, 'err>
+
+  type mapError<'a, 'response, 'headers, 'request> = error<
+    'response,
+    'headers,
+    'request,
+  > => customError<'a, 'response, 'headers, 'request>
+
+  let toResult = (promise, ~mapError, ~decodeData) =>
+    promise
+    ->Promise.Js.toResult
+    ->Promise.mapError(err => mapError->Option.mapWithDefault(#default(err), fn => fn(err)))
+    ->Promise.flatMapOk(response => {
+      Promise.resolved(
+        switch decodeData(response.data) {
+        | Ok(_) as ok => ok
+        | Error(decodeError) => Error(#decodeError(decodeError))
+        },
+      )
+    })
+
+  let get = (
+    string,
+    ~config=?,
+    ~decodeData: decodeData<'newData, 'err>,
+    ~mapError: option<mapError<'a, 'response, 'headers, 'request>>=?,
+    unit,
+  ) => get(string, ~config?, unit)->toResult(~decodeData, ~mapError)
+
+  let post = (
+    string,
+    ~data,
+    ~config=?,
+    ~decodeData: decodeData<'newData, 'err>,
+    ~mapError: option<mapError<'a, 'response, 'headers, 'request>>=?,
+    unit,
+  ) => post(string, ~data, ~config?, unit)->toResult(~decodeData, ~mapError)
+
+  let put = (
+    string,
+    ~data,
+    ~config=?,
+    ~decodeData: decodeData<'newData, 'err>,
+    ~mapError: option<mapError<'a, 'response, 'headers, 'request>>=?,
+    unit,
+  ) => put(string, ~data, ~config?, unit)->toResult(~decodeData, ~mapError)
+
+  let patch = (
+    string,
+    ~data,
+    ~config=?,
+    ~decodeData: decodeData<'newData, 'err>,
+    ~mapError: option<mapError<'a, 'response, 'headers, 'request>>=?,
+    unit,
+  ) => patch(string, ~data, ~config?, unit)->toResult(~decodeData, ~mapError)
+
+  let delete = (
+    string,
+    ~config=?,
+    ~decodeData: decodeData<'newData, 'err>,
+    ~mapError: option<mapError<'a, 'response, 'headers, 'request>>=?,
+    unit,
+  ) => delete(string, ~config?, unit)->toResult(~decodeData, ~mapError)
+
+  let options = (
+    string,
+    ~config=?,
+    ~decodeData: decodeData<'newData, 'err>,
+    ~mapError: option<mapError<'a, 'response, 'headers, 'request>>=?,
+    unit,
+  ) => options(string, ~config?, unit)->toResult(~decodeData, ~mapError)
+}