@colisweb/rescript-toolkit 5.7.1 → 5.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colisweb/rescript-toolkit",
-  "version": "5.7.1",
+  "version": "5.8.1",
   "type": "module",
   "scripts": {
     "clean": "rescript clean",
@@ -29,7 +29,7 @@
   "dependencies": {
     "@colisweb/bs-react-intl-extractor-bin": "0.12.2",
     "@datadog/browser-rum": "5.8.0",
-    "@dck/rescript-ky": "2.0.1",
+    "@dck/rescript-ky": "2.0.4",
     "@dck/rescript-promise": "1.1.0",
     "@dck/restorative": "1.1.0",
     "@greenlabs/ppx-spice": "0.2.1",

package/rescript.json

@@ -34,7 +34,9 @@
     "@dck/rescript-ky"
   ],
   "ppx-flags": [
-    ["@greenlabs/ppx-spice/ppx"],
+    [
+      "@greenlabs/ppx-spice/ppx"
+    ],
     "lenses-ppx/ppx",
     "res-react-intl/ppx"
   ],
@@ -46,6 +48,7 @@
     "-bs-super-errors",
     "-bs-no-version-header",
     "-open Belt",
+    "-open Toolkit__Primitives_Result",
     "-open Cx"
   ]
-}
+}

package/src/primitives/Toolkit__Primitives.res

@@ -63,11 +63,3 @@ module Array = {
 
   let flatten = array => array->Array.reduce([], (acc, value) => acc->Array.concat(value))
 }
-
-module Result = {
-  let get = result =>
-    switch result {
-    | Ok(v) => Some(v)
-    | Error(_) => None
-    }
-}

package/src/primitives/Toolkit__Primitives_Result.res

@@ -0,0 +1,18 @@
+module Result = {
+  include Belt.Result
+
+  let get = result =>
+    switch result {
+    | Ok(v) => Some(v)
+    | Error(_) => None
+    }
+
+  let mapError = (result: t<'a, 'b>, fn: 'b => 'c) => {
+    switch result {
+    | Ok(_) as ok => ok
+    | Error(err) => Error(fn(err))
+    }
+  }
+
+  let mapOk = map
+}

package/src/request/Request.res

