I am using "await" on multiple MongoDB ".findOne" functions to different collections one at a time. I would like to let them all run asynchronously together and somehow know when they are all ready to use.
Instead of doing this:
async function myFunction() {
const collection_1 = await firstCollection.findOne({})
const collection_2 = await secondCollection.findOne({})
const collection_3 = await thirdCollection.findOne({})
console.log(collection_1, collection_2, collection_3)
}
Can I do something like this?
async function myFunction() {
[collection_1, collection_2, collection_3]
await new Promise(() => {
collection_1 = firstCollection.findOne({})
collection_2 = secondCollection.findOne({})
collection_3 = thirdCollection.findOne({})
})
console.log(collection_1, collection_2, collection_3)
}
I don't know how to correctly use Promises to do this.
For tracking the parallel execution of multiple promise-based asynchronous operations, use Promise.all():
async function myFunction() {
const [collection_1, collection_2, collection_3] = await Promise.all([
firstCollection.findOne({}),
secondCollection.findOne({}),
thirdCollection.findOne({})
]);
console.log(collection_1, collection_2, collection_3)
}
Promise.all() will reject if any of the promises you pass it reject. If you want all results, regardless of whether one might reject, you can use Promise.allSettled() instead. See the doc for exactly how its resolved value works.
Related
I wrote this code in lib/helper.js:
var myfunction = async function(x,y) {
....
return [variableA, variableB]
}
exports.myfunction = myfunction;
Then I tried to use it in another file :
var helper = require('./helper.js');
var start = function(a,b){
....
const result = await helper.myfunction('test','test');
}
exports.start = start;
I got an error:
await is only valid in async function
What is the issue?
The error is not refering to myfunction but to start.
async function start() {
....
const result = await helper.myfunction('test', 'test');
}
// My function
const myfunction = async function(x, y) {
return [
x,
y,
];
}
// Start function
const start = async function(a, b) {
const result = await myfunction('test', 'test');
console.log(result);
}
// Call start
start();
I use the opportunity of this question to advise you about an known anti pattern using await which is : return await.
WRONG
async function myfunction() {
console.log('Inside of myfunction');
}
// Here we wait for the myfunction to finish
// and then returns a promise that'll be waited for aswell
// It's useless to wait the myfunction to finish before to return
// we can simply returns a promise that will be resolved later
// useless async here
async function start() {
// useless await here
return await myfunction();
}
// Call start
(async() => {
console.log('before start');
await start();
console.log('after start');
})();
CORRECT
async function myfunction() {
console.log('Inside of myfunction');
}
// Here we wait for the myfunction to finish
// and then returns a promise that'll be waited for aswell
// It's useless to wait the myfunction to finish before to return
// we can simply returns a promise that will be resolved later
// Also point that we don't use async keyword on the function because
// we can simply returns the promise returned by myfunction
function start() {
return myfunction();
}
// Call start
(async() => {
console.log('before start');
await start();
console.log('after start');
})();
Also, know that there is a special case where return await is correct and important : (using try/catch)
Are there performance concerns with `return await`?
To use await, its executing context needs to be async in nature
As it said, you need to define the nature of your executing context where you are willing to await a task before anything.
Just put async before the fn declaration in which your async task will execute.
var start = async function(a, b) {
// Your async task will execute with await
await foo()
console.log('I will execute after foo get either resolved/rejected')
}
Explanation:
In your question, you are importing a method which is asynchronous in nature and will execute in parallel. But where you are trying to execute that async method is inside a different execution context which you need to define async to use await.
var helper = require('./helper.js');
var start = async function(a,b){
....
const result = await helper.myfunction('test','test');
}
exports.start = start;
Wondering what's going under the hood
await consumes promise/future / task-returning methods/functions and async marks a method/function as capable of using await.
Also if you are familiar with promises, await is actually doing the same process of promise/resolve. Creating a chain of promise and executes your next task in resolve callback.
For more info you can refer to MDN DOCS.
When I got this error, it turned out I had a call to the map function inside my "async" function, so this error message was actually referring to the map function not being marked as "async". I got around this issue by taking the "await" call out of the map function and coming up with some other way of getting the expected behavior.
var myfunction = async function(x,y) {
....
someArray.map(someVariable => { // <- This was the function giving the error
return await someFunction(someVariable);
});
}
I had the same problem and the following block of code was giving the same error message:
repositories.forEach( repo => {
const commits = await getCommits(repo);
displayCommit(commits);
});
The problem is that the method getCommits() was async but I was passing it the argument repo which was also produced by a Promise. So, I had to add the word async to it like this: async(repo) and it started working:
repositories.forEach( async(repo) => {
const commits = await getCommits(repo);
displayCommit(commits);
});
If you are writing a Chrome Extension and you get this error for your code at root, you can fix it using the following "workaround":
async function run() {
// Your async code here
const beers = await fetch("https://api.punkapi.com/v2/beers");
}
run();
Basically you have to wrap your async code in an async function and then call the function without awaiting it.
The current implementation of async / await only supports the await keyword inside of async functions Change your start function signature so you can use await inside start.
var start = async function(a, b) {
}
For those interested, the proposal for top-level await is currently in Stage 2: https://github.com/tc39/proposal-top-level-await
async/await is the mechanism of handling promise, two ways we can do it
functionWhichReturnsPromise()
.then(result => {
console.log(result);
})
.cathc(err => {
console.log(result);
});
or we can use await to wait for the promise to full-filed it first, which means either it is rejected or resolved.
Now if we want to use await (waiting for a promise to fulfil) inside a function, it's mandatory that the container function must be an async function because we are waiting for a promise to fulfiled asynchronously || make sense right?.
async function getRecipesAw(){
const IDs = await getIds; // returns promise
const recipe = await getRecipe(IDs[2]); // returns promise
return recipe; // returning a promise
}
getRecipesAw().then(result=>{
console.log(result);
}).catch(error=>{
console.log(error);
});
If you have called async function inside foreach update it to for loop
Found the code below in this nice article: HTTP requests in Node using Axios
const axios = require('axios')
const getBreeds = async () => {
try {
return await axios.get('https://dog.ceo/api/breeds/list/all')
} catch (error) {
console.error(error)
}
}
const countBreeds = async () => {
const breeds = await getBreeds()
if (breeds.data.message) {
console.log(`Got ${Object.entries(breeds.data.message).length} breeds`)
}
}
countBreeds()
Or using Promise:
const axios = require('axios')
const getBreeds = () => {
try {
return axios.get('https://dog.ceo/api/breeds/list/all')
} catch (error) {
console.error(error)
}
}
const countBreeds = async () => {
const breeds = getBreeds()
.then(response => {
if (response.data.message) {
console.log(
`Got ${Object.entries(response.data.message).length} breeds`
)
}
})
.catch(error => {
console.log(error)
})
}
countBreeds()
In later nodejs (>=14), top await is allowed with { "type": "module" } specified in package.json or with file extension .mjs.
https://www.stefanjudis.com/today-i-learned/top-level-await-is-available-in-node-js-modules/
This in one file works..
Looks like await only is applied to the local function which has to be async..
I also am struggling now with a more complex structure and in between different files. That's why I made this small test code.
edit: i forgot to say that I'm working with node.js.. sry. I don't have a clear question. Just thought it could be helpful with the discussion..
function helper(callback){
function doA(){
var array = ["a ","b ","c "];
var alphabet = "";
return new Promise(function (resolve, reject) {
array.forEach(function(key,index){
alphabet += key;
if (index == array.length - 1){
resolve(alphabet);
};
});
});
};
function doB(){
var a = "well done!";
return a;
};
async function make() {
var alphabet = await doA();
var appreciate = doB();
callback(alphabet+appreciate);
};
make();
};
helper(function(message){
console.log(message);
});
A common problem in Express:
The warning can refer to the function, or where you call it.
Express items tend to look like this:
app.post('/foo', ensureLoggedIn("/join"), (req, res) => {
const facts = await db.lookup(something)
res.redirect('/')
})
Notice the => arrow function syntax for the function.
The problem is NOT actually in the db.lookup call, but right here in the Express item.
Needs to be:
app.post('/foo', ensureLoggedIn("/join"), async function (req, res) {
const facts = await db.lookup(something)
res.redirect('/')
})
Basically, nix the => and add async function .
"await is only valid in async function"
But why? 'await' explicitly turns an async call into a synchronous call, and therefore the caller cannot be async (or asyncable) - at least, not because of the call being made at 'await'.
Yes, await / async was a great concept, but the implementation is completely broken.
For whatever reason, the await keyword has been implemented such that it can only be used within an async method. This is in fact a bug, though you will not see it referred to as such anywhere but right here. The fix for this bug would be to implement the await keyword such that it can only be used TO CALL an async function, regardless of whether the calling function is itself synchronous or asynchronous.
Due to this bug, if you use await to call a real asynchronous function somewhere in your code, then ALL of your functions must be marked as async and ALL of your function calls must use await.
This essentially means that you must add the overhead of promises to all of the functions in your entire application, most of which are not and never will be asynchronous.
If you actually think about it, using await in a function should require the function containing the await keyword TO NOT BE ASYNC - this is because the await keyword is going to pause processing in the function where the await keyword is found. If processing in that function is paused, then it is definitely NOT asynchronous.
So, to the developers of javascript and ECMAScript - please fix the await/async implementation as follows...
await can only be used to CALL async functions.
await can appear in any kind of function, synchronous or asynchronous.
Change the error message from "await is only valid in async function" to "await can only be used to call async functions".
I am building a backend with nodeJS.
Since the database call is asynchronous and I want to return its results I have to await the querys result. But then I would have to use await again making the function asynchronous. Is it possible to break this somehow and have synchronous functions?
My goal would be to have something like this.
function persistenceFunction(params){
// Do something to await without this persistenceFunction having to be async
return await pool.query('SELECT stuff FROM table WHERE a=?;',params);
}
function serviceFunction(params){
validate(params);
// do stuff
return persistenceFunction(params);
}
For the database connection I am using the node db module.
Considerations:
The following function will not work because in order for you to be able to use await you have to declare your function as async
function persistenceFunction (params){
// Do something to await without this persistenceFunction having to be async
return await pool.query('SELECT stuff FROM table WHERE a=?;',params);
}
But since you are returning pool.query you don't actually need the await there, so a better alternative would be this.
function persistenceFunction (params){
// Do something to await without this persistenceFunction having to be async
return pool.query('SELECT stuff FROM table WHERE a=?;',params);
}
Just remember that whatever part of your code that is calling serviceFunction will receive a Promise as a result, so it will have to be called in one of the following ways:
function async something () {
const params = {...}
const res = await serviceFunction(params)
// do something with res
}
OR
function something () {
const params = {...}
serviceFunction(params).then((res) => {
// do something with res
})
}
There are 4900 books in the database. I expect to have the same number of books in the new array at the end of the loop. However, I am getting a zero length for the booksArray. What could be the problem and possible solution?
const getOverview = async(req, res) => {
const books = await Book.find();
const booksArray = new Array();
books.forEach(book => {
const url =`https://www.goodreads.com/book/isbn/${book.isbn}key=${process.env.KEY}`;
request.get(url).then(result => {
parseString(result, (error, goodReadsResult) => {
const goodreadsBook = goodReadsResult.GoodreadsResponse.book[0];
booksArray.push(goodreadsBook);
})
});
})
console.log(booksArray.length);
};
First a bit of an overview. Node.js does all networking as non-blocking and asynchronous. That means when you make a networking request, it starts the operation and immediately returns and continues executing the rest of your code. A callback or promise associated with that asynchronous operation gets called sometime later.
In your specific case, your entire .forEach() loop runs to completion starting all the networking requests in it before any of them have finished. Thus you are doing console.log(booksArray.length); before any of your callbacks have run and thus the array is still empty.
Any time you want to sequence or coordinate more than one asynchronous operation in node.js you will want to use promises. It's been built into the language for a couple years now and it's just a massively better way to program with asynchronous operations. I would suggest you find some good tutorials on how promises work and learn them.
Then, the library you are using request() is old and has been put in maintenance mode and does not support promises. There are a variety of more modern alternatives. I personally use the got() library and that's what I've illustrated below.
Then, I don't know what your parseString() function is, but it apparently doesn't use promises and appears to be asynchronous so, in order to use it in a promise-based workflow, I "promisified" it using util.promisify() which is built-into node.js. If it has a promise interface, you should just use that directly.
So anyway, here's what I would suggest:
const got = require('got');
const {promisify} = require('util');
const ps = promisify(parseString);
// this function returns a promise
async function getOverview(req, res) {
const books = await Book.find();
const booksArray = await Promise.all(books.map(book => {
const url =`https://www.goodreads.com/book/isbn/${book.isbn}key=${process.env.KEY}`;
let bookData = await got(url);
return ps(bookData);
}));
console.log(booksArray.length);
// make the booksArray be the resolved value of the promise returned
// by this async function
return booksArray;
}
This makes all your networking calls in parallel and then uses Promise.all() to indicate when they are all done and to collect all the results in order.
If, for some reason, you can't make all these requests in parallel (like there are so many that the target server objects), then you can run them one at a time too like this:
const got = require('got');
const {promisify} = require('util');
const ps = promisify(parseString);
// this function returns a promise
async function getOverview(req, res) {
const books = await Book.find();
const booksArray = [];
for (let book of books) {
const url =`https://www.goodreads.com/book/isbn/${book.isbn}key=${process.env.KEY}`;
let bookData = await got(url);
let data = await ps(bookData);
booksArray.push(data);
}
console.log(booksArray.length);
// make the booksArray be the resolved value of the promise returned
// by this async function
return booksArray;
}
And, since these are async functions, they return a promise so that caller must use await or .then() to get the value from the promise.
getOverview(...).then(results => {
console.log(results);
}).catch(err => {
console.log(err);
});
If you actually intend to pass req and res into that function and use them there, then you will probably need local error handling too so if any of your await operations reject, you can catch that error and send an error response. You would do that with try/catch inside the function body. You can probably just use one top level try/catch and then send an error response inside the catch handler.
I am struggling with how to do this properly in nodejs. This tries to do two things in parallel:
downloads a webpage using axios
creates a directory
When those are finished:
save result asynchronously to a file in de created directory
Then waits until done
const uuidv1 = require('uuid/v1')
const fs = require('fs')
const util = require('util')
const axios = require('axios')
const path = require('path')
const mkdir = util.promisify(fs.mkdir)
const writeFile = util.promisify(fs.writeFile)
const downloadPage = async (url='http://nodeprogram.com') => {
console.log('downloading ', url)
const fetchPage = async function() {
const folderName = uuidv1()
return axios
.all([
mkdir(folderName),
axios.get(url)
])
.then(axios.spread(function (f, r) {
writeFile(path.join(__dirname, folderName, 'file.html'), r.data);
}));
}
await fetchPage()
}
downloadPage(process.argv[2])
Your question and sample are looking contradictory. Question says, you need to make use of async and await to make parallel calls, but your sample code shows you need sequential calls instead of parallel.
Best use of Async/Awaits are for making sequential calls.
async function is a kind of shorthand function for 'Promise', were things are done implicitly like returning will be considered as 'resolve'.
await should always be within async function, add await on functions you need to wait for before proceeding further.
Syntax change in await function is, instead of
somePromiseFunctionCall().then( (someVarible) => {...}).catch(e => {})
you need to use
const asyncFunction = async (parameters) => {
try {
// First Function call that returns Promise / async
someVariable = await somePromiseFunctionCall();
// Second (sequential) call that returns Promise / async
someNewVariable = await someotherPromiseFunctionCall();
} catch(e) {
throw new Error(e);
}
}
Now, in your sample, if your requirement is to wait for axios to return and then create folder and then write the result to file, that can be done using async and await.
Change this:
writeFile(path.join(__dirname, folderName, 'file.html'), r.data);
to this:
return writeFile(path.join(__dirname, folderName, 'file.html'), r.data);
You need to return the promise from writeFile so it is added to the chain so that the promise you're returning from fetchPage() is linked to the writeFile() operation. As your code was originally, the writeFile() operation is proceeding on it's own and is not connected at all to the promise you were returning from fetchPage() so when you do:
await fetchPage()
it wasn't awaiting the writeFile() operation.
A cleaned up version could look like this:
const downloadPage = (url='http://nodeprogram.com') => {
console.log('downloading ', url)
// don't really need this separate fetchPage() function
const fetchPage = function() {
const folderName = uuidv1()
return axios
.all([
mkdir(folderName),
axios.get(url)
])
.then(axios.spread(function (f, r) {
return writeFile(path.join(__dirname, folderName, 'file.html'), r.data);
}));
}
return fetchPage()
}
Then, you would use it like this:
downloadPage().then(() => {
// page is downloaded now
});
Or, inside an async function, you could do:
await downloadPage();
// page is downloaded here
Note, that I removed several cases of async and await as they weren't needed. await fetchPage() wasn't doing you any good at the end of downloadPage(). From a timing point of view, that does the exact same thing as return fetchPage() and this way, you're actually resolving with the resolved value of fetchPage() which can be more useful. There did not appear to be any reason to use async or await in downloadPage(). Keep in mind that an async function still returns a promise and the caller of that function still has to use .then() or await on the return value from that function. So, using await inside of downloadPage() doesn't change that for the caller.
I'm trying to write a node module, to handle my various db calls.
I want to use async/await where ever I can, but I'm having some issues with it.
I've been using promises a bit, and export those functions fine.
Example:
function GetUsernames() {
return new Promise(function (resolve, reject) {
sql.connect(config).then(function () {
new sql.Request()
.query("SELECT [UserName] FROM [Users] ORDER BY [LastLogin] ASC").then(function (recordset) {
resolve(recordset);
}).catch(function (err) {
reject(err);
});
});
});
}
And then I export in the following:
module.exports = {
GetUsernames: GetUsernames,
GetScopes: GetScopes,
UpdateToken: UpdateToken,
SetOwner: SetOwner
};
But, how should I do this, with an async function, to use the async/await that is available in node7?
Do I still just return a promise? I tried doing that, but when I then call it in my code, it doesn't work.
const db = require("dataprovider");
...
var result = await db.GetUsernames();
It gives me:
SyntaxError: Unexpected identifier
on the db name (works fine if I just use the promise functions, with then().)
Maybe my google skills are terrible, but I haven't managed to google anything I could use, on this issue.
How on earth do I make an async function, in my module, that I can await elsewhere?
To turn on the await keyword, you need to have it inside an async function.
const db = require("dataprovider");
...
let result = getUserNames();
async function getUserNames() {
return await db.GetUsernames();
}
See http://javascriptrambling.blogspot.com/2017/04/to-promised-land-with-asyncawait-and.html for more information.
Also, just as an FYI, it a code convention to start function with lowercase, unless you are returning a class from it.
async - await pattern really makes your code easier to read. But node do not allow for global awaits. You can only await an asynchronous flow. What you trying to do is to await outside async flow. This is not permitted. This is kind of anti-pattern for node application. When dealing with promises, what we actually do is generate an asynchronous flow in our program. Our program continue without waiting for promise. So you can export your functions as async but cannot await for them outside async flow. for example.
const db = require('dataprovider');
...
let result = (async () => await db.GetUserNames())();
console.log(result); // outputs: Promise { <pending> }
Thus, async-await pattern works for async flow. Thus use them inside async functions, so that node can execute them asynchronously. Also, you can await for Promises as well. for example.
let fn = async () => await new Promise( (resolve, reject)=>{...} );
fn().then(...);
Here you have created async function 'fn'. This function is thenable. also you can await for 'fn' inside another async function.
let anotherFn = async () => await fn();
anotherFn().then(...);
Here we are waiting for async function inside a async function. Async-Await pattern makes your code readable and concise. This is reflected in large projects.
lets say that you have below function in baseoperation.ts
async function GetAllwithFilter(keyword?: any){
//... async job here
}
then simply you can add below code on the end of baseoperation.ta
module.exports = { GetAllOrAnyName: GetAllwithFilter}
and in the required class you can call it using
const objname = require('./baseoperation');
and to call it in the api using express and router you can use route function with get because it's accept promise call direct
router.route('/').get((req,res) => { objname.GetUsernames().then(then(result => {
res.json(result[0]);
});