Migration von Sequelize zu TypeORM

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

Einrichten einer Data Source

In Sequelize erstellst du eine Data Source auf diese Weise:

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 erstellst du eine Data Source folgendermaßen:

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

Anschließend kannst du die dataSource-Instanz von überall in deiner App verwenden.

Mehr erfahren über Data Source

Schema-Synchronisierung

In Sequelize führst du die Schema-Synchronisierung so durch:

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

In TypeORM fügst du einfach synchronize: true in den Data-Source-Optionen hinzu:

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

Erstellen von Modellen

So werden Modelle in Sequelize definiert:

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 werden diese Modelle Entitäten genannt und folgendermaßen definiert:

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 wird dringend empfohlen, jede Entitätsklasse in einer eigenen Datei zu definieren. TypeORM ermöglicht dir, deine Klassen als Datenbankmodelle zu verwenden und bietet eine deklarative Möglichkeit zu definieren, welche Teile deines Modells Teil deiner Datenbanktabelle werden. Die Stärke von TypeScript liefert dir Typ-Hinweise und andere nützliche Funktionen, die du in Klassen nutzen kannst.

Mehr erfahren über Entitäten und Spalten

Weitere Modelleinstellungen

Folgendes in Sequelize:

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

Kann in TypeORM so umgesetzt werden:

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

Folgendes in Sequelize:

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

Wird in TypeORM so geschrieben:

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

Folgendes in Sequelize:

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

Kann in TypeORM so umgesetzt werden:

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

Folgendes in Sequelize:

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

Entspricht diesem Code in TypeORM:

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

Folgendes in Sequelize:

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

Kann in TypeORM so umgesetzt werden:

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

Folgendes in Sequelize:

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

Kann in TypeORM so umgesetzt werden:

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

Um createDate- und updateDate-ähnliche Spalten zu erstellen, musst du zwei Spalten (benenne sie wie gewünscht) in deiner Entität definieren:

@CreateDateColumn();
createDate: Date;

@UpdateDateColumn();
updateDate: Date;

Arbeiten mit Modellen

Um ein neues Modell in Sequelize zu erstellen und zu speichern, schreibst du:

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

In TypeORM gibt es mehrere Möglichkeiten, ein neues Modell zu erstellen und zu speichern:

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)

oder über das Active-Record-Pattern

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

Wenn du eine bestehende Entität aus der Datenbank laden und einige ihrer Eigenschaften ersetzen möchtest, kannst du folgende Methode verwenden:

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

Mehr erfahren über Active Record vs Data Mapper und die Repository-API.

Um auf Eigenschaften in Sequelize zuzugreifen, machst du folgendes:

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

In TypeORM machst du es einfach so:

console.log(employee.name)

Um einen Index in Sequelize zu erstellen, machst du:

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

In TypeORM machst du:

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

Mehr erfahren über Indizes