const cache = new Map();
const inflight = new Map();

export default async function fetchWithCache(key, fetcher){
  if(cache.has(key)) return cache.get(key);
  const p = fetcher().then(res => { cache.set(key, res); inflight.delete(key); return res; });
  inflight.set(key, p);
  return p;
}

import fetchWithCache from './js-debug-async-race';

describe('fetchWithCache', () => {
  test('shares one in-flight request for concurrent callers', async () => {
    let calls = 0;
    const fetcher = async () => {
      calls++;
      await new Promise(r => setTimeout(r, 20));
      return 'OK';
    };

    const [a, b, c] = await Promise.all([
      fetchWithCache('k', fetcher),
      fetchWithCache('k', fetcher),
      fetchWithCache('k', fetcher)
    ]);

    expect(a).toBe('OK');
    expect(b).toBe('OK');
    expect(c).toBe('OK');
    expect(calls).toBe(1);
  });

  test('uses the cached value on later calls after success', async () => {
    let calls = 0;
    const fetcher = async () => {
      calls++;
      return 'VAL';
    };

    await fetchWithCache('x', fetcher);
    const v2 = await fetchWithCache('x', fetcher);

    expect(v2).toBe('VAL');
    expect(calls).toBe(1);
  });

  test('cleans up failed in-flight requests so the next call can retry', async () => {
    let calls = 0;
    const fetcher = async () => {
      calls++;
      if (calls === 1) throw new Error('boom');
      return 'RECOVERED';
    };

    await expect(fetchWithCache('retry-key', fetcher)).rejects.toThrow('boom');
    await expect(fetchWithCache('retry-key', fetcher)).resolves.toBe('RECOVERED');
    expect(calls).toBe(2);
  });
});