[nodejs] MVC / flow control structure - Please review and comment

On Sunday, 14 October 2012 19:58:31 UTC+10, Mil Werns wrote:

Hi,

I want to implement a REST API with node.js and restify. Because it is my
first node.js project, I spent some time to learn how to structure the
application to avoid the callback hell. Please have a look to the following
solution.


*Assumptions*
- This approach is for writing an end-user application, not a module or a
driver in the sense of a public library.
- REST services are closely related to CRUD, so we have a lot of simple
sequential/interdependent operations (get_data + validate_data [+
change_data] + save_data).


*Goals*
*===> Focus is writing maintainable, clean and easy to understand code!
<===*
Conversely, this means...
- Performance is secondary (scaling horizontally if necessary).
- Avoid "low level" methods like process.nextTick(), instead use "high
level" methods/libs like middleware and control flow modules.
- Use modules to implement a well known MVC structure.


*Code*
Please ignore the poor logging, the not very useful view tasks etc. in the
following example. It should only demonstrate the MVC / callback structure.


*/* server.js */*

var restify = require("restify");
var router = require("./router");
...
router.route(server);
server.listen(...);


*/* router.js */*

var userController = require("./controllers/user");
... // more controllers

exports.route = function route(server) {
server.get("/users",
[
userController.checkRead,
userController.read,
]
);
server.put("/users",
[
userController.checkUpdate,
userController.update,
]
);
...
};


*/* controllers/user.js */*

var restify = require("restify");
var async = require("async");
var check = require('validator').check;
var sanitize = require('validator').sanitize;
var m = require("../models/user");
var v = require("../views/user");
...

var checkUpdate = function userCheckUpdate(req, res, next) {
// validate user input
try {
check(req.params.id, "id").isInt();
check(req.params.forename, "forename").len(1,50);
check(req.params.surname, "surname").len(1,50);
check(req.params.email, "email").isEmail();
} catch(err) {
if(err) {
return next(new restify.InvalidArgumentError("Invalid arguments"));
}
}
return next();
};


var update = function userUpdate(req, res, next) {
// create model
var model = {
forename: sanitize(req.params.forename).xss(),
surname: sanitize(req.params.surname).xss(),
email: sanitize(req.params.email).xss(),
};

//*** "sub-methods" part ***

// _example_ for data check
function checkOwner(curData, callback) {
if(curData.ownerId !== req.userId) {
return callback(new
restify.InvalidArgumentError("NotAuthorizedError"));
}
return callback(null, curData);
};

// _example_ for simple model manipulation
function addSimple(model, callback) {
model.updateDate = new Date().getTime();
return callback(null, model);
};

// _example_ for complex model manipulation
function addComplex(model, callback) {
// use async again to simulate synchronous/parallel/... flow
async.waterfall(
[
// do something
]
function(err, model) {
if(err) {
return callback(new restify.InternalError());
}
return callback(null, model);
}
);
};


// *** main part ***
// use async to simulate synchronous flow
async.waterfall(
[
function(aNext) { m.get(req.params.id, aNext); },
function(curData, aNext) { checkOwner(curData, aNext); },
function(curData, aNext) { addSimple(model, aNext); },
function(model, aNext) { addComplex(model, aNext); },
function(model, aNext) { m.update(model, aNext); },
function(model, aNext) { v.update(model, aNext); },
],
function(err, model) {
if(err) { return next(err); }
res.send(200, model);
}
);
return next();
};
...


*/* models/user.js */*
...
var get = function userGet(id, callback) {
var curData = ... // DB query for ID
if(err) {
console.log("DB error: " + err);
return callback(new restify.InternalError());
};
return callback(null, curData);
};

var update = ...
...


*/* views/user.js */*
...
var update = function userUpdate(model, callback) {
// adjust model for output
delete model.updateDate;
...
callback(null, model);
};


As you can see, this approach uses the middleware concept + async module
to separate the application in small (MVC) pieces that are hopefully easy
to understand.
But as I said before: I'm a node.js newbie :)

