How do I prevent a function from being called from within a specific promise?

Question

I'm working on a library and I'd like to prevent users from calling a specific function in order to prevent infinite loops. Usually I'd go about doing it like this:

let preventFooCalls = false;

function fireUserCallbacks() {
    preventFooCalls = true;

    // Fire callbacks of the user here...

    preventFooCalls = false;
}

function foo() {
    if (preventFooCalls) throw Error();

    // Run the content of foo() ...
    // It will probably call fireUserCallbacks() at some point
}

However, if fireUserCallbacks is async, this method is not possible. It might be called multiple times, and with async user callbacks, preventFooCalls is not guaranteed to have the correct value. For instance:

let preventFooCalls = false;

async function fireUserCallbacks() {
    preventFooCalls = true;

    // Fire callbacks of the user here one of which being:
    await new Promise(r => setTimeout(r, 1000));

    preventFooCalls = false;
}

// Then when doing:
fireUserCallbacks();
foo(); // This will throw even though it's being called from outside fireUserCallbacks()

How can I detect if code is running from within a specific promise? The only thing I can think of is new Error().stack, but oof that sounds like a terrible way to do it.

---

Some context

The reason why I want this is because I'm working on a part of a library that takes care of loading assets. Some of these assets might contain other assets with the possibility of infinite recursion. In order to handle recursion I have another function that I want users to call instead. Therefore I want to warn users when they call foo() from within one of the fireUserCallbacks() callbacks. While this will only be an issue when assets actually contain infinite loops, I'd rather block the usage of foo() completely to prevent unexpected hangs due to infinite loops.

edit: Here's a somewhat more sophisticated example of my actual code. I would share my actual code but that is really way too long for this format, tbh this example is already getting a bit too complex.

class AssetManager {
  constructor() {
    this.registeredAssetTypes = new Map();
    
    this.availableAssets = new Map();
  }
  
  registerAssetType(typeId, assetTypeConstructor) {
    this.registeredAssetTypes.set(typeId, assetTypeConstructor);
  }
  
  fillAvailableAssets(assetDatas) {
    for (const assetData of assetDatas) {
      const constructor = this.registeredAssetTypes.get(assetData.type);
      const asset = new constructor(assetData.id, assetData.data);
      this.availableAssets.set(assetData.id, asset);
    }
  }
  
  async loadAsset(assetId, recursionTracker = null) {
    // I have some extra code here that makes sure this function will only have
    // a single running instance, but this example is getting way too long already
    const asset = this.availableAssets.get(assetId);
    
    let isRootRecursionTracker = false;
    if (!recursionTracker) {
      isRootRecursionTracker = true;
      recursionTracker = new RecursionTracker(assetId);
    }
    const assetData = await asset.generateAsset(recursionTracker);
    
    if (isRootRecursionTracker) {
      // If this call was made from outside any `generateAsset` implementation,
      // we will wait for all assets to be loaded and put on the right place.
      await recursionTracker.waitForAll();
      
      // Finally we will give the recursionTracker the created root asset,
      // in case any of the sub assets reference the root asset.
      // Note that circular references in any of the sub assets (i.e. not
      // containing the root asset anywhere in the chain) are already taken care of.
      if (recursionTracker.rootLoadingAsset) {
        recursionTracker.rootLoadingAsset.setLoadedAssetData(assetData);
      }
    }
    
    return assetData;
  }
}
const assetManager = new AssetManager();



class RecursionTracker {
  constructor(rootAssetId) {
    this.rootAssetId = rootAssetId;
    
    this.rootLoadingAsset = null;
    this.loadingAssets = new Map();
  }
  
  loadAsset(assetId, cb){
    let loadingAsset = this.loadingAssets.get(assetId);
    if (!loadingAsset) {
      loadingAsset = new LoadingAsset(assetId);
      this.loadingAssets.set(assetId, loadingAsset);
      if (assetId != this.rootAssetId) {
        loadingAsset.startLoading(this);
      } else {
        this.rootLoadingAsset = loadingAsset;
      }
    }
    loadingAsset.onLoad(cb);
  }
  
