Shared promises, simpler version of cached-promises

shared-promise-cache.ts

export type ToSlugFunction<T extends any[]> = (...args: T) => string

export const sharedPromiseCache = <T extends any[], R>(
  fn: (...args: T) => Promise<R>,
  toSlug: ToSlugFunction<T> = (...args: T) => JSON.stringify(args)
): ((...args: T) => Promise<R>) => {
  const cache = new Map<string, Promise<R>>()

  return async (...args: T): Promise<R> => {
    const key = toSlug(...args)

    if (cache.has(key)) {
      // Return the existing promise if found in the cache
      return cache.get(key)!
    }

    // Wrap the original function call in a promise to manage its lifecycle
    const promise = (async () => {
      try {
        // Call the original function with the arguments
        return await fn(...args)
      } finally {
        // Remove from cache when the promise is settled (resolved or rejected)
        cache.delete(key)
      }
    })()

    // Store the promise in the cache before returning it
    cache.set(key, promise)

    return promise
  }
}