DEV Community: Vaishnavi Rawool

Introduction to Sequelize: Simplifying Database Operations in Node.js

Vaishnavi Rawool — Thu, 27 Jun 2024 07:38:36 +0000

What is a ORM ?

ORM (Object-Relational Mapping) bridges databases and object-oriented programming by mapping database tables to objects in code. It allows developers to interact with databases using familiar programming constructs, abstracting away SQL queries for easier development and maintenance of applications.

Advantages of ORMs

ORMs abstract away the need to write raw SQL queries directly in your application code, reducing the complexity
Complex database operations, such as JOINs and GROUP BYs, can be expressed in a simpler syntax using ORM methods and APIs.
Supports transactions and rollback mechanisms
ORMs can significantly reduce development time and effort
ORMs includes features for optimizing query performance (e.g., lazy loading).
Same application logic can be used with different database systems (e.g., MySQL, PostgreSQL, SQLite) without significant changes
ORMs offer built-in validation mechanisms (e.g., unique, not null). You can also write custom validations (e.g., email regex validation, phone number validation)

Disadvantages of ORMs

ORMs introduce a learning curve as developers need to familiarize themselves with the ORM's API and its querying methods
Understanding how the ORM translates application code into SQL queries often requires digging into ORM logs or debugging mechanisms.
Despite the ORM's capabilities, there are situations where developers may need to resort to writing raw SQL queries for certain operations. Sequelize, for example, provides mechanisms for executing raw SQL queries when needed.

Getting started with Sequelize

1] Installation

npm install sequelize

or

yarn add sequelize

2]You'll also have to manually install the driver for your database of choice:

One of the following:

$ npm install --save pg pg-hstore # Postgres

$ npm install --save mysql2

$ npm install --save mariadb

$ npm install --save sqlite3

$ npm install --save tedious # Microsoft SQL Server

$ npm install --save oracledb # Oracle Database

Connecting to a Database

1] Create a config.json and store development db details as follows:

{

    "development": {

      "username": "postgres",

      "password": "root",

      "database": "travel",

      "host": "localhost",

      "dialect": "postgres",

      "port":"5432"

    }

  }

Similarly you can add details of other environments e.g., staging/production

2] Create a dbConfig.js file and paste the following code :

const path = require('path');

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

// Load Sequelize configurations from config.json file
const env = process.env.NODE_ENV || 'development'; // default environment is development if not set explicitly

const config = require("./config.json")[env];

// You will have to pass database name, username, password, host, port and dialect (in this case postgres) inorder to create a instance.

const sequelize = new Sequelize(config.database, config.username, config.password, {

  host: config.host,

  dialect: "postgres",

  port: config.port

});

// export the newly created instance from this file
  module.exports.sequelize = sequelize;

Sequelize provides authenticate() function to check whether the database connection was successful

try {

  await sequelize.authenticate();

  console.log('Connection has been established successfully.');

} catch (error) {

  console.error('Unable to connect to the database:', error);

}

Let us explore the basics of model creation in sequelize.

In Sequelize, a model represents a table in a database.
You define a table structure i.e columns, relationships (one-to-one, one-to-many etc), indexes, hooks etc using a model
Columns in a Sequelize model are defined using attributes.
Attributes can specify various parameters, including:

type: Specifies the data type of the column (e.g., STRING, INTEGER, DATE).
allowNull: Indicates whether the column can be null (true or false).
defaultValue: Sets a default value for the column if not provided.
primaryKey: Marks the column as the primary key (true or false).
unique: Ensures the column values are unique (true or false).
Other constraints like autoIncrement, references, onDelete, etc., can also be defined depending on the database relationship requirements.

Create a user.model.js file inside models folder that has a simple User model configuration code.

const { Sequelize, DataTypes, Model } = require('sequelize');

const sequelize = require(‘./dbConfig.js’);

class User extends Model {}

User.init(
  {

// id attribute which is a primary key

   id: {
     type: DataTypes.INTEGER,
     primaryKey: true,
     autoIncrement: true
    },

    firstName: {
      type: DataTypes.STRING,
      allowNull: false,
    },

    lastName: {
      type: DataTypes.STRING,
      // allowNull defaults to true
    },
  },
  {
    // Other model options go here
    sequelize, // We need to pass the connection instance that we have created earlier
    modelName: 'User', // We need to choose the model name
  },
);

You can define relationships between tables using sequelize. Consider the example below, where we create a one-to-many association between the User and Address tables using hasMany:

User.Addresses = User.hasMany(Address);

Similarly, you can create one-to-one and many-to-many relations as well. Read in detail about relationships
Model Associations

Model Synchronization

When you define a model, you're telling Sequelize a few things about its table in the database. However, what if the table actually doesn't even exist in the database? What if it exists, but it has different columns, less columns, or any other difference?

