After being awaited recursively, the resolved promise does not perform any actions

Question

After being awaited recursively, the resolved promise does not perform any actions

When working with the Twitter API, I need to make recursive method calls to retrieve tweets since each request only returns a maximum of 100 tweets.

The process is straightforward:

Call the function and await it
Make an HTTP request and await that
If the response metadata contains a next_token, cache the results and make another HTTP request using the next token.
Repeat until the next_token is undefined, then resolve the promise with the list of all tweets.

However, something seems to be going wrong. The recursive HTTP calls work fine, but when the else block in the recursive function is executed and the promise is resolved, nothing happens. Execution doesn't return to the initial function. It's almost like everything is just spinning without progress. Even setting breakpoints on every line does not trigger any breakpoints.

What could be causing this issue?

public async getTweetList(ticker: string): Promise<string[]>{
        let tweets: string[] = [];

        tweets = await this.getAllTweetsRecursively(ticker, null, tweets);
        return tweets;
    }

    public async getAllTweetsRecursively(ticker: string, nextToken: string, tweetList: string[]): Promise<string[]>{
        return new Promise(async (resolve, reject) => {
            let query = `?query=(${ticker})`
            query += this.extraQuery;

            if(nextToken){
                query += this.nextTokenQuery + nextToken
            }

            let res = await axios.default.get(this.url + query, {
                headers: this.headers
            })

            let newNextToken = res.data.meta.next_token;
            if(res.data.data.length > 0 && newNextToken){
                res.data.data.forEach(tweet => {
                    tweetList.push(tweet.text);
                })
                this.getAllTweetsRecursively(ticker, newNextToken, tweetList);
            }
            else {
                resolve(cleanedTweets)
            }
        })
    }

Alternatively, here's another implementation facing the same issue:

public async getTweetList(ticker: string): Promise<string[]>{
        return new Promise(async (resolve) => {
            let tweets: string[] = [];

            tweets = await this.getAllTweetsRecursively(ticker, null, tweets);
            resolve(tweets);
        })

    }

    public async getAllTweetsRecursively(ticker: string, nextToken: string, tweetList: string[]): Promise<string[]>{
        return new Promise(async (resolve, reject) => {
            let query = `?query=(${ticker})`
            query += this.extraQuery;

            if(nextToken){
                query += this.nextTokenQuery + nextToken
            }

            let res = await axios.default.get(this.url + query, {
                headers: this.headers
            })

            let newNextToken = res.data.meta.next_token;
            if(res.data.data.length > 0 && newNextToken){
                res.data.data.forEach(tweet => {
                    tweetList.push(tweet.text);
                })
                await this.getAllTweetsRecursively(ticker, newNextToken, tweetList);
            }
            else {
                let cleanedTweets: string[] = [];
                tweetList.forEach(tweet => {
                    if(tweet.startsWith("RT")){
                        return;
                    }
                    if(!tweet.toLowerCase().includes("$" + ticker)){
                        return;
                    }
                    cleanedTweets.push(tweet);
                });
                resolve(cleanedTweets)
            }
        })
    }

javascript typescript asynchronous promise

Answer 1

Answer №1

The problem arose when the inner promise failed to resolve during its recursive call.

The issue was resolved by including

resolve(await this.getAllTweetsRecursively(ticker, newNextToken, tweetList));

.

public async getTweetList(symbol: string): Promise<string[]> {
  let tweets: string[] = [];
  return await this.getAllTweetsRecursively(symbol, null, tweets);
}

public async getAllTweetsRecursively(symbol: string, nextToken: string, tweetList: string[]): Promise<string[]>{
  return new Promise(async (resolve, reject) => {
    let query = `?query=(${symbol})`
    query += this.additionalQuery;

    if(nextToken){
      query += this.nextTokenParam + nextToken
    }

    let response = await axios.default.get(this.apiUrl + query, {
      headers: this.requestHeaders
    })

    let newNextToken = response.data.meta.next_token;
    if(response.data.data.length > 0 && newNextToken){
      response.data.data.forEach(tweet => {
        tweetList.push(tweet.text);
      })
      resolve(await this.getAllTweetsRecursively(symbol, newNextToken, tweetList));
    }
    else {
      response.data.data.forEach(tweet => {
        tweetList.push(tweet.text);
      })
      let filteredTweets: string[] = [];
      tweetList.forEach(tweet => {
        if(tweet.startsWith("RT")){
          return;
        }
        if(!tweet.toLowerCase().includes("$" + symbol)){
          return;
        }
        filteredTweets.push(tweet);
      });
      resolve(filteredTweets)
    }
  })
}

