Migración de Sequelize a TypeORM

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Configuración de una fuente de datos

En Sequelize se crea una fuente de datos de esta forma:

const sequelize = new Sequelize("database", "username", "password", {
    host: "localhost",
    dialect: "mysql",
})

sequelize
    .authenticate()
    .then(() => {
        console.log("Data Source has been initialized successfully.")
    })
    .catch((err) => {
        console.error("Error during Data Source initialization:", err)
    })

En TypeORM se crea una fuente de datos de la siguiente manera:

import { DataSource } from "typeorm"

const dataSource = new DataSource({
    type: "mysql",
    host: "localhost",
    username: "username",
    password: "password",
})

dataSource
    .initialize()
    .then(() => {
        console.log("Data Source has been initialized successfully.")
    })
    .catch((err) => {
        console.error("Error during Data Source initialization:", err)
    })

Luego puedes usar la instancia dataSource desde cualquier parte de tu aplicación.

Más información sobre Fuente de datos

Sincronización de esquemas

En Sequelize se realiza la sincronización de esquemas así:

Project.sync({ force: true })
Task.sync({ force: true })

En TypeORM simplemente añades synchronize: true en las opciones de la fuente de datos:

const dataSource = new DataSource({
    type: "mysql",
    host: "localhost",
    username: "username",
    password: "password",
    synchronize: true,
})

Creación de modelos

Así se definen los modelos en Sequelize:

module.exports = function (sequelize, DataTypes) {
    const Project = sequelize.define("project", {
        title: DataTypes.STRING,
        description: DataTypes.TEXT,
    })

    return Project
}

module.exports = function (sequelize, DataTypes) {
    const Task = sequelize.define("task", {
        title: DataTypes.STRING,
        description: DataTypes.TEXT,
        deadline: DataTypes.DATE,
    })

    return Task
}

En TypeORM estos modelos se llaman entidades y se definen de la siguiente forma:

import { Entity, PrimaryGeneratedColumn, Column } from "typeorm"

@Entity()
export class Project {
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    title: string

    @Column()
    description: string
}

import { Entity, PrimaryGeneratedColumn, Column } from "typeorm"

@Entity()
export class Task {
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    title: string

    @Column("text")
    description: string

    @Column()
    deadline: Date
}

Es altamente recomendable definir una clase de entidad por archivo. TypeORM te permite usar tus clases como modelos de base de datos y ofrece una forma declarativa de definir qué parte de tu modelo formará parte de tu tabla de base de datos. El poder de TypeScript te brinda sugerencias de tipos y otras características útiles que puedes usar en las clases.

Más información sobre Entidades y columnas

Otras configuraciones de modelos

Lo siguiente en Sequelize:

flag: { type: Sequelize.BOOLEAN, allowNull: true, defaultValue: true },

Se puede lograr en TypeORM así:

@Column({ nullable: true, default: true })
flag: boolean;

Lo siguiente en Sequelize:

flag: { type: Sequelize.DATE, defaultValue: Sequelize.NOW }

Se escribe así en TypeORM:

@Column({ default: () => "NOW()" })
myDate: Date;

Lo siguiente en Sequelize:

someUnique: { type: Sequelize.STRING, unique: true },

Se puede lograr así en TypeORM:

@Column({ unique: true })
someUnique: string;

Lo siguiente en Sequelize:

fieldWithUnderscores: { type: Sequelize.STRING, field: "field_with_underscores" },

Se traduce así en TypeORM:

@Column({ name: "field_with_underscores" })
fieldWithUnderscores: string;

Lo siguiente en Sequelize:

incrementMe: { type: Sequelize.INTEGER, autoIncrement: true },

Se puede lograr así en TypeORM:

@Column()
@Generated()
incrementMe: number;

Lo siguiente en Sequelize:

identifier: { type: Sequelize.STRING, primaryKey: true },

Se puede lograr así en TypeORM:

@Column({ primary: true })
identifier: string;

Para crear columnas similares a createDate y updateDate, necesitas definir dos columnas (nómbralas como prefieras) en tu entidad:

@CreateDateColumn();
createDate: Date;

@UpdateDateColumn();
updateDate: Date;

Trabajando con modelos

Para crear y guardar un nuevo modelo en Sequelize se escribe:

const employee = await Employee.create({
    name: "John Doe",
    title: "senior engineer",
})

En TypeORM hay varias formas de crear y guardar un nuevo modelo:

const employee = new Employee() // you can use constructor parameters as well
employee.name = "John Doe"
employee.title = "senior engineer"
await dataSource.getRepository(Employee).save(employee)

o mediante el patrón Active Record

const employee = Employee.create({ name: "John Doe", title: "senior engineer" })
await employee.save()

Si deseas cargar una entidad existente de la base de datos y reemplazar algunas de sus propiedades, puedes usar el siguiente método:

const employee = await Employee.preload({ id: 1, name: "John Doe" })

Más información sobre Active Record vs Data Mapper y API de Repositorio.

Para acceder a propiedades en Sequelize se hace lo siguiente:

console.log(employee.get("name"))

En TypeORM simplemente haces:

console.log(employee.name)

Para crear un índice en Sequelize se hace:

sequelize.define(
    "user",
    {},
    {
        indexes: [
            {
                unique: true,
                fields: ["firstName", "lastName"],
            },
        ],
    },
)

En TypeORM se hace:

@Entity()
@Index(["firstName", "lastName"], { unique: true })
export class User {}

Más información sobre Índices