caches a fetch call based on the parameters passed to fetch and a unique identifier.

cachedFetch.ts

const memoryCache = new Map<string, any>()

/**
 * `resetCachedFetch` is a function that clears the cachedFetch cache.
 * It does not take any parameters and does not return any value.
 */
export const resetCachedFetch = () => memoryCache.clear()

/**
 * `cachedFetch` is a generic function that performs a fetch operation and caches the result.
 * If the same fetch operation is performed again (i.e., the same key and parameters are used),
 * the function will return the cached result instead of performing the fetch operation again.
 *
 * @param key - A unique identifier for the fetch operation.
 * @param fetch - The fetch function to be performed.
 * @param parameters - The parameters to be passed to the fetch function.
 * @returns  - The result of the fetch operation.
 */
export const cachedFetch = <T extends (...args: any) => Promise<any>>(
  key: string,
  fetch: T,
  ...parameters: Parameters<T>
): ReturnType<T> => {
  const cacheKey = JSON.stringify({
    uniqueKey: key,
    ...parameters
  })

  if (memoryCache.has(cacheKey)) return memoryCache.get(cacheKey)!

  // eslint-disable-next-line no-useless-call
  const response = fetch.call(null, ...parameters) as ReturnType<T>

  memoryCache.set(cacheKey, response)

  return response
}