How to use TypeScript with Sequelize

Using TypeScript with Sequelize can significantly enhance development efficiency and project maintainability, primarily through the following steps:

1. Installation and Configuration

First, ensure that Node.js is installed. Then, install Sequelize and the corresponding database drivers, such as PostgreSQL or MySQL, in your project. Additionally, you need to install the type definition files for Sequelize and TypeScript:

bash
npm install --save sequelize
npm install --save pg pg-hstore # Example for PostgreSQL
npm install --save-dev @types/sequelize typescript

Next, create a tsconfig.json file in your project root directory to configure TypeScript compilation options:

json
{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true
  }
}

2. Model Definition

In TypeScript, you can define models using classes and interfaces. This makes the model structure clearer and allows you to benefit from TypeScript's type checking and auto-completion features.

typescript
import { Model, DataTypes } from 'sequelize';
import sequelize from '../db/connection'; // Assuming your database connection configuration is in this file

export class User extends Model {
  public id!: number;
  public name!: string;
  public email!: string;
  public readonly createdAt!: Date;
  public readonly updatedAt!: Date;
}

User.init({
  id: {
    type: DataTypes.INTEGER.UNSIGNED,
    autoIncrement: true,
    primaryKey: true,
  },
  name: {
    type: new DataTypes.STRING(128),
    allowNull: false,
  },
  email: {
    type: new DataTypes.STRING(128),
    allowNull: false
  }
}, {
  tableName: 'users',
  sequelize, // Pass the connection instance
});

3. Using Models for Operations

After defining the models, you can use Sequelize's methods to perform data operations such as create, read, update, and delete:

typescript
// Add user
async function addUser(name: string, email: string): Promise<User> {
  return await User.create({ name, email });
}

// Find user by ID
async function findUserById(id: number): Promise<User | null> {
  return await User.findByPk(id);
}

// Update user
async function updateUser(id: number, name: string): Promise<void> {
  const user = await findUserById(id);
  if (user) {
    user.name = name;
    await user.save();
  }
}

// Delete user
async function deleteUser(id: number): Promise<void> {
  const user = await findUserById(id);
  if (user) {
    await user.destroy();
  }
}

4. Integration and Error Handling

In actual development, it is crucial to handle errors appropriately when calling functions. Additionally, you can integrate more TypeScript features, such as interfaces, type aliases, and enums, to enhance code robustness and readability.

Summary

Using TypeScript with Sequelize can make your code more robust, reducing runtime errors. Through the type system, you can also enjoy a better development experience, such as auto-completion and compile-time type checking. These make development more efficient and confident.