Sequelize

Sequelize is a dynamic and powerful JavaScript library. It is a promise-based ORM (Object Relational Mapping) that deals with the management versions of the database primarily SQL database. It can also support other databases like PostgreSQL, MySQL, SQLite, and MSSQL. It is also popularly known as Object-Relation Mapper because it maps object syntax into a database schema. Although there are no prerequisites for learning it familiarity with Node.js and JavaScript syntax used for mapping would be fruitful. In this article, we would be discussing the very basics of Sequelize and check out its installations and implementations.

Additionally, it is important to note that Sequelize is promise-based. Thus, it makes the processes easier to manage about the occurring exceptions and asynchronous functions. On the other hand, there's no support for NoSQL, and can be only done if Object Document Mapper is present on the dependencies like that of Mongoose. This fact depends on the ORM which can further relate mainly to the project requirement we're working on. However, Sequelize supports various types of actions be it solid transaction support, reading and writing applications, the relationship among transactions, and much more. So, let's proceed with the installation of Sequelize.

Installation

Depending upon the requirement of the project, it is always recommended to use PostgreSQL for carrying out operations with Sequelize since it is much easier to edit and view the database with it.

Before proceeding, let's initialize the packages before installing them.

Now, install PostgreSQL dependencies with the below command.

npm install sequelize

npm install pg pg-hstore

If we are using MySQL, SQLite, MariaDB or MSSQL database, we need to type the following command.

npm install mysql2

  npm install sqlite3
  
  npm install mariadb

  npm install tedious

Usage

To connect the above mentioned databases, follow the respective associated commands which are somewhat common for all of them.

const { Sequelize } = require('sequelize');


const sequelize = new Sequelize('sqlite::memory:')  // SQLite
const sequelize = new Sequelize('postgres:')   // PostgreSQL


const sequelize = new Sequelize({
  dialect: 'sqlite',
  storage: 'path/to/database.sqlite'
});

//For all other databases

const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql' | 'mariadb' | 'postgres' | 'mssql' 
});

Before starting, whatever might be the application we have been working with, we need to install Nodemon so that the application gets updated whenever we save changes.

We can now continue writing your application and storing them in our respective databases.

Some other actions might include checking your connectivity of the database which can be done using the below command.

 try {
  await sequelize.authenticate();
  console.log('Connection test successful');
} 
catch (error)
 {
  console.error('Err...Error Occured:', error);
}

One of the most important implementations of using Sequelize as it is promise-based ORM is to create a mapping model using it, reading, updating, and deleting the entities in the database. Let's visualize them with the help of the code snippets that display the required actions.

Creating mapping model

const Note = sequelize.define('notes', { note: Sequelize.TEXT, tag:
 Sequelize.STRING });

The above code creates notes to be later considered for reading, updating, or deleting using Sequelize. The next step is to keep the things in sync and therefore the below code with the .sync() function is used to define all the definite modeling in the database.

const Note = sequelize.define('notes', { note: Sequelize.TEXT, tag:
 sequelize.STRING })sequelize.sync({ force: true })
  .then(() => {
    console.log(`Database & tables created!`);
  });

The further steps include reading, updating and deleting which can be done by including the following code examples.

Example 1: Reading all notes

Consider the below code:

app.get('/notes', function(req, res) {
  note.findAll().then(notes => res.json(notes));
});

Example 2: Updating notes

Consider the below code:

app.put('/notes/:id', function(req, res) {
  note.findByPk(req.params.id).then(function(note) {
    note.update({
      note: req.body.note,
      tag: req.body.tag
    }).then((note) => {
      res.json(note);
    });
  });
});

Example 3: Deleting notes

Consider the below code:

app.delete('/notes/:id', function(req, res) {
  note.findByPk(req.params.id).then(function(note) {
    note.destroy();
  }).then((note) => {
    res.sendStatus(200);
  });
});

There are still much more actions that can be performed using the Sequelize library. We have discussed the most commonly used actions.

Summary

In this tutorial, we came across from very basics of Sequelize to their usage in advanced level applications with Node.js. We also came across various databases with which it works fine despite NoSQL that has the exception of not being able to cope out with it. We also came across the different methods that are taken into account while reading, updating, and deleting the nodes and also creating them using Sequelize. Thus, Sequelize is a promise-based Object Relational Mapping (ORM) that defines a technique of mapping software objects to the tables of the database. It is a popular and balanced ORM tool used with Node.js alongside for handling simple and complex actions. The main advantage of using ORMs with Sequelize is to persist notes and model mapping to the database. The methods we studied above are inherited methods and they serve to perform CRUD (Create, Read, Update, Delete) operation on the chosen database for our project.

Next TopicCloudinary

← prev next →