I am experiencing with typescript's async/await in express. I have the following code snippet which doesn't product any outcome, it just waits as if the promise is never finished. Any ideas how to make it work.
..
router.get('/test', this.test);
..
private async test(req: Request, res: Response) {
const result = await this.test2();
res.json(result);
}
private async test2() {
return await this.test3();
}
private test3() {
return new Promise((resolve) => { resolve({ "working": true }) });
}
update:
If I change the first line with the line below, it works. Any ideas why ?
router.get('/test', (req,res)=>this.test(req,res));
update2 (fixed) - based on #smnbbrv answer below
private test = async(req: Request, res: Response)=> {
const result = await this.test2();
res.json(result);
}
private test2 = async ()=> {
return await this.test3();
}
private test3 = async()=> {
return new Promise((resolve) => { resolve({ "working": true }) });
}
Looks like your 'this' is lost after you pass it like that
router.get('/test', this.test);
If you simply preserve the this value by
router.get('/test', this.test.bind(this));
this should work exactly in the way you mentioned in update
router.get('/test', (req,res)=>this.test(req,res));
Related
I have an Express app and some function in server.js code is like this:
server.post('/post', (req, res) => {
//some code here...
function a() {
return new Promise(resolve => {
//some code here...
resolve(`result`)
});
};
async function output() {
console.log('Waiting');
const result = await a();
console.log(result);
//some code here...
};
output();
});
It works good but too nested to read. I want to move the function a() outside the server.post like:
function a() {
return new Promise(resolve => {
//some code here...
resolve(`result`)
});
}
server.post('/post', (req, res) => {
//some code here...
a();
async function output() {
console.log('Waiting');
const result = await a();
console.log(result);
//some code here...
};
output();
});
But like this cannot work as before...
In this case how to reduce the complexity of the first example?
You can usually handle it with this pattern:
server.post('/post', async (req, res, next) => {
// Some async code here
let stuff = await example();
await a(stuff);
res.send(...);
next();
});
The key here is to have a next argument so you can chain through when the promises wrap up. This is a callback function that must be called. Failing to call it leaves your request hanging.
I have the following Express endpoint:
const all = require('promise-all');
router.post('/verify', upload.single('photo'), async (req, res) => {
...
await all({'p1': p1, 'p2': p2}).then((response) => {
...
console.log("Response:",
ruleCtrl.manageRule(detection, res);
});
});
ruleCtrl.manageRuleis as follows:
export async function manageRule(identifierDetected, res) {
let rule = db.getRule(identifierDetected);
await all([rule]).then((ruleExtracted) => {
...
res.json(ruleExtracted);
}).catch((err) => {
res.status(418).send("DOCUMENT_NOT_RECOGNIZED");
});
}
and db.getRule:
export async function getRule(idRule) {
return new Promise((resolve, reject) => {
Rule.findOne({ruleID: idRule}, (err, rule) => {
if (err) {
reject("MongoDB Rule error: " + err);
} else {
resolve(rule);
}
});
})
}
My response is into manageRule and this function depends of the values extracted into the await all. So, right now, Express is returning a response before get the information from mongoose database (db).
Which is the way to handle this issue?
Thanks everyone!
I would refactor your code a bit to make it easier to read, and also return the result from ruleCtrl.manageRule(detection, res);.
The request might simply be timing out since your original code is missing a return there or an await (to make sure it finishes executing)
Express endpoint:
const all = require('promise-all');
router.post('/verify', upload.single('photo'), async (req, res) => {
...
// Catch any exceptions from the promises. This is the same as using .catch
try {
// Lets assign the returned responses to variable
let [p1Result, p2Result] = await all({'p1': p1, 'p2': p2});
...
console.log("Responses:", p1Result, p2Result);
// return the response from manageRule method
return ruleCtrl.manageRule(detection, res);
} catch(err) {
// Handle err here
}
});
One of the great benefits with async await is moving away from chained promises, so simply return the result from the await to a variable instead of using .then()
ruleCtrl.manageRule
export async function manageRule(identifierDetected, res) {
// Use try catch here to catch error from db.getRule. Assign to variable and return
// res.json
try {
let ruleExtracted = await db.getRule(identifierDetected);
...
return res.json(ruleExtracted);
} catch(err) {
return res.status(418).send("DOCUMENT_NOT_RECOGNIZED");
}
}
You dont have to return res.json or res.status here, I just like to keep track of when I want to end function execution.
You could refactor the ruleCtrl.manageRule method even further by not sending in res as a parameter but by returning the result from db.getRule instead. Let router.post('/verify) handle req and res, so to make it even easier to read.
I have a file where multiple export functions that are invoked from api's and each of these methods will make some get/post inside the function.
so my questions is for Promise.all that looks redundant to me is there better approach to achieve this using one private method handler that can be implemented or invoked from each of those export function and return response.
main.ts
export function getUser(req: Request, res: Response) {
const p1 = Promise.resolve("data1");
const p2 = Promise.resolve("data2");
Promise.all([p1,p2])
.then(function(results) {
res.json(results);
})
.catch(function(e) {
console.log(e)
});
}
export function getRanks(req: Request, res: Response) {
const p1 = Promise.resolve("data3");
const p2 = Promise.resolve("data4");
Promise.all([p1,p2])
.then(function(results) {
res.json(results);
})
.catch(function(e) {
console.log(e)
});
}
You can do exactly what you wrote - create function that does the general handling.
export function getUser(req: Request, res: Response) {
const p1 = Promise.resolve("data1");
const p2 = Promise.resolve("data2");
sendResponse(req, res, [p1,p2]);
}
export function getRanks(req: Request, res: Response) {
const p1 = Promise.resolve("data3");
const p2 = Promise.resolve("data4");
sendResponse(req, res, [p1,p2]);
}
function sendResponse(req, res, promises) {
Promise.all(promises)
.then(function(results) {
res.json(results);
})
.catch(function(e) {
console.log(e)
});
}
PS: You should have some res handling in .catch (res.end() or res.status(500); res.json({error: e})) otherwise the request will be hanging on for 30-90sec (based on your settings)
In case p1, etc. promises are really created Promise.resolve, it could be omitted; Promise.all accepts regular values.
It could be written with async..await in more succinct manner:
export async function getUser(req: Request, res: Response) {
...
try {
const results = await Promise.all([p1, p2]);
res.json(results);
} catch (e) {
console.log(e)
}
}
At this point functions don't need to be DRYed any further.
I originally had try...catch in my getAllUsers method for querying but ended up removing it because as far as I could tell it wasn't doing anything. I know the async function returns a promise so it should be fine and actually based on how the code is structured I think it's required otherwise the try...catch in the query would swallow the error. Is there anything I'm missing with this structure and use of async/await, try...catch, and .then .catch?
let getAllUsers = async () => {
let res = await models.users.findAll({
attributes: [ 'firstName', 'lastName' ]
});
return res;
};
router.get(`${path}`, (req, res) => {
queries.users.getAllUsers()
.then(users => {
res.status(200).json(users);
})
.catch(error => {
res.status(500).send(error)
});
});
There's just no reason to use await at all in your function. Instead of this:
let getAllUsers = async () => {
let res = await models.users.findAll({
attributes: [ 'firstName', 'lastName' ]
});
return res;
};
It can just be this:
let getAllUsers = () => {
return models.users.findAll({
attributes: [ 'firstName', 'lastName' ]
});
};
You just return the promise directly and the caller uses the promise the same as you already were. Since you are not using the result within your getAllUsers() function or coordinating it with anything else, there's no reason to use await. And, since there's no use of await, there's no reason for the function to be declared async either.
If you wanted to use await, you could use it for the caller of getAllUsers() like this:
router.get(`${path}`, async (req, res) => {
try {
let users = await queries.users.getAllUsers();
res.status(200).json(users);
} catch(error => {
res.status(500).json(error);
}
});
And, here you would have to use try/catch in order to catch rejected promises. Personally, I don't see how this is particularly better than what you had originally with .then() and .catch() so for a situation as simple as this (with no coordination or serialization with other promises), it's really just a matter of personal preference whether to use .then() and .catch() or await with try/catch.
You would use async/await with the code that calls getAllUsers rather than using it in getAllUsers itself:
const getAllUsers = () => {
return models.users.findAll({
attributes: [ 'firstName', 'lastName' ]
});
};
router.get(`${path}`, async (req, res) => {
try {
const users = await queries.users.getAllUsers();
res.status(200).json(users);
} catch (error) {
res.status(500).send(error)
}
});
The best way I have found to handle this is using middleware.
Here is the function:
// based upon this
// http://madole.xyz/error-handling-in-express-with-async-await-routes/
// https://github.com/madole/async-error-catcher
export default function asyncErrorCatcher(fn) {
if (!(fn instanceof Function)) {
throw new Error("Must supply a function");
}
return (request, response, next) => {
const promise = fn(request, response, next);
if (!promise.catch) {
return;
}
promise.catch((error) => {
console.log(error.message);
response.sendStatus(500);
});
};
}
Here is the usage:
router.get("/getSettings/", asyncErrorCatcher(async (request: Request, response: Response) => {
const settings = await database.getSettings();
response.json(settings);
}));
Right now i have this route controller
export let remove = (req: Request, res: Response) => {
Area.removeAndRecalc(req.query.ids).then(() => {
return res.json({ success: true });
});
};
and calls the following model method
areaSchema.statics.removeAndRecalc = async function(ids) {
let parents = await this.model("Area").find({_id: ids});
await this.model("Area").delete(
{
_id: ids
}
);
await parents.forEach((parent) => {
parent.recalcParentChilds();
})
return;
}
The function returns a promise. Is it possible to write this code inside the controller? I try to use "async" to my controller but i doesn't work
Something like this (doesn't work)
export let remove = async (req: Request, res: Response) => {
let parents = await this.model("Area").find({_id: req.query.ids});
await this.model("Area").delete(
{
_id: req.query.ids
}
);
await parents.forEach((parent) => {
parent.recalcParentChilds();
})
return res.json({ success: true });
};
It's not clear "what" exactly doesn't work. An exception or description of the bad behaviour would be useful.
But check out async-middleware. I'm using it like this, for example in some projects:
import { wrap } from 'async-middleware'
//Loads of code, some of which creates router, an Express router.
router.get('/some/path/here', wrap(async (req, res) {
var data = await dataFromService();
res.write(renderData(data));
res.end();
}));
//Loads of code
I think there is a mistake with forEach in the remove function , forEach returns undefined not a promise so await won't work as expected, try to something like this :
export let remove = async (req: Request, res: Response) => {
//...
for (let i=0; i< parent.length;i++){ // <-- use for loop instead of forEach
await parent.recalcParentChilds();
}
return res.json({ success: true });
};