Forem: Chiemeke Ifeanyi

How to add mail notification to Sequelize

Chiemeke Ifeanyi — Tue, 26 May 2020 14:45:03 +0000

Laravel's Eloquent (ORM) offers a notification trait that enables you send notification from the model itself. As sequelize doesn't ship with a notify method as Eloquent, we would be creating our own.

Sounds exciting right? Lets dig in!!!

Note: Basic knowledge of Sequelize and Nodemailer is needed. Try reading up on them first :).

We would be kicking things off by creating our package directory called "sequelizeNotifier".

So, lets get this party started!!!

Create sequelizeNotifier entry point.

We kick things off by creating an entry point for our package. To do this, we would create an index.js file in the root path of our package. We then pass the Sequelize object then extend it by adding a notify function to its prototype. We also pass a config parameter for our transport configuration. Don't bother about the dependicies, we are going to create them let's just keep going.

sequelizeNotifier/index.js

 const notifier = require('./src/notify');
 const transport = require('./src/mailer');

 module.exports = function (Sequelize,config) {

    Sequelize.Model.prototype.notify = function (options){
       let initTransport = transport(config);
       return  notifier(this,initTransport,options);
    }

};

Create the Mail Object.

Now let us create a mail function that initializes the nodemailer transport in which returns this transport back to us.

sequelizeNotifier/src/mailer.js

 const nodemailer = require('nodemailer');

 module.exports = function mailer(config) {

        try{

            let transport =  nodemailer.createTransport(config);
            return transport;

        }catch (e) {
            console.warn(e);
        }

}

Create the notifier

sequelizeNotifier/src/notify.js
Finally, let us create the "notify" method. This is the method that would be called anytime we call the notify method from the sequelize model.

 module.exports = function  notify (model,transport,options) {

    try{
        let mail =  transport.sendMail({
            from:'no-reply@myapp.com',
            to:model.email,
            ...options
        });
        console.log(mail)
    }catch (e) {
        console.log(e)
    }
}

Pheewwww we are almost done. It's time to test this beast!!!

Usage:

I am sure you might have a different approach for configuring your application with Sequelize, but in-respective of your configuration style, just pass the sequelize package into our sequelizeNotifier package with it's configuation and we are good to go

const Sequelize = require('sequelize');
const config = {
                host:'smtp.example.com',
                port:"273",
                secure:"false",
                auth:{
                    user:"james",
                    pass:"example"
                }
            }
require('path/to/sequelizeNotifier')(Sequelize,config);
//more codes

Now let's assume we have our register.js file for registering a new user. After creating the user, you would want to notify the user her account has been created. Here is a snippet of register.js:

 const {User} = require('./models');
 module.exports = function register(req,res){
   try{
     const user = await User.create({
       name:"chiemeke Ifeanyi",
       email:"example@gmail.com"
     });
     //send mail
     const messageObject = {
                        subject: "Account Created Successfully",
                        text: `Hi ${user.name}, welcome to my app`,
                    }
     user.notify(messageObject);
   }catch(e){
    //catch eror
   }

}

//more codes

For more options to use with the messageObject, check out the nodemailer documentation here for sending messages.

That would be all folks.

ExpressJs Route Management

Chiemeke Ifeanyi — Fri, 08 May 2020 07:23:55 +0000

ExpressJs is an un-opionated framework for building NodeJs application quick. It comes with a routing feature which is quite easy to implement. But if you have written multiple ExpressJs powered project, you would agree with me that your routes becomes messier and even very hard to maintain as it begins to grow.
To solve this problem, I use a ExpressJs Route Manager to manage this ever growing routes.
Using Expressjs Route Manager your routes can be easily managed.

Here is an implementation:

server.js

 const express               = require("express");
 const app                   = express();
 const options               = {
                                 routeFile:"app/routes",//path to your route file
                                 controllerDirectory:"app/controllers",//path to your controller files 
                                 middlewareDirectory:"app/middlewares" //path to your middleware files
                               }
 const expressRouterManager  = require("expressjs-route-manager")
(app,options);


 app.listen(process.env.API_PORT||'3000',(err)=>{
      console.log(`> server started on port ${process.env.API_PORT||'3000'} `
 });

 app.on('error',(err)=>{
      console.log(err);
      return;
 })

app/routes.js
Let's assume that our application has an api namespace which in turn has an auth namespace which has a login endpoint, our route file would thus look like this:

module.exports = {
    'api': {
      'auth': {
         'login': {
            controller: {
               path: 'auth',
               method: 'login'
             },
             verb: 'post'
           }     
        }
    }
}

controller
Writing your controller is the same as always. Here is an example:

app/controllers/auth.js

 module.exports = class Auth{
                    login(req,res){
                      res.send('hello world');
                    }
                  }

There are numerous ways of writing your controller, you are not limited to the example above. For example you could write it as a function.
Lets add a signup controller to our application.

module.exports = {
    'api': {
      'auth': {
         'login': {
            controller: {
               path: 'auth',
               method: 'login'
             },
             verb: 'post'
          },
          'signup': {
            controller: {
               path: 'signup',
             },
             verb: 'post'
          }   
        }
    }
}

app/controllers/signup.js

 module.exports = (req,res)=>{
                   res.send('hello world');
                  }

Note: When using functions as your controller, you do not need to add method property to your controller, if you do so ExpressJs Route Manager would treat your controller as a class instead of a function.

The above routes would be accessed via:
/api/auth/login
/api/auth/signup

NameSpace

ExpressJs Route Manager helps you group your routes within namespaces. For instance, the above examples shows that the api namespace houses the auth namespace. The end of a namespace is indicated by the introductionn of a controller.

Middlewares

Middlewares can be added at any point in your route namespace. When a middleware is added within a namespace, it affects that namespace and even its children namespaces.
We are going to modify our route file to use middlewares.

module.exports = {
    'api': {
      middlewares:["cors"],
      'auth': {
         'login': {
            controller: {
               path: 'auth',
               method: 'login'
             },
             verb: 'post'
          },
          'signup': {
            controller: {
               path: 'signup',
             },
             verb: 'post'
          }   
        }
    }
}

app/middlewares/cors.js

module.exports = function cors(){
  return function (req,res,next) {
    //do middleware things here
    next();
  }
}

You can add middlewares at any level of your route file.

Conclusion

Managing your ExpressJs routes can be a pain in the ass most times and this simple library objects to build your routes intuitively and with simplicity.

Have an idea on how to make it even better? Create a pull request here:

darnyelx / expressjs-route-manager

A library that helps you organize and group your expressjs route intuitively

NPM package can be found here: