Good Practices Using Node.js + Sequelize with TypeScript

Node.js combined with Sequelize offers a powerful stack for building robust backend applications. When using TypeScript, you can leverage static typing to catch errors at compile time, enhancing code quality and maintainability. This article will guide you through some best practices for integrating Node.js, Sequelize, and TypeScript effectively.

Setting Up Your Project

First, ensure you have Node.js installed on your system. Then, initialize a new project and install the necessary dependencies:

mkdir my-project && cd my-project
npm init -y
npm install express sequelize typescript ts-node @types/node @types/express --save-dev

Create a tsconfig.json file to configure TypeScript options:

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

Defining Models with Sequelize

Sequelize models define the structure of your database tables. With TypeScript, you can benefit from type safety and autocompletion. Here's how to define a simple model:

// src/models/User.ts
import { Model, DataTypes } from 'sequelize';
import { Sequelize } from 'sequelize-typescript';

export class User extends Model {
  public id!: number;
  public name!: string;
}

const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'postgres' // or 'mysql', 'sqlite', etc.
});

User.init({
  id: {
    type: DataTypes.INTEGER.UNSIGNED,
    autoIncrement: true,
    primaryKey: true
  },
  name: {
    type: DataTypes.STRING,
    allowNull: false
  }
}, {
  tableName: 'users',
  sequelize
});

Creating Express Routes

Express routes handle HTTP requests. By defining them in TypeScript, you get the benefits of static typing and better tooling support:

// src/routes/users.ts
import express, { Request, Response } from 'express';
import { User } from '../models/User';

const router = express.Router();

router.get('/', async (req: Request, res: Response) => {
  const users = await User.findAll();
  res.json(users);
});

export default router;

Middleware and Error Handling

Middleware functions can be typed to ensure they receive the correct parameters and return the expected values. Error handling middleware should also be properly typed:

// src/middleware/errorHandler.ts
import { NextFunction, Request, Response } from 'express';

export function errorHandler(err: Error, req: Request, res: Response, next: NextFunction) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
}

Don't forget to add this middleware to your Express app:

// src/app.ts
import express from 'express';
import errorHandler from './middleware/errorHandler';
import usersRouter from './routes/users';

const app = express();
app.use(express.json());
app.use('/api/users', usersRouter);
app.use(errorHandler);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Integrating Node.js, Sequelize, and TypeScript allows you to build scalable and maintainable backend applications. By following these best practices, such as setting up your project correctly, defining models with type safety, creating typed Express routes, and implementing proper error handling, you can enhance your development workflow and produce higher-quality code. Remember to keep your dependencies up-to-date and explore Sequelize's advanced features for even more efficient database operations.

Contacts
Email: [e-mail]
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca