Ts-sequelize-models

This package is made to help you initialize sequelize models very easily not only that but , also it will help you make a very neat and good looking sequelize models using typescript.

Table of contents

• Prerequisite packages
• Installation
• How to make your sequelize models
  • Basic usage
  • Associations
  • Hooks
  • Option paramters in sequelize define
  • All available functions and properties to override
• How to initializate your models
  • sequelizeInit method details
  • sequelizeInit option paramter details
• Feedback
• Planned features

Please if there is anything that is not clear enough in the documentation create an issue or email me on abdoolly@gmail.com

Prerequisite

• Before installing you will need to install of course sequelize using npm i sequelize
• you will also need to install sequelize type declarations using this command npm i @types/sequelize

Installation

• Now to install this package just type

  npm i ts-sequelize-models

How to make your sequelize models

Basic usage

• first you need to make a class and extend the base class sequelizeModel like that.

import { DefineAttributes, DataTypes } from 'sequelize';
 
export class User extends sequelizeModel {
 
    getAttributes(DataTypes: DataTypes): DefineAttributes {
        return {
            first_name: DataTypes.STRING,
            last_name: DataTypes.STRING,
            email: { type: DataTypes.STRING, unique: true },
            password: DataTypes.STRING,
        };
    }
 
}

The above code does exactly what this sequelize code does

sequelize.define('User', {
            first_name: DataTypes.STRING,
            last_name: DataTypes.STRING,
            email: { type: DataTypes.STRING, unique: true },
            password: DataTypes.STRING,
        }
    });

• The class name will be your name of the model if you wanted different you can always override the modelName property.
• when you class extend the sequelizeModel it will ask you to implement the getAttribute() function which will be the attributes that will be used to create your table.

Associations

This was the basic usage but , how to make associations with that model

• you just need to override the associate() method and inside it define your associations like that.

    associate(models: any, currentModel: Model<any, any>): any {
        models.Role.hasMany(currentModel, { constraints: false, allowNull: true, defaultValue: null });
        // you can do as many associations as you want here
    }

• now after that your have finished the associations

Hooks

Now How to add sequelize Hooks

• just as easy as overriding a function and return a callback from it like that

beforeCreate() {
    return (user: any, options: any) => {
        
        return hashPassword(user.password).then(hashedPw => {
            user.password = hashedPw;
        });
    }
 }

The above function will exactly do when you do that code using the normal sequelize models

User.beforeCreate((user: any, options: any) => {
return hashPassword(user.password).then(hashedPw => {
            user.password = hashedPw;
        });
 });

• now it looks much more neater

Hint : you now don't need to go to the sequelize docs to know what hook functions are available. All hooks are just available when you press your auto complete keys cause this the beauty of typescript.

All available functions and properties to override

modelName

This is a property in which if you wanted the model name to be with a certain name different than your class name just override it and set its value to what you want.

getAttributes()

This method is used to return the attributes of your table which will be used during the model definition This is the only required method in the class

example:

import { sequelizeModel } from 'ts-sequelize-models';
import { DefineAttributes, DataTypes } from 'sequelize';

export class User extends sequelizeModel {
    getAttributes(DataTypes: DataTypes): DefineAttributes {
        return {
            first_name: DataTypes.STRING,
            last_name: DataTypes.STRING,
            email: { type: DataTypes.STRING, unique: true },
            password: DataTypes.STRING,
        };
    }
}

associate()

This method is used to make you model relation with other tables it does not return anything

example:

associate(models: any, currentModel: Model<any, any>): any {
        models.Role.hasMany(currentModel, { constraints: false, allowNull: true, defaultValue: null });
}

getOptions()

This is a method which is used to get the options paramter in the sequlize.define which was the third paramter in that method it does not get any paramters but , it require you to return an object of DefineOptions<any>

NOTE also this function according to sequlize reference you can add hooks in the options when you add hooks here it override any hook in the model if it was with the same name but if it was with a different name they just merge together.

