app-api
├── controllers
│   └── users.js
├── models
│   ├── db.js
│   └── users.js
└── routes
    └── index.js

var express = require('express');
var router = express.Router();
var ctrlUsers = require('../controllers/users');

router.get('/user', ctrlUsers.userInfo);
router.post('/signup', ctrlUsers.userSignup);

module.exports = router;

var mongoose  = require( 'mongoose' );
var mongoURI = 'mongodb://localhost/local';
var mongoDB = mongoose.createConnection(mongoURI);

mongoDB.on('connected', function (){
    // console.log("enviorment:" + process.env.NODE_ENV);
    // console.log("mongolab:" + process.env.MONGOLAB_URI);
    console.log('mongoose connected to ' + mongoURI);
});

mongoDB.on('disconnected', function (){
    console.log('mongoose disconnected ');
});

require('./users');

var mongoose = require('mongoose');
var Schema =  mongoose.Schema;

var userSchema = new Schema({
    username: {type: String, required: true, unique: true},
    password: {type: String, required: true},
    email: {type: String, required: true},
    gender: {type: Boolean, "default": "m"},
    createdOn: {type: Date, "default": Date.now}
});

module.exports = mongoose.model('User', userSchema);

var mongoose  = require( 'mongoose' );
var User = mongoose.model('User');

module.exports.userInfo = function(req,res) {
    res.render('signup', {
        title: 'User List'
    });
};

module.exports.userSignup = function(req,res) {
    console.log(req.body);
    console.log(User);
    if (req.method == 'POST') {
        // console.log("[200] " + req.method + " to " + req.url);
        User.create({
            username: req.body.username,
            password: req.body.password,
            email: req.body.email
        },function (err, user) {
            console.log(err);
            if(err) handleError(err);
            console.log('User saved successfully!');
        });
    }
};

{ [Function: model]
  hooks: Kareem { _pres: {}, _posts: {} },
  base:
   Mongoose {
     connections: [ [Object], [Object] ],
     plugins: [],
     models: { User: [Circular], Location: [Object] },
     modelSchemas: { User: [Object], Location: [Object] },
     options: { pluralization: true } },
  modelName: 'User',
  model: [Function: model],
  db:
   NativeConnection {
     base:
      Mongoose {
        connections: [Object],
        plugins: [],
        models: [Object],
        modelSchemas: [Object],
        options: [Object] },
     collections: { users: [Object], locations: [Object] },
     models: { User: [Circular], Location: [Object] },
     config: { autoIndex: true },
     replica: false,
     hosts: null,
     host: null,
     port: null,
     user: null,
     pass: null,
     name: null,
     options: null,
     otherDbs: [],
     _readyState: 0,
     _closeCalled: false,
     _hasOpened: false,
     _listening: false },
  discriminators: undefined,
  schema:
   Schema {
     paths:
      { username: [Object],
        password: [Object],
        email: [Object],
        gender: [Object],
        createdOn: [Object],
        _id: [Object],
        __v: [Object] },
     subpaths: {},
     virtuals: { id: [Object] },
     singleNestedPaths: {},
     nested: {},
     inherits: {},
     callQueue: [ [Object], [Object] ],
     _indexes: [],
     methods: {},
     statics: {},
     tree:
      { username: [Object],
        password: [Object],
        email: [Object],
        gender: [Object],
        createdOn: [Object],
        _id: [Object],
        id: [Object],
        __v: [Function: Number] },
     _requiredpaths: undefined,
     discriminatorMapping: undefined,
     _indexedpaths: undefined,
     s: { hooks: [Object], queryHooks: [Object] },
     options:
      { typeKey: 'type',
        id: true,
        noVirtualId: false,
        _id: true,
        noId: false,
        validateBeforeSave: true,
        read: null,
        shardKey: null,
        autoIndex: null,
        minimize: true,
        discriminatorKey: '__t',
        versionKey: '__v',
        capped: false,
        bufferCommands: true,
        strict: true,
        pluralization: true } },
  collection:
   NativeCollection {
     collection: null,
     opts: { bufferCommands: true, capped: false },
     name: 'users',
     collectionName: 'users',
     conn:
      NativeConnection {
        base: [Object],
        collections: [Object],
        models: [Object],
        config: [Object],
        replica: false,
        hosts: null,
        host: null,
        port: null,
        user: null,
        pass: null,
        name: null,
        options: null,
        otherDbs: [],
        _readyState: 0,
        _closeCalled: false,
        _hasOpened: false,
        _listening: false },
     queue: [ [Object] ],
     buffer: true,
     emitter:
      EventEmitter {
        domain: null,
        _events: {},
        _eventsCount: 0,
        _maxListeners: undefined } } }