Model: Tasks

To start, let’s modify the models/tasks.js file, applying the following code.

 1   module.exports = (sequelize, DataType) => {
 2     const Tasks = sequelize.define("Tasks", {
 3       id: {
 4         type: DataType.INTEGER,
 5         primaryKey: true,
 6         autoIncrement: true
 7       },
 8       title: {
 9         type: DataType.STRING,
10         allowNull: false,
11         validate: {
12           notEmpty: true
13         }
14       },
15       done: {
16         type: DataType.BOOLEAN,
17         allowNull: false,
18         defaultValue: false
19       }
20     }, {
21       classMethods: {
22         associate: (models) => {
23           Tasks.belongsTo(models.Users);
24         }
25       }
26     });
27     return Tasks;
28   };

The function sequelize.define("Tasks") is responsible for creating or changing a table. This happens only when Sequelize syncs with the application during boot time (in our case, this happens on the libs/boot.js file via the app.db.sync() function). The second parameter is an object; their attributes respectively represent the fields of a table, and their values are subattributes that describe the data type of their fields.

On this model, the field id is an integer via DataType.INTEGER. It represents a primary key (primaryKey: true) and its value is autoincremented (autoIncrement: true‘) on each new record.

The field title is a string (DataType.STRING). This field has the attribute allowNull: false to block null values and it is a validator field as well, which verifies if the string is not empty (validate.notEmpty: true). The field done is a boolean (DataType.BOOLEAN) that doesn’t allow null values (allowNull: false). By the way, if a value is not informed in this field, it will be registered as false via the defaultValue: false attribute.

Finally, we have a third parameter, which allows including static functions within the attribute classMethods. The associate(models) function was created to allow models’ relationships . In this case, the relationship was established via the Tasks.belongsTo(models.Users) function, because this is a Tasks 1-NUsers relationship.

Model: Users

To complete our database modeling, let’s create a model that will represent the users of our application. You need to create the models/users.js file with the following model definitions.

 1   module.exports = (sequelize, DataType) => {
 2     const Users = sequelize.define("Users", {
 3       id: {
 4         type: DataType.INTEGER,
 5         primaryKey: true,
 6         autoIncrement: true
 7       },
 8       name: {
 9         type: DataType.STRING,
10        allowNull: false,
11        validate: {
12          notEmpty: true
13        }
14       },
15       password: {
16         type: DataType.STRING,
17         allowNull: false,
18         validate: {
19           notEmpty: true
20         }
21        },
22        email: {
23          type: DataType.STRING,
24          unique: true,
25          allowNull: false,
26          validate: {
27            notEmpty: true
28          }
29         }
30       }, {
31         classMethods: {
32           associate: (models) => {
33             Users.hasMany(models.Tasks);
34           }
35        }
36      });
37      return Users;
38   };

This time, the modeling of the table Users was very similar to Tasks. The only difference was the inclusion of the unique: true attribute, inside the field email, to ensure that repeated e-mails won’t be allowed .

After finishing this step, we are going to change some codes in the project so it can load these models correctly and run their respective relationship functions in the database. To start, let’s modify some of the modules loading on index.js. First, we are going to order the loading of the modules so the libs/config.js is loaded first, then the db.js, and then also remove the loading of the models directory from consign, because now all models are loaded from db.js. The code should look like this.

 1   import express from "express";
 2   import consign from "consign";
 3   
 4   const app = express();
 5   
 6   consign()
 7     .include("libs/config.js")
 8     .then("db.js")
 9     .then("libs/middlewares.js")
10     .then("routes")
11     .then("libs/boot.js")
12     .into(app);

The reason the directory models was deleted from consign() is that now, all models will be loaded directly by db.js file, via the sequelize.import() function. After all, if you go back to the models codes, you will notice that two new attributes within module.exports = (sequelize, DataType) appeared. Those are going to be magically injected via sequelize.import(), which is responsible for loading and defining the models. Let’s refactor the db.js file, to import and load all models correctly.

 1   import fs from "fs";
 2   import path from "path";
 3   import Sequelize from "sequelize";
 4   
 5   let db = null;
 6   
 7   module.exports = app => {
 8     if (!db) {
 9       const config = app.libs.config;
10       const sequelize = new Sequelize(
11        config.database,
12        config.username,
13        config.password,
14        config.params
15      );
16      db = {
17        sequelize,
18        Sequelize,
19        models: {}
20      };
21      const dir = path.join(__dirname, "models");
22      fs.readdirSync(dir).forEach(file => {
23        const modelDir = path.join(dir, file);
24        const model = sequelize.import(modelDir);
25        db.models[model.name] = model;
26      });
27      Object.keys(db.models).forEach(key => {
28        db.models[key].associate(db.models);
29      });
30     }
31     return db;
32   };

This time, the code got a little complex, didn’t it? Its features are pretty cool, though. Now we can use the database settings via app.libs.config object. Another detail is in the execution of the nested function fs.readdirSync(dir).forEach(file), which basically returns an array of strings referring to the file names from the directory models. Then, this array is iterated to import and load all models using the sequelize.import(modelDir) function and, then, inserted in this module inside the structure db.models via db.models[model.name] = model.

After loading all models, a new iteration happens through the Object.keys(db.models).forEach(key) function, which basically executes the function db.models[key].associate(db.models) to ensure the models’ relationship.

To finish the adjustments, we need to write a simple modification in the libs/boot.js file, changing from the app.db.sync() function to app.db.sequelize.sync():

1   module.exports = app => {
2     app.db.sequelize.sync().done(() => {
3       app.listen(app.get("port"), () => {
4         console.log(`NTask API               - Port ${app.get("port")}`);
5       });
6     });
7   };

Then, let’s modify routes/tasks.js to load the Tasks model correctly using app.db.models.Tasks and modify the function Tasks.findAll() to this Promises-based function provided by Sequelize . This is how it should look.

1   module.exports = app => {
2     const Tasks = app.db.models.Tasks;
3     app.get("/tasks", (req, res) => {
4       Tasks.findAll({}).then(tasks => {
5         res.json({tasks: tasks});
6       });
7     });
8   };