Mastering CRUD Operations with Sequelize and Sequelize-Typescript in Node.js

Are you tired of struggling with complex database operations in your Node.js apps? If you’re a developer looking to streamline your database workflow with Sequelize and Sequelize-Typescript, you’re in the right place. This guide is designed to save you time and frustration by simplifying CRUD operations and giving you the tools to build efficient, scalable applications.

If this helps, don’t forget to follow for more tips on leveling up your backend skills. If it’s not exactly what you’re looking for, drop a comment and I’ll make sure to address your needs!

What is Sequelize?

Sequelize is an ORM that supports multiple SQL dialects like MySQL, PostgreSQL, and SQLite. It allows developers to define models, perform database operations, and manage relationships between tables in a simpler, more intuitive way than raw SQL.

Why Use Sequelize-Typescript?

While Sequelize provides an excellent API, the default JavaScript setup doesn’t provide type safety. Sequelize-Typescript is a wrapper around Sequelize that adds TypeScript support. It brings the benefits of TypeScript’s static typing, improving developer productivity and reducing runtime errors.

Setting Up Sequelize with Node.js

Let’s walk through setting up Sequelize and Sequelize-Typescript in a Node.js project to perform CRUD operations.

Step 1: Install Dependencies

To get started, first install the necessary packages:

npm install sequelize sequelize-typescript pg pg-hstore express
npm install --save-dev typescript @types/node

Step 2: Set Up Sequelize with TypeScript

Next, create a sequelize.ts file to configure Sequelize in your Node.js app:

import { Sequelize } from 'sequelize-typescript';

const sequelize = new Sequelize({
  database: 'your_database',
  dialect: 'postgres',
  username: 'your_username',
  password: 'your_password',
  models: [__dirname + '/models'], // path to your model files
});

export default sequelize;

Step 3: Define Models with Sequelize-Typescript

Create a simple model for users in a models/user.ts file:

import { Table, Column, Model, DataType } from 'sequelize-typescript';

@Table
class User extends Model {
  @Column({
    type: DataType.STRING,
    allowNull: false,
  })
  name!: string;

  @Column({
    type: DataType.STRING,
    allowNull: false,
    unique: true,
  })
  email!: string;
}

export default User;

Step 4: CRUD Operations Example in Sequelize-Typescript

Now, let’s implement some basic CRUD (Create, Read, Update, Delete) operations:

1. Create a User

const newUser = await User.create({
  name: 'John Doe',
  email: 'john.doe@example.com',
});

2. Read Users

const users = await User.findAll();
console.log(users);

3. Update a User

const user = await User.findOne({ where: { email: 'john.doe@example.com' } });
if (user) {
  user.name = 'Johnathan Doe';
  await user.save();
}

4. Delete a User

const user = await User.findOne({ where: { email: 'john.doe@example.com' } });
if (user) {
  await user.destroy();
}

Setting Up Express to Handle CRUD Routes

Let’s quickly set up Express to handle routes for CRUD operations:

import express from 'express';
import sequelize from './sequelize';
import User from './models/user';

const app = express();
app.use(express.json());

app.post('/users', async (req, res) => {
  try {
    const user = await User.create(req.body);
    res.status(201).json(user);
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});

app.get('/users', async (req, res) => {
  try {
    const users = await User.findAll();
    res.status(200).json(users);
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});

app.listen(3000, async () => {
  await sequelize.sync();
  console.log('Server running on http://localhost:3000');
});

Conclusion

In this post, we’ve covered how to set up Sequelize with Sequelize-Typescript for Node.js, and how to perform basic CRUD operations in an Express app. Using Sequelize-Typescript enhances the development process by adding type safety and making interactions with databases more intuitive.

By mastering CRUD operations with Sequelize in Node.js, you’ll be well on your way to building efficient, scalable applications that can interact seamlessly with databases.