*What do you think about this structure?
Are there any drawbacks?*

Thanks a lot for your help
Mil

On Sunday, October 14, 2012 1:58:31 PM UTC+4, Mil Werns wrote:

Hi,

I want to implement a REST API with node.js and restify. Because it is my
first node.js project, I spent some time to learn how to structure the
application to avoid the callback hell. Please have a look to the following
solution.


*Assumptions*
- This approach is for writing an end-user application, not a module or a
driver in the sense of a public library.
- REST services are closely related to CRUD, so we have a lot of simple
sequential/interdependent operations (get_data + validate_data [+
change_data] + save_data).


*Goals*
*===> Focus is writing maintainable, clean and easy to understand code!
<===*
Conversely, this means...
- Performance is secondary (scaling horizontally if necessary).
- Avoid "low level" methods like process.nextTick(), instead use "high
level" methods/libs like middleware and control flow modules.
- Use modules to implement a well known MVC structure.


*Code*
Please ignore the poor logging, the not very useful view tasks etc. in the
following example. It should only demonstrate the MVC / callback structure.


*/* server.js */*

var restify = require("restify");
var router = require("./router");
...
router.route(server);
server.listen(...);


*/* router.js */*

var userController = require("./controllers/user");
... // more controllers

exports.route = function route(server) {
server.get("/users",
[
userController.checkRead,
userController.read,
]
);
server.put("/users",
[
userController.checkUpdate,
userController.update,
]
);
...
};


*/* controllers/user.js */*

var restify = require("restify");
var async = require("async");
var check = require('validator').check;
var sanitize = require('validator').sanitize;
var m = require("../models/user");
var v = require("../views/user");
...

var checkUpdate = function userCheckUpdate(req, res, next) {
// validate user input
try {
check(req.params.id, "id").isInt();
check(req.params.forename, "forename").len(1,50);
check(req.params.surname, "surname").len(1,50);
check(req.params.email, "email").isEmail();
} catch(err) {
if(err) {
return next(new restify.InvalidArgumentError("Invalid arguments"));
}
}
return next();
};


var update = function userUpdate(req, res, next) {
// create model
var model = {
forename: sanitize(req.params.forename).xss(),
surname: sanitize(req.params.surname).xss(),
email: sanitize(req.params.email).xss(),
};

//*** "sub-methods" part ***

// _example_ for data check
function checkOwner(curData, callback) {
if(curData.ownerId !== req.userId) {
return callback(new
restify.InvalidArgumentError("NotAuthorizedError"));
}
return callback(null, curData);
};

// _example_ for simple model manipulation
function addSimple(model, callback) {
model.updateDate = new Date().getTime();
return callback(null, model);
};

// _example_ for complex model manipulation
function addComplex(model, callback) {
// use async again to simulate synchronous/parallel/... flow
async.waterfall(
[
// do something
]
function(err, model) {
if(err) {
return callback(new restify.InternalError());
}
return callback(null, model);
}
);
};


// *** main part ***
// use async to simulate synchronous flow
async.waterfall(
[
function(aNext) { m.get(req.params.id, aNext); },
function(curData, aNext) { checkOwner(curData, aNext); },
function(curData, aNext) { addSimple(model, aNext); },
function(model, aNext) { addComplex(model, aNext); },
function(model, aNext) { m.update(model, aNext); },
function(model, aNext) { v.update(model, aNext); },
],
function(err, model) {
if(err) { return next(err); }
res.send(200, model);
}
);
return next();
};
...


*/* models/user.js */*
...
var get = function userGet(id, callback) {
var curData = ... // DB query for ID
if(err) {
console.log("DB error: " + err);
return callback(new restify.InternalError());
};
return callback(null, curData);
};

var update = ...
...


*/* views/user.js */*
...
var update = function userUpdate(model, callback) {
// adjust model for output
delete model.updateDate;
...
callback(null, model);
};


As you can see, this approach uses the middleware concept + async module
to separate the application in small (MVC) pieces that are hopefully easy
to understand.
But as I said before: I'm a node.js newbie :)

