Mutexes at application logic level

In my node.js app I have a async function that fetches remote documents and caches them on the disk. Upon a retrieval request for a document first checks the disk, if found loads it from the disk otherwise initiates a network request.

async function getDoc(id){
    if (await diskCache.found(id)){
        return await diskCache.load(id);
    } else {
        const doc = await fetch(/* url */);
        await diskCache.save(doc);
        return doc;
    }
}

If this function gets called twice in a single tick for example:

getDoc(1);
getDoc(1);

and the cache doesn’t contain the document, it sends two network requests, which is’t intended. The second call should wait for the first one to complete then checks the cache.

How should I solve this problem?

const inFlight = {};

async function getDoc(id) {
  // try to look up the cached value
  const value = await diskCache.tryLoad(id);
  if (value !== undefined) return value;

  // get or create a promise that fills the cache
  const promise = (inFlight[id] ||= (async () => {
    const doc = await fetch(...);
    await diskCache.save(doc);
    delete inFlight[id];
    return doc;
  })());

  return await promise;
}