Answer 2

The problem arose when the inner promise failed to resolve during its recursive call.

The issue was resolved by including

resolve(await this.getAllTweetsRecursively(ticker, newNextToken, tweetList));

.

public async getTweetList(symbol: string): Promise<string[]> {
  let tweets: string[] = [];
  return await this.getAllTweetsRecursively(symbol, null, tweets);
}

public async getAllTweetsRecursively(symbol: string, nextToken: string, tweetList: string[]): Promise<string[]>{
  return new Promise(async (resolve, reject) => {
    let query = `?query=(${symbol})`
    query += this.additionalQuery;

    if(nextToken){
      query += this.nextTokenParam + nextToken
    }

    let response = await axios.default.get(this.apiUrl + query, {
      headers: this.requestHeaders
    })

    let newNextToken = response.data.meta.next_token;
    if(response.data.data.length > 0 && newNextToken){
      response.data.data.forEach(tweet => {
        tweetList.push(tweet.text);
      })
      resolve(await this.getAllTweetsRecursively(symbol, newNextToken, tweetList));
    }
    else {
      response.data.data.forEach(tweet => {
        tweetList.push(tweet.text);
      })
      let filteredTweets: string[] = [];
      tweetList.forEach(tweet => {
        if(tweet.startsWith("RT")){
          return;
        }
        if(!tweet.toLowerCase().includes("$" + symbol)){
          return;
        }
        filteredTweets.push(tweet);
      });
      resolve(filteredTweets)
    }
  })
}

Answer 3

Answer №2

Always keep in mind that when you use async function() {}, it automatically creates a function that returns a Promise. Essentially, the async keyword handles the asynchronous nature of the function by encapsulating it in a Promise without requiring you to manually write Promise code. Additionally, the await keyword simplifies handling Promises compared to using Promise.then() as it eliminates the need for extraction code.

In essence, the following two functions are essentially the same:

function() {
  return new Promise(resolve, reject => {
    resolve(4);
  });
}

async function() {
  return 4;
}

Both functions return Promises, can be awaited inside another async function, and can be chained with .then(). This is because they are effectively identical. Hence, if you intend to utilize async/await in your code, there's no necessity to construct additional Promises:

public async getTweetList(ticker: string): Promise<string[]> {
  return await this.getAllTweetsRecursively(ticker, null, []);
}

public async getAllTweetsRecursively(ticker: string, nextToken: string, tweetList: string[]): Promise<string[]>{
    let query = `?query=(${ticker})${this.extraQuery}`;

    if(nextToken){
      query = `${query}${this.nextTokenQuery}${nextToken}`;
    }

    let res = await axios.default.get(this.url + query, {
      headers: this.headers
    })

    let newNextToken = res.data.meta.next_token;
    if(res.data.data.length > 0 && newNextToken){
      res.data.data.forEach(tweet => tweetList.push(tweet.text))
      return await this.getAllTweetsRecursively(ticker, newNextToken, tweetList));
    }

    // There's no need for an "else" statement here as the "if" already returns.

    res.data.data.forEach(tweet => tweetList.push(tweet.text))
    let cleanedTweets: string[] = [];
    tweetList.forEach(tweet => {
      if(tweet.startsWith("RT")) return;
      if(!tweet.toLowerCase().includes("$" + ticker)) return;
      cleanedTweets.push(tweet);
    });

    return cleanedTweets
  })
}

You are currently using

async getAllTweetsRecursively(...) { return new Promise(async (resolve, reject) => { ... }))

, which results in THREE nested promises due to each "async" creating its Promise layer. This situation unfolds into:

getAllTweetsRecursively(...) {
  return new Promise(resolve, reject => {
    return new Promise(async (resolve, reject) => {
      ...
    }))
  });
}

