Promise-chain vs. simplicity - node.js

Question

I have a Node 8 / Express 4 / Mongoose 4 API and would like to generalize some code so that I can reuse it for other parts.
Consider the following code that would create a new user:
function postUser(req, res, next) {
var body = req.body;
if ("data" in body) {
var user = new User(body.data);
user.save(function(err, savedUser) {
if (err) {
if (err.name === 'MongoError' && err.code === 11000) {
// user already exists
res.status(400).json({status: "fail", message: "User already exists"});
} else {
return next(err);
}
} else {
// user successfully saved
res.json({status: "success", data: savedUser});
}
});
} else {
// malformed body
res.status(400).json({status: "fail", message: "Malformed body"});
}
}
Let's assume that I have other functions that would do similar work and some of them are callback-hell. How would I best generalize the above code? I thought about using promise-chains like this:
function postUser(req, res, next) {
validateBody(req.body)
.then(createNewUser)
.then(user => sendUser(user, res))
.catch(e => handleErrors(e, res));
}
function validateBody(body) {
return new Promise(function(resolve, reject) {
if ("data" in body) {
resolve(body.data);
} else {
reject(new InvalidBodyError());
}
});
}
function createNewUser(userObj) {
return new Promise(function(resolve, reject) {
var user = new User(userObj);
user.save(function(err, savedUser) {
if (err) {
if (err.name === 'MongoError' && err.code === 11000) {
// user already exists
reject(new UserAlreadyExistsError(userObj));
} else {
// other error
reject(err);
}
} else {
// user successfully saved
resolve(savedUser);
}
});
});
}
function handleErrors(e, res) {
if (e instanceof InvalidObjectIdError) handleInvalidObjectIdError(e, res)
else if (e instanceof UserNotFoundError) handleUserNotFoundError(e, res)
else if (e instanceof InvalidBodyError) handleInvalidBodyError(e, res)
else if (e instanceof UserAlreadyExistsError) handleUserAlreadyExistsError(e, res)
// TODO: handle unknown errors
}
As you can see, it looks cleaner and more reusable. But how will it perform under load? I am especially concerned about creating multiple promises per request. Does this scale or not?
Another way of solving it would be to create a generic base class that would solve the generic stuff and then extend this class with implementation-specific methods (pseudocode):
class Action {
constructor() {}
postDoc(Base, req, res, next) {
var body = req.body;
if ("data" in body) {
var doc= new Base(body.data);
doc.save(function(err, savedDoc) {
if (err) {
if (err.name === 'MongoError' && err.code === 11000) {
// docalready exists
res.status(400).json({status: "fail", message: "Doc already exists"});
} else {
return next(err);
}
} else {
// user successfully saved
res.json({status: "success", data: savedDoc});
}
});
} else {
// malformed body
res.status(400).json({status: "fail", message: "Malformed body"});
}
}
}
class UserAction extends Action {
constructor() {
super();
}
postUser(body, req, res, next) {
this.postDoc(User, req, res, next);
}
}
class AnotherAction extends Action {
constructor() {
super();
}
postAnother(body, req, res, next) {
this.postDoc(AnotherBase, req, res, next);
}
}
And then just use UserAction or AnotherAction (User is a mongoose model in my case).
Which one do you prefer?

Answer 1

I thought about using promise-chains like this, which is cleaner and more reusable. But how will it perform under load?
Just fine.
I am especially concerned about creating multiple promises per request. Does this scale or not?
Yes. Promises are cheap. Look at how many other objects and callback closures you are creating per request - it scales exactly the same.
However, you can further simplify:
function validateBody(body) {
return "data" in body
? Promise.resolve(body.data)
: Promise.reject(new InvalidBodyError());
}
function createNewUser(userObj) {
return new Promise(function(resolve, reject) {
new User(userObj).save(function(err, savedUser) {
if (err) reject(err);
else resolve(savedUser);
});
}).catch((err) => {
if (err.name === 'MongoError' && err.code === 11000) {
// user already exists
throw new UserAlreadyExistsError(userObj);
} else {
// other error
throw err;
});
});
}
Another way of solving it would be to create a generic base class that would solve the generic stuff and then extend this class with implementation-specific methods
No, don't do that. Inheritance is the wrong tool here. Creating generic helper functions like postDoc, which abstracts over the type of the document to create, are a good idea, but there's no good reason to put them in classes. Combine them with promises. If the number of parameters to the helper function gets out of hand, you can use objects, and even a class, but don't use inheritance - use different instances instead. For example, the code could look like this:
const userAction = new Action(User, UserAlreadyExistsError);
const anotherAction = new Action(AnotherBase, …);
function post(action) {
return (req, res, next) => {
action.postDoc(req)
.then(doc => send(doc, res))
.catch(e => handleErrors(e, res));
};
}