There is included an example that create, list, delete and list details of an user.

  express(v4.10.4)       - This package is a MVC framework for Node.js
  bookshelf(v0.4.9)      - This package is javascript ORM for Node.js
  knex(v0.7.3)           - This package is for SQL Query Builder for Postgrate, MySQL etc.
  mysql(v2.5.3)          - This package is a MySQL driver for Node.js
  body-parse(v1.10.0)    - This package is a Node.js body parser
  path(v0.4.9)           - This package is a Node.js path module

All these package are installed by npm(Node Package Manager). You have to type npm install at directory package.json is stored and all packages will be installed automatically.

  First, there is declared an object ```DBConfig```, in this object are stored data for database client and database options

  ```javascript
  var DBConfig = {
	client: 'mysql',
	connection: {
		host: 'localhost',
		user: 'root',
		password: 'mysql_password',
		database: 'database_name',
		charset: 'utf8'
	}
};
```
Then, there is included ```knex``` package passing ```DBConfig``` object, after that there is included ```bookshelf``` package passing ```knex```
```javascript
var knex = require('knex')(DBConfig);
var bookshelf = require('bookshelf')(knex);
```

And finally, is exported ```bookshelf``` and we are done with ```config/db.js``` file.
```javascript
module.exports.bookshelf = bookshelf;
```

2. Let's describe next file models/User.js

   First, is included bookshelf that we exported above

   var bookshelf = require('./../config/db').bookshelf;

   Then,is declared a User object that extends built-in bookshelf Model with a table name, in this case users table

   var User = bookshelf.Model.extend({
   	tableName: 'users'
   });

   Finally, export User and we are done with model.

   module.exports = {
   	User: User
   };

3. The directory routes contains two files: index.js and users.js.

   In index.js, first is included path package needed resolve relative path. Then, we export the main view file (index.html).

   var path = require('path');
   
   var index = function (req, res) {
   	res.sendFile(path.resolve(__dirname + '/../public/index.html'));
   };
   
   module.exports.index = index;

   Code below belongs to users.js file. First of all, there is included User model. To save a user, inputs are set by a request from client side, and with save method of bookshelf it is saved to db. If it will be saved, then method repond user as json, othervise it fires and error.

   var Model = require('./../models/User');
   
   /* Save a user */
   var saveUser = function (req, res) {
   	new Model.User({
   		username: req.body.username,
   		email: req.body.email,
   		name: req.body.name,
   		age: req.body.age,
   		location: req.body.location
   	}).save()
   		.then(function (user) {
   			res.json(user);
   		}).catch(function (error) {
   			res.json(error);
   		});
   };

   Below are returnded all users from database, useing another method of bookshelf - fetchAll().

   /* Get all users */
   var getAllUsers = function (req, res) {
   	new Model.User().fetchAll()
   		.then(function (users) {
   			res.json(users);
   		}).catch(function (error) {
   			res.json(error);
   		});
   };

   First, this get the user id from url parameters and then using destroy method, it deletes the user in database.

   /* Delete a user */
   var deleteUser = function (req, res) {
   	var userId = req.params.id;
   	new Model.User().where('id', userId)
   		.destroy()
   		.catch(function (error) {
   			res.json(error);
   		});
   };

   The code below gets all details for a specified user.

   /* Get a user */
   var getUser = function (req, res) {
   	var userId = req.params.id;
   	new Model.User().where('id', userId)
   		.fetch()
   		.then(function (user) {
   			res.json(user);
   		}).catch(function (error) {
   			res.json(error);
   		});
   };

   Using module.export it exports all methods explained above.

   /* Exports all methods */
   module.exports = {
   	saveUser: saveUser,
   	getAllUsers: getAllUsers,
   	deleteUser: deleteUser,
   	getUser: getUser
   };

4. router.js

   This is router. It included logic from routes collection and uses methods from these routes, and at least it export url routes for basic http methods using expressjs. This method will be used to server.js

   var user = require('./routes/users');
   var index = require('./routes/index');
   
   module.exports = function (app) {
   
   	/* Index(main) route */
   	app.get('/', index.index);
   
   	/* User Routes */
   	app.post('/users', user.saveUser);
   	app.get('/users', user.getAllUsers);
   	app.delete('/user/:id', user.deleteUser);
   	app.get('/user/:id', user.getUser);
   };

5. server.js

   Here the server is started and the routes are called. The express framework and body-parser are included. body-parser is used to parse json.

   var express = require('express');
   var app = express();
   var bodyParser = require('body-parser');
   
   app.use(bodyParser.json());
   app.use('/public', express.static(__dirname + '/public'));
   
   /* Router */
   require('./router')(app);
   
   app.listen(3000, function () {
   	console.log('Go to localhost:3000');
   });

Finally the simple app is done. Enjoy it!