This further complicates to:

getAllTweetsRecursively(...) {
  return new Promise(resolve, reject => {
    return new Promise((resolve, reject) => {
      return new Promise(resolve, reject => {
        resolve(...)
      })
    }))
  });
}

Remember, too many nested Promises can lead to confusion and complexity in your code! Beware of descending down this path =)

Answer 4

Always keep in mind that when you use async function() {}, it automatically creates a function that returns a Promise. Essentially, the async keyword handles the asynchronous nature of the function by encapsulating it in a Promise without requiring you to manually write Promise code. Additionally, the await keyword simplifies handling Promises compared to using Promise.then() as it eliminates the need for extraction code.

In essence, the following two functions are essentially the same:

function() {
  return new Promise(resolve, reject => {
    resolve(4);
  });
}

async function() {
  return 4;
}

Both functions return Promises, can be awaited inside another async function, and can be chained with .then(). This is because they are effectively identical. Hence, if you intend to utilize async/await in your code, there's no necessity to construct additional Promises:

public async getTweetList(ticker: string): Promise<string[]> {
  return await this.getAllTweetsRecursively(ticker, null, []);
}

public async getAllTweetsRecursively(ticker: string, nextToken: string, tweetList: string[]): Promise<string[]>{
    let query = `?query=(${ticker})${this.extraQuery}`;

    if(nextToken){
      query = `${query}${this.nextTokenQuery}${nextToken}`;
    }

    let res = await axios.default.get(this.url + query, {
      headers: this.headers
    })

    let newNextToken = res.data.meta.next_token;
    if(res.data.data.length > 0 && newNextToken){
      res.data.data.forEach(tweet => tweetList.push(tweet.text))
      return await this.getAllTweetsRecursively(ticker, newNextToken, tweetList));
    }

    // There's no need for an "else" statement here as the "if" already returns.

    res.data.data.forEach(tweet => tweetList.push(tweet.text))
    let cleanedTweets: string[] = [];
    tweetList.forEach(tweet => {
      if(tweet.startsWith("RT")) return;
      if(!tweet.toLowerCase().includes("$" + ticker)) return;
      cleanedTweets.push(tweet);
    });

    return cleanedTweets
  })
}

You are currently using

async getAllTweetsRecursively(...) { return new Promise(async (resolve, reject) => { ... }))

, which results in THREE nested promises due to each "async" creating its Promise layer. This situation unfolds into:

getAllTweetsRecursively(...) {
  return new Promise(resolve, reject => {
    return new Promise(async (resolve, reject) => {
      ...
    }))
  });
}

This further complicates to:

getAllTweetsRecursively(...) {
  return new Promise(resolve, reject => {
    return new Promise((resolve, reject) => {
      return new Promise(resolve, reject => {
        resolve(...)
      })
    }))
  });
}

Remember, too many nested Promises can lead to confusion and complexity in your code! Beware of descending down this path =)

After being awaited recursively, the resolved promise does not perform any actions

Answer №1

Answer №2

Similar questions

Issues with the messaging functionality of socket.io

RC7 is missing the necessary HTTP_PROVIDERS for the resolveAndCreate HTTP method in Angular2

What is the best way to specify the type of a property that has already been assigned

Difficulty arises when trying to extract specific information from an ajax response using the jQuery.filter

using http to handle a 404 error

What are some effective ways to test asynchronous functions in React?

What are the best techniques for creating animations in AngularJS?

Delegating events after removing a class

A more concise approach to crafting ajax requests

Error: Syntax error - V token not recognized

What is the best way to extract specific information from an API using AJAX and Axios?

Using jQuery to toggle sliding the information above a div

Cross domain request in a simple HTML document

"Encountering issues with calling a Node.js function upon clicking the button

Virtual machines have encountered issues when attempting to utilize setTimeout within the browser with vm.runInNewContext

Is there a way to ensure the content of two divs remains aligned despite changing data within them?

When deploying, an error is occurring where variables and objects are becoming undefined

"Techniques for extracting both the previous and current selections from a dropdown menu in Angular 2

What is the process for testing and executing the code I've written on ACE Cloud 9?

The NextAuth file imported with the EmailProvider is currently not being utilized