@colisweb/rescript-toolkit 5.4.2 → 5.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colisweb/rescript-toolkit",
-  "version": "5.4.2",
+  "version": "5.5.1",
   "type": "module",
   "scripts": {
     "clean": "rescript clean",
@@ -29,6 +29,7 @@
   "dependencies": {
     "@colisweb/bs-react-intl-extractor-bin": "0.12.2",
     "@datadog/browser-rum": "5.8.0",
+    "@dck/rescript-ky": "^2.0.0",
     "@dck/rescript-promise": "1.1.0",
     "@dck/restorative": "1.1.0",
     "@greenlabs/ppx-spice": "0.2.1",
@@ -43,6 +44,7 @@
     "copy-to-clipboard": "3.3.3",
     "date-fns": "3.2.0",
     "dedent": "0.7.0",
+    "ky": "^1.2.4",
     "lenses-ppx": "6.1.10",
     "list-selectors": "2.0.1",
     "lodash": "4.17.21",

package/rescript.json

@@ -30,7 +30,8 @@
     "@greenlabs/ppx-spice",
     "rescript-classnames",
     "rescript-react-update",
-    "@dck/restorative"
+    "@dck/restorative",
+    "@dck/rescript-ky"
   ],
   "ppx-flags": [
     ["@greenlabs/ppx-spice/ppx"],

package/src/request/Request.res

@@ -0,0 +1,205 @@
+type error<'apiError> =
+  | DecodeError(Spice.decodeError)
+  | Unknown(Ky.error<Js.Json.t>)
+  | Custom('apiError)
+
+type requestConfig<'apiError, 'response> = {
+  path: string,
+  requestOptions: Ky.requestOptions<Js.Json.t, Js.Json.t, Js.Json.t, 'response>,
+  key?: array<string>,
+  customError?: Ky.error<Js.Json.t> => Promise.t<error<'apiError>>,
+  mapPromise?: Js.Json.t => result<'response, error<'apiError>>,
+}
+
+%%private(
+  let fetch = (
+    ~instance,
+    ~path,
+    ~requestOptions,
+    ~mapPromise=?,
+    ~customError=?,
+    ~response_decode,
+  ) => {
+    // TODO :
+    // - parseJson
+    // - abort controller signal
+    Ky.Instance.asCallable(instance)(path, ~options=requestOptions)
+    ->Ky.Response.json()
+    ->Promise.Js.fromBsPromise
+    ->Promise.Js.toResult
+    ->Promise.flatMap(response => {
+      switch response {
+      | Error(err) => {
+          let error: Ky.error<'a> = err->Obj.magic
+          customError->Option.mapWithDefault(Promise.resolved(Error(Unknown(error))), fn =>
+            fn(error)->Promise.map(e => Error(e))
+          )
+        }
+      | Ok(response) =>
+        switch mapPromise {
+        | None =>
+          Promise.resolved(
+            switch response->response_decode {
+            | Ok(_) as ok => ok
+            | Error(decodeError) => Error(DecodeError(decodeError))
+            },
+          )
+        | Some(fn) => Promise.resolved(fn(response))
+        }
+      }
+    })
+  }
+)
+module type Config = {
+  type argument
+  type response
+  type error
+  let instance: Ky.Instance.t
+  let response_decode: Js.Json.t => result<response, Spice.decodeError>
+  let config: argument => requestConfig<error, response>
+}
+
+let fetchAPI = (
+  type argument response err,
+  config: module(Config with
+    type argument = argument
+    and type response = response
+    and type error = err
+  ),
+  argument: argument,
+): Promise.t<result<response, error<err>>> => {
+  let module(C) = config
+  let requestConfig = C.config(argument)
+
+  fetch(
+    ~instance=C.instance,
+    ~path=requestConfig.path,
+    ~response_decode=C.response_decode,
+    ~requestOptions=requestConfig.requestOptions,
+    ~customError=?requestConfig.customError,
+    ~mapPromise=?requestConfig.mapPromise,
+  )
+}
+let useFetcher = (
+  type argument response error,
+  ~options: option<Swr.fetcherOptions>=?,
+  config: module(Config with
+    type argument = argument
+    and type response = response
+    and type error = error
+  ),
+  argument: option<argument>,
+): Toolkit__Hooks.fetcher<response> => {
+  let module(C) = config
+
+  Toolkit__Hooks.useFetcher(
+    ~options?,
+    argument->Option.flatMap(argument => {
+      let requestConfig = C.config(argument)
+
+      switch requestConfig.key->Obj.magic {
+      | None =>
+        Js.Exn.raiseError(
+          `You are using a config without a key for this path ${requestConfig.path}`,
+        )
+      | Some(key) => key
+      }
+    }),
+    () => {
+      fetchAPI(config, argument->Option.getExn)->Promise.Js.fromResult
+    },
+  )
+}
+
+let useOptionalFetcher = (
+  type argument response error,
+  ~options: option<Swr.fetcherOptions>=?,
+  config: module(Config with
+    type argument = argument
+    and type response = response
+    and type error = error
+  ),
+  argument: option<argument>,
+): Toolkit__Hooks.fetcher<response> => {
+  let module(C) = config
+
+  Toolkit__Hooks.useOptionalFetcher(
+    ~options?,
+    argument->Option.flatMap(argument => {
+      let requestConfig = C.config(argument)
+
+      switch requestConfig.key->Obj.magic {
+      | None =>
+        Js.Exn.raiseError(
+          `You are using a config without a key for this path ${requestConfig.path}`,
+        )
+      | Some(key) => key
+      }
+    }),
+    () => {
+      fetchAPI(config, argument->Option.getExn)->Promise.Js.fromResult
+    },
+  )
+}
+
+type state<'data, 'error> =
+  | NotAsked
+  | Loading
+  | Done(result<'data, 'error>)
+
+%%private(
+  let minInt = -999999999
+  let maxInt = 1000000000
+
+  let increment = (num: int): int => num !== maxInt ? num + 1 : minInt
+)
+
+let useManualRequest = (
+  type argument response error,
+  config: module(Config with
+    type argument = argument
+    and type response = response
+    and type error = error
+  ),
+) => {
+  let module(Config) = config
+
+  let lastCallId = React.useRef(0)
+  let canceled = React.useRef(false)
+  let (state, set) = React.useState(() => NotAsked)
+  let isMounted = ReactUse.useMountedState(.)
+
+  let trigger = argument => {
+    lastCallId.current = lastCallId.current->increment
+    let callId = lastCallId.current
+
+    set(_ => Loading)
+
+    canceled.current = false
+
+    fetchAPI(module(Config), argument)->Promise.map(result => {
+      let isCanceled = callId !== lastCallId.current || canceled.current
+
+      if isMounted() && !isCanceled {
+        set(_ => Done(result))
+      }
+
+      (result, isCanceled)
+    })
+  }
+
+  let cancel = React.useCallback(() => canceled.current = true, [])
+
+  (state, trigger, cancel)
+}
+
+external exnToError: Js.Exn.t => error<'a> = "%identity"
+
+let decodeResponseError = (responseError, decoder) => {
+  responseError
+  ->Ky.Response.json()
+  ->Promise.Js.fromBsPromise
+  ->Promise.Js.toResult
+  ->Promise.mapError(Obj.magic)
+  ->Promise.flatMapOk(json => json->decoder->Promise.resolved)
+}

package/src/vendors/Swr.res

@@ -63,6 +63,11 @@ type mutationFetcher<'params, 'data, 'error> = {
 
 module SwrKey = Toolkit__Identifier.MakeString()
 
+@unboxed
+type key =
+  | String(string)
+  | Array(array<string>)
+
 @module("swr")
 external useSwr: (option<SwrKey.t>, 'fn, 'fetcherOptions) => fetcher<'data> = "default"
 
@@ -88,6 +93,8 @@ module SwrConfig = {
 
   @send
   external mutate0: (t, SwrKey.t) => unit = "mutate"
+  @send
+  external mutateByKey: (t, key) => unit = "mutate"
 
   @send
   external mutate: (t, SwrKey.t, 'data, bool) => unit = "mutate"