@@ -8,13 +8,13 @@ type requestConfig<'apiError, 'response> = {
   path: string,
   requestOptions: Ky.requestOptions<Js.Json.t>,
   key?: array<string>,
-  mapCustomErrors?: Ky.error => error<'apiError>,
-  mapRawResponse?: (result<Js.Json.t, Ky.error>, Ky.Response.t) => result<'response, error<'apiError>>,
+  mapCustomErrors?: Ky.error => Promise.t<error<'apiError>>,
+  mapRawResponse?: result<Js.Json.t, Ky.error> => Promise.t<result<'response, error<'apiError>>>,
 }
 
 %%private(
   let fetch = (
-    ~instance=?,
+    ~instance,
     ~path,
     ~requestOptions,
     ~mapRawResponse=?,
@@ -25,35 +25,40 @@ type requestConfig<'apiError, 'response> = {
     // - parseJson
     // - abort controller signal
 
-    let kyResponse = instance->Option.mapWithDefault(Ky.fetch(path, requestOptions), instance => {
-      (instance->Ky.Instance.asCallable)(path, ~options=requestOptions)
-    })
-    kyResponse
-    ->Ky.Response.json()
+    (instance->Ky.Instance.asCallable)(path, ~options=requestOptions)
+    ->Ky.Response.jsonFromPromise()
     ->Promise.Js.fromBsPromise
     ->Promise.Js.toResult
     ->Promise.flatMap(result => {
       let result: result<Js.Json.t, Ky.error> = result->Obj.magic
 
       let mapRawResponseOrDecode = switch mapRawResponse {
-      | Some(fn) => fn(result, kyResponse)
+      | Some(fn) => fn(result)
       | None =>
-        switch result {
-        | Error(err) => Error(Unknown(err))
-        | Ok(response) =>
-          switch response->response_decode {
-          | Ok(response) => Ok(response)
-          | Error(decodeError) => Error(DecodeError(decodeError))
-          }
-        }
+        Promise.resolved(
+          switch result {
+          | Error(err) => Error(Unknown(err))
+          | Ok(response) =>
+            switch response->response_decode {
+            | Ok(response) => Ok(response)
+            | Error(decodeError) => Error(DecodeError(decodeError))
+            }
+          },
+        )
       }
 
-      let mappedCustomErrors = switch mapRawResponseOrDecode {
-      | Error(Unknown(err)) => Error(mapCustomErrors->Option.mapWithDefault(Unknown(err), fn => fn(err)))
-      | _ as ok => ok
-      }
+      let mappedCustomErrors = mapRawResponseOrDecode->Promise.flatMapError(error => {
+        switch error {
+        | Unknown(err) =>
+          mapCustomErrors->Option.mapWithDefault(
+            Promise.resolved(Error(Unknown(err))),
+            fn => fn(err)->Promise.map(v => {Error(v)}),
+          )
+        | err => Promise.resolved(Error(err))
+        }
+      })
 
-      Promise.resolved(mappedCustomErrors)
+      mappedCustomErrors
     })
   }
 )
@@ -127,7 +132,7 @@ let useOptionalFetcher = (
     and type error = error
   ),
   argument: option<argument>,
-): Toolkit__Hooks.fetcher<response> => {
+): Toolkit__Hooks.fetcher<option<response>> => {
   let module(C) = config
 
   Toolkit__Hooks.useOptionalFetcher(
@@ -210,3 +215,12 @@ let decodeResponseError = (responseError, decoder) => {
   ->Promise.mapError(Obj.magic)
   ->Promise.flatMapOk(json => json->decoder->Promise.resolved)
 }
+
+let decodeRawResponse = (result: result<Js.Json.t, Ky.error>, decoder): result<
+  'a,
+  error<'apiError>,
+> => {
+  result
+  ->Result.mapError(err => Unknown(err))
+  ->Result.flatMap(json => json->decoder->Result.mapError(err => DecodeError(err)))
+}

package/src/request/index.md

@@ -4,100 +4,97 @@
 
 ```rescript
 module API = {
-  module FetchUsers = {
-    module Config = {
-      type argument = unit;
-
-      [@spice]
-      type response = array(user)
-      [@spice]
-      and user = {
-        name: string
-      };
-
-      type error = string;
-
-      let exec = clientId => {
-        request->Request.get(baseUrl(~clientId), response_decode);
-      };
-    };
+  let kyInstance = Ky.Instance.create({
+    prefixUrl: `${ColiswebApi__Env.v6ApiUrl}`,
+    timeout: ColiswebApi__Env.isNodeDevelopment ? 5000 : 20000,
+  })
 
-    module Request = Toolkit.Request.Make(Config);
+  module FetchUsers = {
+    type argument = ()
+
+    @spice
+    type user = {
+      id: string,
+      name: string
+    }
+
+    @spice
+    type response = {
+      users: array<user>
+    }
+
+    type error = unit
+
+    let config = () => {
+      kyInstance,
+      requestOptions: {
+        method: Ky.HttpMethod.GET,
+      },
+      key: [
+        "FetchUser"
+      ],
+      path: `/users`,
+    }
   };
 };
 
-API.FetchUsers.Request.exec();
+let (data, isLoading, _) = Request.useFetcher(module(API.FetchUsers), Some())
+
+Request.fetchAPI(module(API.FetchUsers), Some())
+->Promise.tapOk(({users}) => Js.log(users))
 ```
 
 ### Handle custom error
 
 ```rescript
 module API = {
+  let kyInstance = Ky.Instance.create({
+    prefixUrl: `${ColiswebApi__Env.v6ApiUrl}`,
+    timeout: ColiswebApi__Env.isNodeDevelopment ? 5000 : 20000,
+  })
+
   module FetchUsers = {
-    module Error = {
-      type errorType = [
-        | `overlappingActivations(array(activation))
-        | `compileError(string)
-        | `accessRefused
-        | `unknown
-      ]
-      [@spice]
-      and activation = {ruleTitle: string};
-
-      let encoder: Spice.encoder(errorType) = _v => ""->Spice.stringToJson;
-
-      let decoder: Spice.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: Spice.codec(errorType) = (encoder, decoder);
-
-      [@spice]
-      type t = [@spice.codec codec] errorType;
-    };
-
-    module Config = {
-      type argument = unit;
-
-      [@spice]
-      type response = array(user)
-      [@spice]
-      and user = {
-        name: string
-      };
-
-      [@spice]
-      type error = Error.t;
-
-      let exec = clientId => {
-        request->Request.get(baseUrl(~clientId), ~errorDecoder=error_decode,response_decode);
-      };
-    };
-
-    module Request = Toolkit.Request.Make(Config);
+    type argument = ()
+
+    @spice
+    type user = {
+      id: string,
+      name: string
+    }
+
+    @spice
+    type response = {
+      users: array<user>
+    }
+
+    type error = Anything
+
+    let config = () => {
+      kyInstance,
+      requestOptions: {
+        method: Ky.HttpMethod.GET,
+      },
+      key: [
+        "FetchUser"
+      ],
+      path: `/users`,
+      mapCustomErrors: error =>
+        switch error.response {
+        | Some({status: 409}) => Custom(Anything)
+        | _ => Unknown(error)
+        }->Promise.resolved,
+    }
   };
 };
 
-API.FetchUsers.Request.exec()
-->Promise.tapError(err => switch (err) {
-  | Custom(`accessRefused) => "handle refused access"
-  | Custom(`compileError(msg)) => msg
-  | _ => "else"
-});
+
+Request.fetchAPI(module(API.FetchUsers), Some())
+->Promise.tapOk(({users}) => Js.log(users))
+->Promise.tapError(error => {
+  switch error {
+    | Custom(Anything) => ...
+    | DecodeError(spiceError) => ...
+    | Unknown(kyError) => ...
+  }
+})
 ```

package/src/vendors/Swr.res

@@ -95,6 +95,8 @@ module SwrConfig = {
   external mutate0: (t, SwrKey.t) => unit = "mutate"
   @send
   external mutateByKey: (t, key) => unit = "mutate"
+  @send
+  external mutateByKeyWithParams: (t, key, 'data, bool) => unit = "mutate"
 
   @send
   external mutate: (t, SwrKey.t, 'data, bool) => unit = "mutate"