*What do you think about this structure?
Are there any drawbacks?*

Thanks a lot for your help
Mil

On Sunday, October 14, 2012 1:58:31 PM UTC+4, Mil Werns wrote:

Hi,

I want to implement a REST API with node.js and restify. Because it is my
first node.js project, I spent some time to learn how to structure the
application to avoid the callback hell. Please have a look to the following
solution.


*Assumptions*
- This approach is for writing an end-user application, not a module or a
driver in the sense of a public library.
- REST services are closely related to CRUD, so we have a lot of simple
sequential/interdependent operations (get_data + validate_data [+
change_data] + save_data).


*Goals*
*===> Focus is writing maintainable, clean and easy to understand code!
<===*
Conversely, this means...
- Performance is secondary (scaling horizontally if necessary).
- Avoid "low level" methods like process.nextTick(), instead use "high
level" methods/libs like middleware and control flow modules.
- Use modules to implement a well known MVC structure.


*Code*
Please ignore the poor logging, the not very useful view tasks etc. in the
following example. It should only demonstrate the MVC / callback structure.


*/* server.js */*

var restify = require("restify");
var router = require("./router");
...
router.route(server);
server.listen(...);


*/* router.js */*

var userController = require("./controllers/user");
... // more controllers

exports.route = function route(server) {
server.get("/users",
[
userController.checkRead,
userController.read,
]
);
server.put("/users",
[
userController.checkUpdate,
userController.update,
]
);
...
};


*/* controllers/user.js */*

var restify = require("restify");
var async = require("async");
var check = require('validator').check;
var sanitize = require('validator').sanitize;
var m = require("../models/user");
var v = require("../views/user");
...

var checkUpdate = function userCheckUpdate(req, res, next) {
// validate user input
try {
check(req.params.id, "id").isInt();
check(req.params.forename, "forename").len(1,50);
check(req.params.surname, "surname").len(1,50);
check(req.params.email, "email").isEmail();
} catch(err) {
if(err) {
return next(new restify.InvalidArgumentError("Invalid arguments"));
}
}
return next();
};


var update = function userUpdate(req, res, next) {
// create model
var model = {
forename: sanitize(req.params.forename).xss(),
surname: sanitize(req.params.surname).xss(),
email: sanitize(req.params.email).xss(),
};

//*** "sub-methods" part ***

// _example_ for data check
function checkOwner(curData, callback) {
if(curData.ownerId !== req.userId) {
return callback(new
restify.InvalidArgumentError("NotAuthorizedError"));
}
return callback(null, curData);
};

// _example_ for simple model manipulation
function addSimple(model, callback) {
model.updateDate = new Date().getTime();
return callback(null, model);
};

// _example_ for complex model manipulation
function addComplex(model, callback) {
// use async again to simulate synchronous/parallel/... flow
async.waterfall(
[
// do something
]
function(err, model) {
if(err) {
return callback(new restify.InternalError());
}
return callback(null, model);
}
);
};


// *** main part ***
// use async to simulate synchronous flow
async.waterfall(
[
function(aNext) { m.get(req.params.id, aNext); },
function(curData, aNext) { checkOwner(curData, aNext); },
function(curData, aNext) { addSimple(model, aNext); },
function(model, aNext) { addComplex(model, aNext); },
function(model, aNext) { m.update(model, aNext); },
function(model, aNext) { v.update(model, aNext); },
],
function(err, model) {
if(err) { return next(err); }
res.send(200, model);
}
);
return next();
};
...


*/* models/user.js */*
...
var get = function userGet(id, callback) {
var curData = ... // DB query for ID
if(err) {
console.log("DB error: " + err);
return callback(new restify.InternalError());
};
return callback(null, curData);
};

var update = ...
...


*/* views/user.js */*
...
var update = function userUpdate(model, callback) {
// adjust model for output
delete model.updateDate;
...
callback(null, model);
};


