如何防止从特定承诺中调用函数？

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 too infinite loops.

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.