This is where model synchronization comes in. A model can be synchronized with the database by calling model.sync(options), an asynchronous function (that returns a Promise). With this call, Sequelize will automatically perform an SQL query to the database. Note that this changes only the table in the database, not the model in the JavaScript side.

User.sync() - This creates the table if it doesn't exist (and does nothing if it already exists)
User.sync({ force: true }) - This creates the table, dropping it first if it already existed
User.sync({ alter: true }) - This checks what is the current state of the table in the database (which columns it has, what are their data types, etc), and then performs the necessary changes in the table to make it match the model.

Let us explore some basics CRUD operations with the help of sequelize:

1] Create a new record

create() method is asynchronous hence we have to put await before it
Import User from user.model.js file

const User = require(‘../model/user.model.js’);

const jane = await User.create({ firstName: 'Jane', lastName: 'Doe' });


// Jane exists in the database now!
console.log(jane instanceof User); // true
console.log(jane.name); // "Jane"

2] Simple SELECT queries (all of the querying methods are asychronous)

// fetch all users from user table

const users = await User.findAll();

// fetch certain fields from user table

await User.findAll({  attributes: [firstName,’lastName’]});

//apply where clause and fetch user with id = 1

await User.findAll({ where: {  id: 1, }});

Read more about model querying here: Model Querying

3] Update query

await User.update( { lastName: 'Doe' },{
    where: {
      lastName: null,
    },
  },
);

4] Delete query

// Delete everyone named "Jane"
await User.destroy({
  where: {
    firstName: 'Jane',
  },
});

CONCLUSION

Sequelize offers a comprehensive documentation covering various SQL methods along with advanced topics such as Joins, Aggregate functions, Transactions, and Lazy Loading. Its user-friendly navigation makes it accessible even for beginners, helping in a thorough understanding of the ORM. I highly recommend exploring Sequelize's documentation to delve deeper into its capabilities. Sequelize

Creating a Simple RESTful API with Node.js

Vaishnavi Rawool — Wed, 19 Jun 2024 17:54:05 +0000

What is an API ?

An API, or application programming interface, is a set of rules or protocols that enables software applications to communicate with each other to exchange data, features and functionality.It’s useful to think about API communication in terms of a request and response between a client and server. The application submitting the request is the client, and the server provides the response. The API is the bridge establishing the connection between them.

What are the types of APIs?

Some of the most common type of APIs are:

RESTful APIs: Use standard HTTP methods like GET, POST, PUT, DELETE to interact with resources identified by URLs. They are stateless and follow the principles of REST for scalability and simplicity in client-server communication.
SOAP APIs: Employ XML-based messaging and typically use protocols like HTTP or SMTP. They adhere to a strict messaging format and rely on a contract (WSDL) for defining endpoints and operations, making them suitable for complex integrations requiring strong reliability and security measures.

What is REST ?

REST stands for Representational State Transfer. It's an architectural style for designing networked applications. Here’s a simple explanation:

Imagine you're in a restaurant. When you want to order food, you ask the waiter for the menu, choose your dishes, and tell the waiter your order. REST works similarly in the digital world:

Resources: Think of these as items on the menu — they can be data or functionality (like getting information or saving data).
HTTP Methods: These are like actions you can take with your order, such as GET (to retrieve data), POST (to add new data), PUT (to update data), DELETE (to remove data).
URLs: Just like how you tell the waiter where to bring your food, URLs specify where to find or interact with resources.

RESTful APIs use these concepts to allow different systems to communicate over the internet, making it easier for computers to share and use information effectively.

Know everything about REST -> https://restfulapi.net/

How to create REST APIs in Node.js ?

- Tools Required

Node.js (Node.js is a runtime environment that allows developers to run JavaScript code outside of a web browser, enabling server-side scripting and building scalable network applications)
Express.js (Express.js is a minimalist Node.js web framework with features for routing, middleware support, and simplified handling of HTTP requests and responses.)
VS Code (Code Editor) or any other editor of your choice

Step 1: Install latest versions of above mentioned software

Step 2: Creating a Node Project