As you can see, this approach uses the middleware concept + async module
to separate the application in small (MVC) pieces that are hopefully easy
to understand.
But as I said before: I'm a node.js newbie :)

*What do you think about this structure?
Are there any drawbacks?*

Thanks a lot for your help
Mil

On Sunday, October 14, 2012 11:58:31 AM UTC+2, Mil Werns wrote:

Hi,

I want to implement a REST API with node.js and restify. Because it is my
first node.js project, I spent some time to learn how to structure the
application to avoid the callback hell. Please have a look to the following
solution.


*Assumptions*
- This approach is for writing an end-user application, not a module or a
driver in the sense of a public library.
- REST services are closely related to CRUD, so we have a lot of simple
sequential/interdependent operations (get_data + validate_data [+
change_data] + save_data).


*Goals*
*===> Focus is writing maintainable, clean and easy to understand code!
<===*
Conversely, this means...
- Performance is secondary (scaling horizontally if necessary).
- Avoid "low level" methods like process.nextTick(), instead use "high
level" methods/libs like middleware and control flow modules.
- Use modules to implement a well known MVC structure.


*Code*
Please ignore the poor logging, the not very useful view tasks etc. in the
following example. It should only demonstrate the MVC / callback structure.


*/* server.js */*

var restify = require("restify");
var router = require("./router");
...
router.route(server);
server.listen(...);


*/* router.js */*

var userController = require("./controllers/user");
... // more controllers

exports.route = function route(server) {
server.get("/users",
[
userController.checkRead,
userController.read,
]
);
server.put("/users",
[
userController.checkUpdate,
userController.update,
]
);
...
};


*/* controllers/user.js */*

var restify = require("restify");
var async = require("async");
var check = require('validator').check;
var sanitize = require('validator').sanitize;
var m = require("../models/user");
var v = require("../views/user");
...

var checkUpdate = function userCheckUpdate(req, res, next) {
// validate user input
try {
check(req.params.id, "id").isInt();
check(req.params.forename, "forename").len(1,50);
check(req.params.surname, "surname").len(1,50);
check(req.params.email, "email").isEmail();
} catch(err) {
if(err) {
return next(new restify.InvalidArgumentError("Invalid arguments"));
}
}
return next();
};


var update = function userUpdate(req, res, next) {
// create model
var model = {
forename: sanitize(req.params.forename).xss(),
surname: sanitize(req.params.surname).xss(),
email: sanitize(req.params.email).xss(),
};

//*** "sub-methods" part ***

// _example_ for data check
function checkOwner(curData, callback) {
if(curData.ownerId !== req.userId) {
return callback(new
restify.InvalidArgumentError("NotAuthorizedError"));
}
return callback(null, curData);
};

// _example_ for simple model manipulation
function addSimple(model, callback) {
model.updateDate = new Date().getTime();
return callback(null, model);
};

// _example_ for complex model manipulation
function addComplex(model, callback) {
// use async again to simulate synchronous/parallel/... flow
async.waterfall(
[
// do something
]
function(err, model) {
if(err) {
return callback(new restify.InternalError());
}
return callback(null, model);
}
);
};


// *** main part ***
// use async to simulate synchronous flow
async.waterfall(
[
function(aNext) { m.get(req.params.id, aNext); },
function(curData, aNext) { checkOwner(curData, aNext); },
function(curData, aNext) { addSimple(model, aNext); },
function(model, aNext) { addComplex(model, aNext); },
function(model, aNext) { m.update(model, aNext); },
function(model, aNext) { v.update(model, aNext); },
],
function(err, model) {
if(err) { return next(err); }
res.send(200, model);
}
);
return next();
};
...


*/* models/user.js */*
...
var get = function userGet(id, callback) {
var curData = ... // DB query for ID
if(err) {
console.log("DB error: " + err);
return callback(new restify.InternalError());
};
return callback(null, curData);
};

var update = ...
...


*/* views/user.js */*
...
var update = function userUpdate(model, callback) {
// adjust model for output
delete model.updateDate;
...
callback(null, model);
};


