Migrazione da Sequelize a TypeORM

Traduzione Beta Non Ufficiale

Questa pagina è stata tradotta da PageTurner AI (beta). Non ufficialmente approvata dal progetto. Hai trovato un errore? Segnala problema →

Configurazione di una sorgente dati

In Sequelize si crea una sorgente dati in questo modo:

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)
    })

In TypeORM si crea una sorgente dati nel modo seguente:

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)
    })

Successivamente puoi utilizzare l'istanza dataSource da qualsiasi punto della tua applicazione.

Scopri di più sulla Sorgente Dati

Sincronizzazione dello schema

In Sequelize esegui la sincronizzazione dello schema così:

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

In TypeORM aggiungi semplicemente synchronize: true nelle opzioni della sorgente dati:

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

Creazione dei modelli

Ecco come vengono definiti i modelli in 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
}

In TypeORM questi modelli sono chiamati entità e puoi definirli nel modo seguente:

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
}

È altamente consigliato definire una classe di entità per file. TypeORM ti permette di utilizzare le tue classi come modelli di database e fornisce un modo dichiarativo per definire quale parte del tuo modello diventerà parte della tua tabella di database. La potenza di TypeScript offre suggerimenti sui tipi e altre funzionalità utili che puoi utilizzare nelle classi.

Scopri di più su Entità e colonne

Altre impostazioni dei modelli

Quanto segue in Sequelize:

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

Si può ottenere in TypeORM in questo modo:

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

Quanto segue in Sequelize:

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

Si scrive così in TypeORM:

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

Quanto segue in Sequelize:

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

Si può ottenere in TypeORM in questo modo:

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

Quanto segue in Sequelize:

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

Corrisponde a questo in TypeORM:

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

Quanto segue in Sequelize:

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

Si può ottenere in TypeORM in questo modo:

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

Quanto segue in Sequelize:

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

Si può ottenere in TypeORM in questo modo:

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

Per creare colonne simili a createDate e updateDate, devi definire due colonne (assegna loro il nome che preferisci) nella tua entità:

@CreateDateColumn();
createDate: Date;

@UpdateDateColumn();
updateDate: Date;

Lavorare con i modelli

Per creare e salvare un nuovo modello in Sequelize scrivi:

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

In TypeORM ci sono diversi modi per creare e salvare un nuovo modello:

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 tramite il pattern Active Record

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

se vuoi caricare un'entità esistente dal database e sostituire alcune delle sue proprietà, puoi usare il seguente metodo:

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

Scopri di più su Active Record vs Data Mapper e Repository API.

Per accedere alle proprietà in Sequelize fai così:

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

In TypeORM semplicemente fai:

console.log(employee.name)

Per creare un indice in Sequelize fai:

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

In TypeORM fai:

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

Scopri di più sugli Indici