Create a new folder called node-rest-apis
When installing Node.js, npm, the package manager, is also installed, that helps us create a new node project
Open the integrated terminal within VS Code with the following command -> Ctrl + `
Enter the following command -> npm init
Follow the prompt -> npm init will ask you for information such as the project name, version, description, entry point (usually index.js), test command, repository URL, author information, and license. You can either fill out these details or simply press Enter to accept the default values.

Step 3: Install express with the help of npm: npm install express

Step 4: Create a file named index.js file (you may give it any name of your choice)

Step 5: Overview of the files/folders created

package.json: package.json file stores metadata about your project and its dependencies. Whenever we install new dependencies, they are automatically added to the dependencies section of the package.json file in our Node.js project
node_modules: This directory houses all the dependencies that your project requires. These dependencies are installed via npm or yarn and are listed in package.json.
index.js : This file usually serves as the entry point to your application. It initializes your application, sets up configurations, and may start the server if it's a web application.

Step 6: Install nodemon npm install nodemon

Nodemon is a utility tool for Node.js that helps in development by automatically restarting the Node application when changes are detected in the codebase. This eliminates the need to manually stop and restart the server after every code change, thus speeding up the development workflow.

Make changes to the start script and run the server using the following command : npm start

Step 7: Let’s start by creating a node server

Code explanation:

require('express'): Imports the Express module.
const app = express(): Creates an instance of the Express application.
const port = 3000: Specifies the port number where the server will listen for incoming requests.
app.listen(port, ...): Starts the Express server on the specified port (3000 in this case) and logs a message to the console once the server is running.

For running your application add the following start script in package.json:

You can you run your application with the following command: node index.js

Step 8: Create a basic API route in express

Defines a route handler for the GET request at /test. When a GET request is made to /test, it sends back a JSON response { message: 'This is a sample API route' }

Step 9: Testing the API using Postman

Postman is a collaborative platform for API development that simplifies the process of designing, testing, and debugging APIs.

The API gives a successful response

Step 10: Let’s organize the code in a MVC (Model, View, Controller) like pattern

Create controllers, services, routes, models folder in the root directory

Step 11: Create a file name user.model.js under models folder

These functions mimic basic CRUD (Create, Read, Update, Delete) operations commonly performed on user data in applications. Other CRUD operations like create, update, and delete could be added as needed to complete the CRUD functionality.

Step 12: Create a file name user.service.js under services folder

The service files have all the business logic implemented. For eg: all the users related CRUD operations will go inside this file

Code Explanation:

Import the User model to interact with user data
Call getUsers and getUsersById methods to perform corresponding operations
Each method calls methods from model layer. In a real-time project this would include operations performed using a ORM (Object Relationship Mapper). Find more on ORMs here : https://medium.com/@rishu__2701/node-js-database-magic-exploring-the-powers-of-sequelize-orm-a22a521d9d9d

Step 13: Create a file name user.controller.js under controllers folder

In your controllers , you would import and use the service methods to handle HTTP requests

Code Explanation:

-Import respective service function within the controller file, in our case user.service.js within user.controller.js

Define route handlers getAllUsers and getUserById
Within getAllUsers we are retrieving all user data and sending it as a response with a HTTP status 200. In scenarios where database operations are involved, the data retrieval might fail. In that case, the response needs to be sent accordingly with a status 500.
getUserById(), finds userId from request params. Find more on request params https://www.geeksforgeeks.org/difference-between-req-query-and-req-params-in-express/
Send user data with status 200 on successful response
Send 404 if User is not found
More on HTTP status codes here https://developer.mozilla.org/en-US/docs/Web/HTTP/Status

Step 14: Create a file name user.routes.js under routes folder

user.routes.js is typically a file where you define and configure all your application routes using Express Router. Here’s how you can structure and explain a routes.js file:

Step 15: Advantages of following this code pattern

Separation of Concerns: The service layer (user.service.js) encapsulates business logic and serves as an intermediary between controllers and models.
Reusability: Services can be reused across different parts of the application, promoting code reuse and maintaining DRY (Don't Repeat Yourself) principles. In the scenarios where multiple services need to be called together, a manager file can be created (eg: user.manager.js) that imports all the required services and calls them wherever required. Manager file in turn needs to be imported in controller file.
Modularity: Each layer (models, services, controllers) has a distinct responsibility, making the application easier to understand, test, and maintain.
Mock Data: In real-world applications, you would replace the mock data and methods in the model (User.js) with actual database interaction using libraries like Mongoose, Sequelize, etc.

Step 16: Mounting routes.js in app.js

In your main application file (e.g., index.js), you would integrate routes.js by mounting the router using app.use().

const usersRoute = require('./routes/user.route'); Import the routes.js file.

app.use('/users, routes);: Mount the router at the / users prefix. All routes defined in routes.js will be accessible under / users (e.g., / users /:id, / users /:id/likes, etc.

Step 17: Test APIs with Postman

More Resources on REST APIs

HTTP Verbs -> https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods

REST naming conventions -> https://restfulapi.net/resource-naming/

API Documentation -> https://swagger.io/blog/api-documentation/what-is-api-documentation-and-why-it-matters/

Conclusion:

In summary, REST APIs are essential for modern web development, providing a standardized way for clients and servers to communicate efficiently. Node.js with Express.js offers a powerful framework for creating RESTful APIs, enabling developers to build scalable and maintainable backend systems.

By leveraging Node.js's non-blocking architecture and Express's simplicity, developers can quickly create robust API endpoints for various applications. Understanding these technologies ensures you can deliver efficient, secure, and adaptable backend solutions that meet current and future needs in web development.

Follow for more insightful content on web development and stay updated with the latest tips and tutorials. See you next week with more valuable insights!