  async waitForAll() {
    const promises = [];
    for (const loadingAsset of this.loadingAssets.values()) {
      promises.push(loadingAsset.waitForLoad());
    }
    await Promise.all(promises);
  }
}



class LoadingAsset {
  constructor(assetId) {
    this.assetId = assetId;
    
    this.onLoadCbs = new Set();
    this.loadedAssetData = null;
  }
  
  async startLoading(recursionTracker) {
    const loadedAssetData = await assetManager.loadAsset(this.assetId, recursionTracker);
    this.setLoadedAssetData(loadedAssetData);
  }
  
  onLoad(cb) {
    if (this.loadedAssetData) {
      cb(this.loadedAssetData)
    } else {
      this.onLoadCbs.add(cb);
    }
  }
  
  setLoadedAssetData(assetData) {
    this.loadedAssetData = assetData;
    this.onLoadCbs.forEach(cb => cb(assetData));
  }
  
  async waitForLoad() {
    await new Promise(r => this.onLoad(r));
  }
}



class AssetTypeInterface {
  constructor(id, rawAssetData) {
    this.id = id;
    this.rawAssetData = rawAssetData;
  }
  async generateAsset(recursionTracker) {}
}



class AssetTypeFoo extends AssetTypeInterface {  
  async generateAsset(recursionTracker) {
    // This is here just to simulate network traffic, an indexeddb lookup, or any other async operation:
    await new Promise(r => setTimeout(r, 200));
      
    const subAssets = [];
    for (const subAssetId of this.rawAssetData.subAssets) {
      
      
      // This won't work, as it will start waiting for itself to finish:
      // const subAsset = await assetManager.loadAsset(subAssetId);
      // subAssets.push(subAsset);
      
      // So instead we will create a dummy asset:
      const dummyAsset = {}
      const insertionIndex = subAssets.length;
      subAssets[insertionIndex] = dummyAsset;
      // and load the asset with a callback rather than waiting for a promise
      recursionTracker.loadAsset(subAssetId, (loadedAsset) => {
        // since this will be called outside the `generateAsset` function, this won't hang
        subAssets[insertionIndex] = loadedAsset;
      });
    }
    return {
      foo: this.id,
      subAssets,
    }
  }
}
assetManager.registerAssetType("foo", AssetTypeFoo);



class AssetTypeBar extends AssetTypeInterface {
  async generateAsset(recursionTracker) {
    // This is here just to simulate network traffic, an indexeddb lookup, or any other async operation:
    await new Promise(r => setTimeout(r, 200));
    
    // We'll just return a simple object for this one.
    // No recursion here...
    return {
      bar: this.id,
    };
  }
}
assetManager.registerAssetType("bar", AssetTypeBar);



// This is all the raw asset data as stored on the users disk.
// These are not instances of the assets yet, so no circular references yet.
// The assets only reference other assets by their "id"
assetManager.fillAvailableAssets([
  {
    id: "mainAsset",
    type: "foo",
    data: {
      subAssets: ["subAsset1", "subAsset2"]
    }
  },
  {
    id: "subAsset1",
    type: "bar",
    data: {},
  },
  {
    id: "subAsset2",
    type: "foo",
    data: {
      subAssets: ["mainAsset"]
    }
  }
]);

// This sets the loading of the "mainAsset" in motion. It recursively loads
// all referenced assets and finally puts the loaded assets in the right place,
// completing the circle.
(async () => {
  const asset = await assetManager.loadAsset("mainAsset");
  console.log(asset);
})();

Answer 1

Maintain a queue and a set. The queue contains pending requests. The set contains pending requests, requests in progress, and successfully completed requests. (Each item would include the request itself; the request's status: pending, processing, complete; and possibly a retry counter.)

When request is made, check if it is in the set. If it is in the set, it was already requested and will be processed, is being processed, or was processed successfully and is already available. If not in the set, add it to both the set and the queue, then trigger queue processing. If queue processing is already running, the trigger is ignored. If not, queue processing starts.

Queue processing pulls requests off the queue, one by one, and processes them. If a request fails, it can either be put back onto the queue for repeat attempts (a counter can be included in the item to limit retries) or it can be removed from the set so it can be requested again later. Queue processing ends when the queue is empty.

This avoids recursion and unnecessary repeat requests.