example:

I am just putting the imports I used above each function for you to know the import needed for the types

import { DefineOptions } from 'sequelize';
getOptions(): DefineOptions<any> {
        return {
            hooks: {
                beforeValidate: (user, options) => {
                    user.mood = 'happy';
                },
                afterValidate: (user, options) => {
                    user.username = 'Toni';
                }
            }
        };
 }

modelAction()

This method I have put to give you the flexibility to add as many hooks as you want and how you want it or do what ever you wish with model in it. It's made for any missing thing I did not include also it does not return anything but, it accepts the following

Paramters description

example:

modelAction(model: Model<any, any>) {
        model.addHook('afterValidate', 'someCustomName', (user, options) => {
            return sequelize.Promise.reject(new Error("I'm afraid I can't let you do that!"));
        });

        // or do this

        model.afterValidate('myHookAfter', (user, options) => {
            user.username = 'Toni';
        });

        // you can do here what ever you like with the model I just execute the function for you 
    }

These are sequelize hooks functions and which you can override

you can override them and return from them the closure as documented in sequelize documentation here http://docs.sequelizejs.com/manual/tutorial/hooks.html

The sequlize reference explain very well how to use them I will just show you how to override one function and return the closure from it to see how it works then the same concept applies on the rest of all the available hooks.

beforeValidate()

This hook is called before validation you can override it to be like that:

beforeValidate() {
        return (user: any, options: any) => {
            user.username = 'Toni';
        }
 }

as you can see all you do is override the function then return the closure you want to happen in the hook the same concept applies on all the hooks if you wanted to make named hooks then just put them in the modelAction method.

afterValidate()

beforeCreate()

afterCreate()

beforeDestroy()

beforeDelete()

afterDestroy()

afterDelete()

beforeUpdate()

afterUpdate()

beforeBulkCreate()

afterBulkCreate()

beforeBulkDestroy()

beforeBulkDelete()

afterBulkDestroy()

afterBulkDelete()

beforeBulkUpdate()

afterBulkUpdate()

beforeFind()

beforeFindAfterExpandIncludeAll()

beforeFindAfterOptions()

afterFind()

Option paramters in sequelize define

Now How to pass the options parameter in the sequelize.define

you just need to override the getOptions() method like that and don't forget to make it's return type so typescript would autocomplete to you the attributes you can enter

getOptions(): DefineOptions<any>{
  return {
  // your options here
  };
}

More Detailed documentation is coming in a few days which will show all the functions that can be overriden and a full models examples to more illustrate the package.

How to initializate your models

• First just initalize your sequelize object using your config like that

const Sequelize = require('sequelize');
let sequelize = new Sequelize(config.database, config.username,  config.password, config);

• I required sequelize like that not with import cause sequelize only export the sequelize interface in it so it will work with you this way.

• In future versions I will make a function event to initialize the sequelize for you but , for now I give you the flexibility of creating it yourself.

• Now all is missing is this line of code to initialize all your models

import { sequelizeInit } from 'ts-sequelize-models';

let { sequelize, models } = await sequelizeInit(sequelize, './api/models/',
           {
               exposeGlobal: true
           });

• first paramter is your sequelize object you just created
• second parameter is the path to your compiled models
• third parameter is some options for sync I by default automatically sync for you with force:false
• this function above will return you two objects

sequelizeInit method details

sequelizeInit option paramter details

This is a detailed table to show you the options object in sequelizeInit()

Feedback

• I hope my package helps you by a way for another if you have some feedback please email me on abdoolly@gmail.com
• If you have found any issues please create an issue in the package repository https://github.com/abdoolly/ts-sequelize-models/issues
• If you some ideas or features you want me to add which could help you please email me on the above email.

Planned features

• Make the sequelize initialization inside the library so you just need to pass the configs.
• I will make a command line to declare your models in global.d.ts declarations which will help you use the models globaly.