AI solution for JavaScript Coding Question on BFE.dev
29. implement async helper - `sequence()`

Solution 1: Using Promise

We can implement sequence using Promise and async/await.

First, we convert each AsyncFunc to a Promise using the Promise constructor. Inside the Promise constructor, we call the async function and resolve or reject the Promise based on the result.

Next, we use Array.reduce() to chain up the Promises. For each Promise, we wait for it to resolve and then call the next AsyncFunc with the result.

If any Promise throws an error, we catch it and reject the chain of Promises. We return the rejected Promise to sequence() and stop further execution of AsyncFuncs.

Finally, we return the Promise returned by the last AsyncFunc to sequence().

Here's the code:

const sequence = async (asyncFuncs) => {
  let result = undefined;
  try {
    result = await asyncFuncs.reduce(async (prev, curr) => {
      const prevResult = await prev;
      return new Promise((resolve, reject) => {
        curr((error, data) => {
          if (error) {
            reject(error);
          } else {
            resolve(data);
          }
        }, prevResult);
      });
    }, Promise.resolve());
  } catch (error) {
    return Promise.reject(error);
  }
  return Promise.resolve(result);
};

Solution 2: Using Callbacks

We can implement sequence using callbacks and recursion.

First, we define a helper function runAsyncFuncs() which takes an array of AsyncFuncs and a callback function. It calls the first AsyncFunc with the given data and passes a new callback function to it. The new callback function calls the next AsyncFunc with the result and calls itself with the new callback function and the next AsyncFunc. If any AsyncFunc throws an error, it calls the original callback function with the error and stops further execution of AsyncFuncs.

Next, we call runAsyncFuncs() with the array of AsyncFuncs and a callback function which returns the result to sequence(). If any error occurs, we return the error to sequence().

Here's the code:

const sequence = (asyncFuncs) => {
  const runAsyncFuncs = (asyncFuncs, callback, data) => {
    const asyncFunc = asyncFuncs[0];
    const remainingAsyncFuncs = asyncFuncs.slice(1);
    asyncFunc((error, result) => {
      if (error) {
        callback(error);
      } else if (remainingAsyncFuncs.length === 0) {
        callback(null, result);
      } else {
        runAsyncFuncs(
          remainingAsyncFuncs,
          callback,
          result
        );
      }
    }, data);
  };
  return (callback) => {
    runAsyncFuncs(
      asyncFuncs,
      (error, result) => {
        if (error) {
          callback(error);
        } else {
          callback(null, result);
        }
      },
      undefined
    );
  };
};

Note: In this solution, we return a callback function from sequence() instead of returning a value directly. This is because we need to pass the callback function to runAsyncFuncs(), which is called recursively.