As you can see, this approach uses the middleware concept + async module
to separate the application in small (MVC) pieces that are hopefully easy
to understand.
But as I said before: I'm a node.js newbie :)

*What do you think about this structure?
Are there any drawbacks?*

Thanks a lot for your help
Mil

On 10/15/2012 01:18 AM, Mil Werns wrote:
@Tim:
Thanks, positive feedback is always welcome :)

@Eldar:
the-box looks very interesting. I am curious to see what in this
project happens next. But currently, it is important for me to use
only standard (within the meaning of established/mainstream)
componentes and libraries (like e.g. async) that every node programmer
knows.

Can you please point out some more details why you don't find this
code clean/easy maintainable? And give me some example code for
improvements?

On Sunday, October 14, 2012 11:58:31 AM UTC+2, Mil Werns wrote:

Hi,

I want to implement a REST API with node.js and restify. Because
it is my first node.js project, I spent some time to learn how to
structure the application to avoid the callback hell. Please have
a look to the following solution.


_*Assumptions*_
- This approach is for writing an end-user application, not a
module or a driver in the sense of a public library.
- REST services are closely related to CRUD, so we have a lot of
simple sequential/interdependent operations (get_data +
validate_data [+ change_data] + save_data).


_*Goals*_
*===> Focus is writing maintainable, clean and easy to understand
code! <===*
Conversely, this means...
- Performance is secondary (scaling horizontally if necessary).
- Avoid "low level" methods like process.nextTick(), instead use
"high level" methods/libs like middleware and control flow modules.
- Use modules to implement a well known MVC structure.


_*Code*_
Please ignore the poor logging, the not very useful view tasks
etc. in the following example. It should only demonstrate the MVC
/ callback structure.


*/* server.js */*

var restify = require("restify");
var router = require("./router");
...
router.route(server);
server.listen(...);


*/* router.js */*

var userController = require("./controllers/user");
... // more controllers

exports.route = function route(server) {
server.get("/users",
[
userController.checkRead,
userController.read,
]
);
server.put("/users",
[
userController.checkUpdate,
userController.update,
]
);
...
};


*/* controllers/user.js */*

var restify = require("restify");
var async = require("async");
var check = require('validator').check;
var sanitize = require('validator').sanitize;
var m = require("../models/user");
var v = require("../views/user");
...

