equt / fetch

Declarative WHATWG Fetch Wrapper

Declarative WHATWG Fetch Wrapper

fetch's Issues

`withURLSearchParams` Cannot Be Set After `withBaseURL` Combinator

More Tests to Make Sure Order

Allow `when` Combinator to Inspect Last Output

Currently, the when could only accept a lazy boolean value, indicating whether the giving combinator should be running or not. We should instead extend the prediction function, to allow it to inspect the data flow.

pipe(
  request,
  asJSON(),
  decodeAs(/* */),
  when(
    ({ succeeded }) => succeeded,
    fail(() => /* */)
  ),
)

Add More Generic Combinators

Tracking Status

• #13

Higher Order Combinator: Retry

Proposal

From the user's perspective, there should be three components

• Retry Policy

  type Policy = Nullable<number>

  If it's non-nullable, i.e., not undefined or null, the executor will wait that amount of time, then re-execute it.

• Retry Strategy

  type Strategy<E> = {
    (error: E, times: number): Policy
  }

  Strategy will be called if there is an error, and it decides when & how the retry should happen.

• HoC Retry

TODO

• Where should the retry be placed?
• Should retry handle the bailed?

Support io-ts

Tracking Issue for 5.0

TODO

• Remove withUsername, withPassword, and decodeAs combinators
• Provide a build alternative to runFetchM variants, which will return the built Either<E, Request> without sending it
• Correct code doc links
• Require DOM.Iterable
• Allow withSignal and/or withTimeout occur multiple times (requires TypeScript 5.5)

References

• Fetch Exceptions - MDN

Better Error Handling

Different Error Sources

Currently, errors could come from two different sources

1. Rejected Promise, a.k.a., JS throws. According to the spec, it should either be a DOMException named AbortError, or TypeError for the rest.
2. Specially, a Response has a property called type, which could be error. This is set, for example, if the redirect in Request is error.

References

• fetch() global function - Web APIs | MDN
• Fetch Standard - Concept Network Error

Make `Lazy` into Function

We would like to have something like

const getUserProfile = pipe(
  base,
  withJSON((id: number, size: '1x' | '2x' = '2x') => ({ id, size })),
  asJSON(),
  runFetchMFlippedPT,
)

, where the sig could be automatically inferred by the compiler, which in this case, is (endpoint: string, args: { id: number; size?: '1x' | '2x' }) => Promise<Json>.

Combinator using `AbortController` not throw inside itself

`withBaseURL` Breaks on Invalid URL

Add URL Param Combinator

Add Base URL Combinator

Replace `fetch-mock` Testing Framework

I'm gonna suspend this until fetch gets implemented in Node, which should happen after Node 18 lands.

Add `StateT` into Monad Stack

Integrate with SWR Libs

Research

Vercel's SWR Lib

• The Fetcher type is defined as

export type Fetcher<
  Data = unknown,
  SWRKey extends Key = Key
> = SWRKey extends () => readonly [...infer Args] | null | undefined | false
  ? (...args: [...Args]) => FetcherResponse<Data>
  : SWRKey extends readonly [...infer Args]
  ? (...args: [...Args]) => FetcherResponse<Data>
  : SWRKey extends () => infer Arg | null | undefined | false
  ? (...args: [Arg]) => FetcherResponse<Data>
  : SWRKey extends null | undefined | false
  ? never
  : SWRKey extends infer Arg
  ? (...args: [Arg]) => FetcherResponse<Data>
  : never

As for code using @equt/fetch, dependencies are

+ export const createUser = (username: string, password: string) =>
  pipe(
    base,
    withMethod('POST'),
    withJSON({
      username,
      password,
    }),
+    runFetchM('user'),
  )

We don't actually use string interpolation to add params to create the desired URL, so our choices are either pass them into an Array, or as a Record.

• The Global Error Report section really convinces me a lot.
  • But if the error gets resolved inside the component, will it still be reported to the global wrapper?

Avoid Using Error