@colisweb/rescript-toolkit 2.9.0 → 2.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colisweb/rescript-toolkit",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "scripts": {
     "clean": "rescript clean",
     "build": "rescript build",

package/src/fetcher/Toolkit__Fetcher2.res

@@ -0,0 +1,28 @@
+module type Config = {
+  module Request: Toolkit__Request2.Config
+  let key: Request.argument => array<string>
+}
+
+module Make = (Config: Config) => {
+  let key: Config.Request.argument => array<string> = Config.key
+
+  let use = (
+    ~options: option<Swr.fetcherOptions>=?,
+    key: option<Config.Request.argument>,
+  ): Toolkit__Hooks.fetcher<Config.Request.response> =>
+    Toolkit__Hooks.useFetcher(~options?, key->Option.map(Config.key), () => {
+      let key = key->Option.getExn
+
+      Config.Request.exec(key)->Promise.Js.fromResult
+    })
+
+  let useOptional = (
+    ~options: option<Swr.fetcherOptions>=?,
+    key: option<Config.Request.argument>,
+  ): Toolkit__Hooks.fetcher<option<Config.Request.response>> =>
+    Toolkit__Hooks.useOptionalFetcher(~options?, key->Option.map(Config.key), () => {
+      let key = key->Option.getExn
+
+      Config.Request.exec(key)->Promise.Js.fromResult
+    })
+}

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, Js.Json.t, 'header, 'req>>,
+  >
+}
+
+module Make = (Config: Config) => {
+  include Config
+}

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)
+}