var checkUpdate = function userCheckUpdate(req, res, next) {
// validate user input
try {
check(req.params.id <http://req.params.id>, "id").isInt();
check(req.params.forename, "forename").len(1,50);
check(req.params.surname, "surname").len(1,50);
check(req.params.email, "email").isEmail();
} catch(err) {
if(err) {
return next(new restify.InvalidArgumentError("Invalid
arguments"));
}
}
return next();
};


var update = function userUpdate(req, res, next) {
// create model
var model = {
forename: sanitize(req.params.forename).xss(),
surname: sanitize(req.params.surname).xss(),
email: sanitize(req.params.email).xss(),
};

//*** "sub-methods" part ***

// _example_ for data check
function checkOwner(curData, callback) {
if(curData.ownerId !== req.userId) {
return callback(new
restify.InvalidArgumentError("NotAuthorizedError"));
}
return callback(null, curData);
};

// _example_ for simple model manipulation
function addSimple(model, callback) {
model.updateDate = new Date().getTime();
return callback(null, model);
};

// _example_ for complex model manipulation
function addComplex(model, callback) {
// use async again to simulate synchronous/parallel/... flow
async.waterfall(
[
// do something
]
function(err, model) {
if(err) {
return callback(new restify.InternalError());
}
return callback(null, model);
}
);
};


// *** main part ***
// use async to simulate synchronous flow
async.waterfall(
[
function(aNext) { m.get(req.params.id
<http://req.params.id>, aNext); },
function(curData, aNext) { checkOwner(curData, aNext); },
function(curData, aNext) { addSimple(model, aNext); },
function(model, aNext) { addComplex(model, aNext); },
function(model, aNext) { m.update(model, aNext); },
function(model, aNext) { v.update(model, aNext); },
],
function(err, model) {
if(err) { return next(err); }
res.send(200, model);
}
);
return next();
};
...


*/* models/user.js */*
...
var get = function userGet(id, callback) {
var curData = ... // DB query for ID
if(err) {
console.log("DB error: " + err);
return callback(new restify.InternalError());
};
return callback(null, curData);
};

var update = ...
...


*/* views/user.js */*
...
var update = function userUpdate(model, callback) {
// adjust model for output
delete model.updateDate;
...
callback(null, model);
};


As you can see, this approach uses the middleware concept + async
module to separate the application in small (MVC) pieces that are
hopefully easy to understand.
But as I said before: I'm a node.js newbie :)

*What do you think about this structure?
Are there any drawbacks?*

Thanks a lot for your help
Mil


--
Job Board: http://jobs.nodejs.org/
Posting guidelines:
https://github.com/joyent/node/wiki/Mailing-List-Posting-Guidelines
You received this message because you are subscribed to the Google
Groups "nodejs" group.
To post to this group, send email to nodejs@googlegroups.com
To unsubscribe from this group, send email to
nodejs+unsubscribe@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/nodejs?hl=en?hl=en

But currently, it is important for me to use only standard (within the
meaning of established/mainstream) componentes and libraries (like e.g.
async) that every node programmer knows.

On Monday, October 15, 2012 11:18:37 AM UTC+4, Mil Werns wrote:

@Tim:
Thanks, positive feedback is always welcome :)

@Eldar:
the-box looks very interesting. I am curious to see what in this project
happens next. But currently, it is important for me to use only standard
(within the meaning of established/mainstream) componentes and libraries
(like e.g. async) that every node programmer knows.

Can you please point out some more details why you don't find this code
clean/easy maintainable? And give me some example code for improvements?

But currently, it is important for me to use only standard (within the

No one encourages you to use the-box as is. It's essentials just about
50-100 lines of code. Each app might want to have it's own optimized
version. But the pattern "hey I want this and that" is very common.
Delegating tasks of getting dependencies to well known infrastructure is
what makes code more simple and declarative. Here we see an idea of
separating control flow from business logic in action.

Can you please point out some more details why you don't find this code

Without concrete use case it's very hard to do. What you showed just has
some smells for me, but that's all pretty subjective. For example using of
async utils for sequential execution. They are adding their own noise both
in code and runtime. I personally can tolerate up to 5 levels of nesting
with 2 space tabs but can't remember when I had more than 3 levels. At the
same time async.waterfall adds 2 levels just by default. Another thing is

function doSomething () {
var data = {}
function a () {}
function b () {}
a()
b()
}

or

function doSomething () {
var data = {}
a(data)
b(data)
}

function a (data) {
// body...
}

function b (data) {
// body...
}

probably it's better to create object-method for such use case

function DoSomething (data) {
this.data = data
}

DoSomething.prototype.a = function () {
// body...
}

DoSomething.prototype.b = function () {
// body...
}

On Tuesday, October 16, 2012 1:58:28 PM UTC+2, greelgorke wrote:

totally agree about nesting and async is a smell.

Am Dienstag, 16. Oktober 2012 10:58:22 UTC+2 schrieb Eldar:

@John: I'm using couchDb. Currently, my db-query function is just a
wrapper around the "request" module. Perhaps I will use the nano module in
the future.

@Manuel: For small projects, I prefer a central routing module, but for
bigger projects you are right of course. Thanks for this hint and the mvc
link.

@Eldar, @greelgorke: I think you are right that the async module shouldn't
be used for simple functions. I will adjust my project code. The only thing
that bothers me is the costly error handling

m.get(..., function(err, body) {
if(err) { return next(err); }
m.upate(..., function(err, model) {
if(err) { return next(err); }
...

A lot of same "*if(err)*" lines. So, using the async module for
_complicated_ (deep nested) cases keeps the code cleaner.

@All: Thanks for your responses, I will optimize my code :)

Hi,

I want to implement a REST API with node.js and restify. Because it is my
first node.js project, I spent some time to learn how to structure the
application to avoid the callback hell. Please have a look to the following
solution.


*Assumptions*
- This approach is for writing an end-user application, not a module or a
driver in the sense of a public library.
- REST services are closely related to CRUD, so we have a lot of simple
sequential/interdependent operations (get_data + validate_data [+
change_data] + save_data).


*Goals*
*===> Focus is writing maintainable, clean and easy to understand code!
<===*
Conversely, this means...
- Performance is secondary (scaling horizontally if necessary).
- Avoid "low level" methods like process.nextTick(), instead use "high
level" methods/libs like middleware and control flow modules.
- Use modules to implement a well known MVC structure.


*Code*
Please ignore the poor logging, the not very useful view tasks etc. in the
following example. It should only demonstrate the MVC / callback structure.


*/* server.js */*

var restify = require("restify");
var router = require("./router");
...
router.route(server);
server.listen(...);


*/* router.js */*

var userController = require("./controllers/user");
... // more controllers

exports.route = function route(server) {
server.get("/users",
[
userController.checkRead,
userController.read,
]
);
server.put("/users",
[
userController.checkUpdate,
userController.update,
]
);
...
};


*/* controllers/user.js */*

var restify = require("restify");
var async = require("async");
var check = require('validator').check;
var sanitize = require('validator').sanitize;
var m = require("../models/user");
var v = require("../views/user");
...

var checkUpdate = function userCheckUpdate(req, res, next) {
// validate user input
try {
check(req.params.id, "id").isInt();
check(req.params.forename, "forename").len(1,50);
check(req.params.surname, "surname").len(1,50);
check(req.params.email, "email").isEmail();
} catch(err) {
if(err) {
return next(new restify.InvalidArgumentError("Invalid arguments"));
}
}
return next();
};


var update = function userUpdate(req, res, next) {
// create model
var model = {
forename: sanitize(req.params.forename).xss(),
surname: sanitize(req.params.surname).xss(),
email: sanitize(req.params.email).xss(),
};

//*** "sub-methods" part ***

// _example_ for data check
function checkOwner(curData, callback) {
if(curData.ownerId !== req.userId) {
return callback(new
restify.InvalidArgumentError("NotAuthorizedError"));
}
return callback(null, curData);
};

// _example_ for simple model manipulation
function addSimple(model, callback) {
model.updateDate = new Date().getTime();
return callback(null, model);
};

// _example_ for complex model manipulation
function addComplex(model, callback) {
// use async again to simulate synchronous/parallel/... flow
async.waterfall(
[
// do something
]
function(err, model) {
if(err) {
return callback(new restify.InternalError());
}
return callback(null, model);
}
);
};


// *** main part ***
// use async to simulate synchronous flow
async.waterfall(
[
function(aNext) { m.get(req.params.id, aNext); },
function(curData, aNext) { checkOwner(curData, aNext); },
function(curData, aNext) { addSimple(model, aNext); },
function(model, aNext) { addComplex(model, aNext); },
function(model, aNext) { m.update(model, aNext); },
function(model, aNext) { v.update(model, aNext); },
],
function(err, model) {
if(err) { return next(err); }
res.send(200, model);
}
);
return next();
};
...


*/* models/user.js */*
...
var get = function userGet(id, callback) {
var curData = ... // DB query for ID
if(err) {
console.log("DB error: " + err);
return callback(new restify.InternalError());
};
return callback(null, curData);
};

var update = ...
...


*/* views/user.js */*
...
var update = function userUpdate(model, callback) {
// adjust model for output
delete model.updateDate;
...
callback(null, model);
};


As you can see, this approach uses the middleware concept + async module
to separate the application in small (MVC) pieces that are hopefully easy
to understand.
But as I said before: I'm a node.js newbie :)

*What do you think about this structure?
Are there any drawbacks?*

Thanks a lot for your help
Mil