Zum Hauptinhalt springen

Decorator-Referenz

Inoffizielle Beta-Übersetzung

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

Entity-Decorators​

@Entity​

Markiert Ihr Modell als Entität. Eine Entität ist eine Klasse, die in eine Datenbanktabelle transformiert wird. Sie können den Tabellennamen in der Entität angeben:

@Entity("users")
export class User {}

Dieser Code erstellt eine Datenbanktabelle namens "users".

Sie können auch zusätzliche Entitätsoptionen angeben:

  • name - Tabellenname. Wenn nicht angegeben, wird der Tabellenname aus dem Klassennamen der Entität generiert.

  • database - Datenbankname im ausgewählten DB-Server.

  • schema - Name des Schemas.

  • engine - Datenbank-Engine, die bei der Tabellenerstellung gesetzt wird (funktioniert nur in einigen Datenbanken).

  • synchronize - Entitäten mit false werden bei Schema-Updates übersprungen.

  • orderBy - Legt die Standard-Sortierreihenfolge für Entitäten bei find-Operationen und QueryBuilder fest.

Beispiel:

@Entity({
    name: "users",
    engine: "MyISAM",
    database: "example_dev",
    schema: "schema_with_best_tables",
    synchronize: false,
    orderBy: {
        name: "ASC",
        id: "DESC",
    },
})
export class User {}

Erfahre mehr über Entitäten.

@ViewEntity​

Eine View-Entität ist eine Klasse, die auf eine Datenbank-View abgebildet wird.

@ViewEntity() akzeptiert folgende Optionen:

  • name - Name der View. Wenn nicht angegeben, wird der View-Name aus dem Klassennamen der Entität generiert.

  • database - Datenbankname im ausgewählten DB-Server.

  • schema - Name des Schemas.

  • expression - View-Definition. Erforderlicher Parameter.

expression kann ein String mit korrekt maskierten Spalten und Tabellen sein (abhängig von der verwendeten Datenbank, hier PostgreSQL-Beispiel):

@ViewEntity({
    expression: `
        SELECT "post"."id" "id", "post"."name" AS "name", "category"."name" AS "categoryName"
        FROM "post" "post"
        LEFT JOIN "category" "category" ON "post"."categoryId" = "category"."id"
    `,
})
export class PostCategory {}

oder eine Instanz von QueryBuilder

@ViewEntity({
    expression: (dataSource: DataSource) =>
        dataSource
            .createQueryBuilder()
            .select("post.id", "id")
            .addSelect("post.name", "name")
            .addSelect("category.name", "categoryName")
            .from(Post, "post")
            .leftJoin(Category, "category", "category.id = post.categoryId"),
})
export class PostCategory {}

Hinweis: Parameter-Binding wird aufgrund von Treibereinschränkungen nicht unterstützt. Verwende stattdessen Literal-Parameter.

@ViewEntity({
    expression: (dataSource: DataSource) =>
        dataSource
            .createQueryBuilder()
            .select("post.id", "id")
            .addSelect("post.name", "name")
            .addSelect("category.name", "categoryName")
            .from(Post, "post")
            .leftJoin(Category, "category", "category.id = post.categoryId")
            .where("category.name = :name", { name: "Cars" }) // <-- this is wrong
            .where("category.name = 'Cars'"), // <-- and this is right
})
export class PostCategory {}

Erfahre mehr über View-Entitäten.

Spalten-Decorators​

@Column​

Markiert eine Eigenschaft Ihrer Entität als Tabellenspalte. Beispiel:

@Entity("users")
export class User {
    @Column({ primary: true })
    id: number

    @Column({ type: "varchar", length: 200, unique: true })
    firstName: string

    @Column({ nullable: true })
    lastName: string

    @Column({ default: false })
    isActive: boolean
}

@Column akzeptiert mehrere Optionen:

  • type: ColumnType - Spaltentyp. Einer der unterstützten Spaltentypen.

  • name: string - Spaltenname in der Datenbanktabelle. Standardmäßig wird der Spaltenname aus dem Eigenschaftsnamen generiert. Kann durch eigenen Namen überschrieben werden.

  • length: string|number - Länge des Spaltentyps. Beispiel: Für varchar(150) werden Spaltentyp und Längenoption angegeben.

  • width: number - Anzeigebreite des Spaltentyps. Nur für MySQL-Integer-Typen. Veraltet in neueren MySQL-Versionen, wird in zukünftigen TypeORM-Versionen entfernt.

  • onUpdate: string - ON UPDATE-Trigger (nur in MySQL relevant)

  • nullable: boolean - Legt fest, ob die Spalte NULL sein darf oder immer NOT NULL sein muss. Standardwert ist nullable: false.

  • update: boolean - Gibt an, ob der Spaltenwert durch "save"-Operationen aktualisiert wird. Bei false kann der Wert nur beim ersten Einfügen gesetzt werden. Standardwert ist true.

  • insert: boolean - Gibt an, ob der Spaltenwert beim ersten Einfügen des Objekts gesetzt wird. Standardwert ist true.

  • select: boolean - Legt fest, ob diese Spalte standardmäßig bei Abfragen ausgeblendet wird. Bei false werden die Spaltendaten nicht in einer Standardabfrage angezeigt. Standardmäßig ist select: true.

  • default: string - Fügt einen DEFAULT-Wert der Spalte auf Datenbankebene hinzu.

  • primary: boolean - Markiert die Spalte als Primärschlüssel. Entspricht @PrimaryColumn.

  • unique: boolean - Markiert die Spalte als eindeutige Spalte (erzeugt Unique-Constraint). Standardwert ist false.

  • comment: string - Kommentar der Spalte in der Datenbank. Nicht von allen Datenbanktypen unterstützt.

  • precision: number - Die Genauigkeit für eine Dezimal-Spalte (exakte numerische Spalte, gilt nur für Dezimal-Spalten), also die maximale Anzahl der gespeicherten Ziffern. Wird bei einigen Spaltentypen verwendet.

  • scale: number - Die Dezimalstellen für eine Dezimal-Spalte (exakte numerische Spalte), also die Anzahl der Nachkommastellen. Darf nicht größer als die Genauigkeit (precision) sein. Wird bei einigen Spaltentypen verwendet.

  • zerofill: boolean - Setzt ZEROFILL-Attribut auf numerische Spalten. Nur in MySQL. Bei true fügt MySQL automatisch UNSIGNED hinzu. Veraltet in neueren MySQL-Versionen, wird in zukünftigen TypeORM-Versionen entfernt. Verwende stattdessen Zeichenspalten und LPAD-Funktion gemäß MySQL-Empfehlung.

  • unsigned: boolean - Setzt das UNSIGNED-Attribut auf eine numerische Spalte. Wird nur in MySQL verwendet.

  • charset: string - Definiert den Zeichensatz der Spalte. Nicht von allen Datenbanktypen unterstützt.

  • collation: string - Definiert die Sortierreihenfolge (Collation) der Spalte.

  • enum: string[]|AnyEnum - Definiert bei enum-Spaltentypen die erlaubten Enumerationswerte. Akzeptiert Wert-Arrays oder Enum-Klassen.

  • enumName: string - Name für den generierten Enum-Typ. Ohne Angabe generiert TypeORM den Typ aus Entitäts- und Spaltennamen. Erforderlich, wenn derselbe Enum-Typ in mehreren Tabellen verwendet wird.

  • primaryKeyConstraintName: string - Benutzerdefinierter Name für die Primärschlüssel-Constraint. Ohne Angabe wird der Name aus Tabellen- und Spaltennamen generiert.

  • asExpression: string - Ausdruck für generierte Spalten. Nur in MySQL und Postgres unterstützt.

  • generatedType: "VIRTUAL"|"STORED" - Typ der generierten Spalte. Nur in MySQL und Postgres (nur "STORED") verfügbar.

  • hstoreType: "object"|"string" - Rückgabetyp der HSTORE-Spalte. Gibt den Wert als String oder Objekt zurück. Wird nur in Postgres verwendet.

  • array: boolean - Kennzeichnet Spaltentypen als Array (z.B. int[]). Nur für PostgreSQL und CockroachDB.

  • transformer: ValueTransformer|ValueTransformer[] - Spezifiziert einen Wert-Transformer (oder ein Array von Wert-Transforms), der beim Lesen/Schreiben aus/in die Datenbank für das (De-)Marshalling dieser Spalte verwendet wird. Bei einem Array werden die Transforms in natürlicher Reihenfolge (Entity → Datenbank) und in umgekehrter Reihenfolge (Datenbank → Entity) angewendet.

  • spatialFeatureType: string - Optionaler Feature-Typ (Point, Polygon, LineString, Geometry) als Constraint für räumliche Spalten. Wenn nicht angegeben, verhält sich die Spalte wie bei Geometry. Nur für PostgreSQL und CockroachDB.

  • srid: number - Optionale Spatial Reference ID als Constraint für räumliche Spalten. Standardwert ist 0. Geografische Koordinaten (Breite/Länge im WGS84-Datum) entsprechen EPSG 4326. Nur für PostgreSQL und CockroachDB.

Erfahre mehr über Entitätsspalten.

@PrimaryColumn​

Markiert eine Entitätseigenschaft als Primärspalte der Tabelle. Entspricht @Column, setzt aber die primary-Option auf true.

Beispiel:

@Entity()
export class User {
    @PrimaryColumn()
    id: number
}

@PrimaryColumn() unterstützt benutzerdefinierte Constraint-Namen für Primärschlüssel:

@Entity()
export class User {
    @PrimaryColumn({ primaryKeyConstraintName: "pk_user_id" })
    id: number
}

Hinweis: Bei Verwendung von primaryKeyConstraintName mit mehreren Primärschlüsseln muss der Constraint-Name für alle Primärspalten identisch sein.

Erfahre mehr über Entitätsspalten.

@PrimaryGeneratedColumn​

Markiert eine Eigenschaft in deiner Entität als tabellengenerierte Primärspalte.
Die erstellte Spalte ist ein Primärschlüssel und ihr Wert wird automatisch generiert.
Beispiel:

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number
}

@PrimaryGeneratedColumn() unterstützt benutzerdefinierte Primärschlüssel-Constraint-Namen:

@Entity()
export class User {
    @PrimaryGeneratedColumn({ primaryKeyConstraintName: "pk_user_id" })
    id: number
}

Es gibt vier Generierungsstrategien:

  • increment - Verwendet AUTO_INCREMENT / SERIAL / SEQUENCE (datenbankabhängig) zur Generierung inkrementeller Zahlen.

  • identity - Nur für PostgreSQL 10+. Postgres-Versionen ab 10 unterstützen die SQL-konforme IDENTITY-Spalte. Bei Markierung der Generierungsstrategie als identity wird die Spalte mit GENERATED [ALWAYS|BY DEFAULT] AS IDENTITY erzeugt.

  • uuid - Generiert eine eindeutige uuid-Zeichenkette.

  • rowid - Nur für CockroachDB. Generiert Werte mit der unique_rowid()-Funktion (64-Bit-Integer aus Timestamp und Node-ID der INSERT/UPSERT-Operation).

    Hinweis: Eigenschaften mit rowid-Strategie müssen vom Typ string sein.

Die Standardgenerierungsstrategie ist increment. Um sie zu ändern, übergibst du die Strategie einfach als ersten Parameter an den Decorator:

@Entity()
export class User {
    @PrimaryGeneratedColumn("uuid")
    id: string
}

Erfahre mehr über Entitätsspalten.

@ObjectIdColumn​

Markiert eine Eigenschaft in deiner Entität als ObjectId.
Dieser Decorator wird nur in MongoDB verwendet.
Jede Entität in MongoDB muss eine ObjectId-Spalte besitzen.
Beispiel:

@Entity()
export class User {
    @ObjectIdColumn()
    id: ObjectId
}

Erfahre mehr über MongoDB.

@CreateDateColumn​

Spezielle Spalte, die automatisch auf den Einfügezeitpunkt der Entität gesetzt wird.
Du musst keinen Wert zuweisen – er wird automatisch generiert.
Beispiel:

@Entity()
export class User {
    @CreateDateColumn()
    createdDate: Date
}

@UpdateDateColumn​

Spezielle Spalte, die bei jedem Aufruf von save (EntityManager oder Repository) automatisch auf den Aktualisierungszeitpunkt der Entität gesetzt wird.
Keine manuelle Zuweisung notwendig – der Wert wird automatisch generiert.

Diese Spalte wird auch automatisch während upsert-Operationen aktualisiert, wenn eine Änderung aufgrund eines Konflikts erfolgt.

@Entity()
export class User {
    @UpdateDateColumn()
    updatedDate: Date
}

@DeleteDateColumn​

Spezielle Spalte, die bei Soft-Delete-Operationen (EntityManager/Repository) automatisch auf den Löschzeitpunkt gesetzt wird.
Keine manuelle Zuweisung erforderlich – der Wert wird automatisch generiert.

TypeORMs Soft-Delete-Funktionalität nutzt globale Scopes, um nur "nicht gelöschte" Entitäten aus der Datenbank abzurufen.

Wenn @DeleteDateColumn gesetzt ist, gilt standardmäßig der Scope "nicht gelöscht".

@Entity()
export class User {
    @DeleteDateColumn()
    deletedDate: Date
}

@VersionColumn​

Spezielle Spalte, die bei jedem save-Aufruf (EntityManager/Repository) automatisch auf die Versionsnummer der Entität (inkrementelle Zahl) aktualisiert wird.
Keine manuelle Zuweisung notwendig – der Wert wird automatisch generiert.

Diese Spalte wird auch automatisch während upsert-Operationen aktualisiert, wenn eine Änderung aufgrund eines Konflikts erfolgt.

@Entity()
export class User {
    @VersionColumn()
    version: number
}

@Generated​

Markiert eine Spalte als generierten Wert. Beispiel:

@Entity()
export class User {
    @Column()
    @Generated("uuid")
    uuid: string
}

Der Wert wird nur einmal generiert – vor dem Einfügen der Entität in die Datenbank.

@VirtualColumn​

Spezielle Spalte, die nie in der Datenbank gespeichert wird und als schreibgeschützte Eigenschaft fungiert.
Bei jedem find- oder findOne-Aufruf (EntityManager) wird der Wert dynamisch basierend auf der im Decorator angegebenen Query-Funktion berechnet. Das alias-Argument referenziert dabei den Entitäts-Alias der generierten Query.

@Entity({ name: "companies", alias: "COMP" })
export class Company extends BaseEntity {
    @PrimaryColumn("varchar", { length: 50 })
    name: string

    @VirtualColumn({
        query: (alias) =>
            `SELECT COUNT("name") FROM "employees" WHERE "companyName" = ${alias}.name`,
    })
    totalEmployeesCount: number

    @OneToMany((type) => Employee, (employee) => employee.company)
    employees: Employee[]
}

@Entity({ name: "employees" })
export class Employee extends BaseEntity {
    @PrimaryColumn("varchar", { length: 50 })
    name: string

    @ManyToOne((type) => Company, (company) => company.employees)
    company: Company
}

Relationsdekoratoren​

@OneToOne​

Eine Eins-zu-eins-Beziehung liegt vor, wenn A genau eine Instanz von B enthält und B genau eine Instanz von A. Nehmen wir als Beispiel die Entitäten User und Profile. Ein Benutzer kann nur ein einzelnes Profil haben, und jedes Profil gehört zu genau einem Benutzer. Beispiel:

import { Entity, OneToOne, JoinColumn } from "typeorm"
import { Profile } from "./Profile"

@Entity()
export class User {
    @OneToOne((type) => Profile, (profile) => profile.user)
    @JoinColumn()
    profile: Profile
}

Erfahre mehr über Eins-zu-eins-Beziehungen.

@ManyToOne​

Eine Viele-zu-eins-/Eins-zu-viele-Beziehung liegt vor, wenn A mehrere Instanzen von B enthält, aber B nur eine Instanz von A. Nehmen wir als Beispiel die Entitäten User und Photo. Ein Benutzer kann mehrere Fotos haben, aber jedes Foto gehört zu genau einem Benutzer. Beispiel:

import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from "typeorm"
import { User } from "./User"

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

    @Column()
    url: string

    @ManyToOne((type) => User, (user) => user.photos)
    user: User
}

Erfahre mehr über Viele-zu-eins-/Eins-zu-viele-Beziehungen.

@OneToMany​

Eine Viele-zu-eins-/Eins-zu-viele-Beziehung liegt vor, wenn A mehrere Instanzen von B enthält, aber B nur eine Instanz von A. Nehmen wir als Beispiel die Entitäten User und Photo. Ein Benutzer kann mehrere Fotos haben, aber jedes Foto gehört zu genau einem Benutzer. Beispiel:

import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from "typeorm"
import { Photo } from "./Photo"

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

    @Column()
    name: string

    @OneToMany((type) => Photo, (photo) => photo.user)
    photos: Photo[]
}

Erfahre mehr über Viele-zu-eins-/Eins-zu-viele-Beziehungen.

@ManyToMany​

Eine Viele-zu-viele-Beziehung liegt vor, wenn A mehrere Instanzen von B enthält und B mehrere Instanzen von A. Nehmen wir als Beispiel die Entitäten Question und Category. Eine Frage kann mehrere Kategorien haben, und jede Kategorie kann mehrere Fragen enthalten. Beispiel:

import {
    Entity,
    PrimaryGeneratedColumn,
    Column,
    ManyToMany,
    JoinTable,
} from "typeorm"
import { Category } from "./Category"

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

    @Column()
    title: string

    @Column()
    text: string

    @ManyToMany((type) => Category)
    @JoinTable()
    categories: Category[]
}

Erfahre mehr über Viele-zu-viele-Beziehungen.

@JoinColumn​

Definiert, welche Seite der Beziehung die Join-Spalte mit dem Fremdschlüssel enthält und ermöglicht die Anpassung des Join-Spaltennamens, referenzierten Spaltennamens und Fremdschlüsselnamens. Beispiel:

@Entity()
export class Post {
    @ManyToOne((type) => Category)
    @JoinColumn({
        name: "cat_id",
        referencedColumnName: "name",
        foreignKeyConstraintName: "fk_cat_id",
    })
    category: Category
}

@JoinTable​

Wird für many-to-many-Beziehungen verwendet und beschreibt die Join-Spalten der "Junction"-Tabelle. Die Junction-Tabelle ist eine spezielle separate Tabelle, die automatisch von TypeORM erstellt wird, mit Spalten, die auf die verknüpften Entitäten verweisen. Du kannst folgendes anpassen:

  • Namen der generierten Junction-Tabelle
  • Spaltennamen innerhalb der Junction-Tabelle
  • Referenzierte Spalten via joinColumn- und inverseJoinColumn-Attribute
  • Namen der erstellten Fremdschlüssel Der Parameter synchronize kann auf false gesetzt werden, um Schema-Updates zu überspringen (wie bei @Entity).

Beispiel:

@Entity()
export class Post {
    @ManyToMany((type) => Category)
    @JoinTable({
        name: "question_categories",
        joinColumn: {
            name: "question",
            referencedColumnName: "id",
            foreignKeyConstraintName: "fk_question_categories_questionId",
        },
        inverseJoinColumn: {
            name: "category",
            referencedColumnName: "id",
            foreignKeyConstraintName: "fk_question_categories_categoryId",
        },
        synchronize: false,
    })
    categories: Category[]
}

Wenn die Zieltabelle zusammengesetzte Primärschlüssel hat, muss ein Array von Eigenschaften an den @JoinTable-Dekorator übergeben werden.

@RelationId​

Lädt die ID (oder IDs) bestimmter Beziehungen in Eigenschaften. Wenn du beispielsweise eine Many-to-One-category in deiner Post-Entität hast, kannst du eine neue Kategorie-ID-Eigenschaft durch Markieren mit @RelationId erstellen. Beispiel:

@Entity()
export class Post {
    @ManyToOne((type) => Category)
    category: Category

    @RelationId((post: Post) => post.category) // you need to specify target relation
    categoryId: number
}

Diese Funktionalität funktioniert für alle Beziehungstypen, einschließlich many-to-many:

@Entity()
export class Post {
    @ManyToMany((type) => Category)
    categories: Category[]

    @RelationId((post: Post) => post.categories)
    categoryIds: number[]
}

Die Relations-ID dient nur der Darstellung. Die zugrunde liegende Beziehung wird nicht hinzugefügt/entfernt/geändert, wenn der Wert geändert wird.

Dekoratoren für Subscriber und Listener​

@AfterLoad​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @AfterLoad markieren. TypeORM ruft diese Methode jedes Mal auf, wenn die Entität mittels QueryBuilder oder Repository-/Manager-Find-Methoden geladen wird. Beispiel:

@Entity()
export class Post {
    @AfterLoad()
    updateCounters() {
        if (this.likesCount === undefined) this.likesCount = 0
    }
}

Erfahre mehr über Listener.

@BeforeInsert​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @BeforeInsert markieren. TypeORM ruft sie auf, bevor die Entität mittels Repository-/Manager-save eingefügt wird. Beispiel:

@Entity()
export class Post {
    @BeforeInsert()
    updateDates() {
        this.createdDate = new Date()
    }
}

Erfahre mehr über Listener.

@AfterInsert​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @AfterInsert markieren. TypeORM ruft sie auf, nachdem die Entität mittels Repository-/Manager-save eingefügt wurde. Beispiel:

@Entity()
export class Post {
    @AfterInsert()
    resetCounters() {
        this.counters = 0
    }
}

Erfahre mehr über Listener.

@BeforeUpdate​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @BeforeUpdate markieren. TypeORM ruft sie auf, bevor eine bestehende Entität mittels Repository-/Manager-save aktualisiert wird. Beispiel:

@Entity()
export class Post {
    @BeforeUpdate()
    updateDates() {
        this.updatedDate = new Date()
    }
}

Erfahre mehr über Listener.

@AfterUpdate​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @AfterUpdate markieren. TypeORM ruft sie auf, nachdem eine bestehende Entität mittels Repository-/Manager-save aktualisiert wurde. Beispiel:

@Entity()
export class Post {
    @AfterUpdate()
    updateCounters() {
        this.counter = 0
    }
}

Erfahre mehr über Listener.

@BeforeRemove​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @BeforeRemove markieren, und TypeORM ruft sie auf, bevor eine Entität mit repository/manager remove entfernt wird. Beispiel:

@Entity()
export class Post {
    @BeforeRemove()
    updateStatus() {
        this.status = "removed"
    }
}

Erfahre mehr über Listener.

@AfterRemove​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @AfterRemove markieren. TypeORM ruft sie auf, nachdem die Entität mittels Repository-/Manager-remove entfernt wurde. Beispiel:

@Entity()
export class Post {
    @AfterRemove()
    updateStatus() {
        this.status = "removed"
    }
}

Erfahre mehr über Listener.

@BeforeSoftRemove​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @BeforeSoftRemove markieren, und TypeORM ruft sie auf, bevor eine Entität mit repository/manager softRemove soft entfernt wird. Beispiel:

@Entity()
export class Post {
    @BeforeSoftRemove()
    updateStatus() {
        this.status = "soft-removed"
    }
}

Erfahre mehr über Listener.

@AfterSoftRemove​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @AfterSoftRemove markieren. TypeORM ruft sie auf, nachdem die Entität mittels Repository-/Manager-softRemove soft-removed wurde. Beispiel:

@Entity()
export class Post {
    @AfterSoftRemove()
    updateStatus() {
        this.status = "soft-removed"
    }
}

Erfahre mehr über Listener.

@BeforeRecover​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @BeforeRecover markieren, und TypeORM ruft sie auf, bevor eine Entität mit repository/manager recover wiederhergestellt wird. Beispiel:

@Entity()
export class Post {
    @BeforeRecover()
    updateStatus() {
        this.status = "recovered"
    }
}

Erfahre mehr über Listener.

@AfterRecover​

Sie können eine Methode mit beliebigem Namen in der Entität definieren und mit @AfterRecover markieren. TypeORM ruft sie auf, nachdem die Entität mittels Repository-/Manager-recover wiederhergestellt wurde. Beispiel:

@Entity()
export class Post {
    @AfterRecover()
    updateStatus() {
        this.status = "recovered"
    }
}

Erfahre mehr über Listener.

@EventSubscriber​

Markiert eine Klasse als Event-Subscriber, der auf bestimmte Entitätsereignisse oder Ereignisse beliebiger Entitäten lauschen kann. Ereignisse werden mittels QueryBuilder und Repository-/Manager-Methoden ausgelöst. Beispiel:

@EventSubscriber()
export class PostSubscriber implements EntitySubscriberInterface<Post> {
    /**
     * Indicates that this subscriber only listen to Post events.
     */
    listenTo() {
        return Post
    }

    /**
     * Called before post insertion.
     */
    beforeInsert(event: InsertEvent<Post>) {
        console.log(`BEFORE POST INSERTED: `, event.entity)
    }
}

Sie können jede Methode aus EntitySubscriberInterface implementieren. Um auf beliebige Entitäten zu lauschen, lassen Sie einfach die listenTo-Methode weg und verwenden any:

@EventSubscriber()
export class PostSubscriber implements EntitySubscriberInterface {
    /**
     * Called before entity insertion.
     */
    beforeInsert(event: InsertEvent<any>) {
        console.log(`BEFORE ENTITY INSERTED: `, event.entity)
    }
}

Erfahre mehr über Subscriber.

Weitere Decorators​

@Index​

Dieser Decorator ermöglicht das Erstellen eines Datenbankindex für eine oder mehrere Spalten. Er erlaubt auch, Spalten als eindeutig zu markieren. Dieser Decorator kann auf Spalten oder die Entität selbst angewendet werden. Verwende ihn bei einer Spalte, wenn ein Index für eine einzelne Spalte benötigt wird, und auf der Entität, wenn ein einzelner Index für mehrere Spalten erforderlich ist. Beispiele:

@Entity()
export class User {
    @Index()
    @Column()
    firstName: string

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

    @Column()
    lastName: string

    @Column()
    middleName: string
}

Erfahre mehr über Indizes.

@Unique​

Dieser Decorator ermöglicht das Erstellen eines eindeutigen Datenbank-Constraints für eine oder mehrere Spalten. Dieser Decorator kann nur auf die Entität selbst angewendet werden. Sie müssen die Feldnamen der Entität (nicht die Datenbank-Spaltennamen) als Argumente angeben.

Beispiele:

@Entity()
@Unique(["firstName"])
@Unique(["lastName", "middleName"])
@Unique("UQ_NAMES", ["firstName", "lastName", "middleName"])
export class User {
    @Column({ name: "first_name" })
    firstName: string

    @Column({ name: "last_name" })
    lastName: string

    @Column({ name: "middle_name" })
    middleName: string
}

Hinweis: MySQL speichert eindeutige Constraints als eindeutige Indizes

@Check​

Dieser Decorator ermöglicht das Erstellen eines Check-Constraints in der Datenbank für eine oder mehrere Spalten. Dieser Decorator kann nur auf die Entität selbst angewendet werden.

Beispiele:

@Entity()
@Check(`"firstName" <> 'John' AND "lastName" <> 'Doe'`)
@Check(`"age" > 18`)
export class User {
    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    age: number
}

Hinweis: MySQL unterstützt keine Check-Constraints.

@Exclusion​

Dieser Decorator ermöglicht das Erstellen eines Ausschluss-Constraints in der Datenbank für eine oder mehrere Spalten. Dieser Decorator kann nur auf die Entität selbst angewendet werden.

Beispiele:

@Entity()
@Exclusion(`USING gist ("room" WITH =, tsrange("from", "to") WITH &&)`)
export class RoomBooking {
    @Column()
    room: string

    @Column()
    from: Date

    @Column()
    to: Date
}

Hinweis: Nur PostgreSQL unterstützt Ausschluss-Constraints.

@ForeignKey​

Dieser Decorator ermöglicht das Erstellen eines Fremdschlüssels in der Datenbank für eine oder mehrere Spalten. Dieser Decorator kann auf Spalten oder die Entität selbst angewendet werden. Verwende ihn bei einer Spalte, wenn ein Fremdschlüssel für eine einzelne Spalte benötigt wird, und auf der Entität, wenn ein einzelner Fremdschlüssel für mehrere Spalten erforderlich ist.

Hinweis: Verwende diesen Decorator nicht mit Beziehungen. Fremdschlüssel werden automatisch für Beziehungen erstellt, die Sie mit Relation Decorators (@ManyToOne, @OneToOne, etc.) definieren. Der @ForeignKey-Decorator sollte nur verwendet werden, um Fremdschlüssel in der Datenbank zu erstellen, wenn Sie keine entsprechende Entitätsbeziehung definieren möchten.

Beispiele:

@Entity("orders")
@ForeignKey(() => City, ["cityId", "countryCode"], ["id", "countryCode"])
export class Order {
    @PrimaryColumn()
    id: number

    @Column("uuid", { name: "user_uuid" })
    @ForeignKey<User>("User", "uuid", { name: "FK_user_uuid" })
    userUuid: string

    @Column({ length: 2 })
    @ForeignKey(() => Country, "code")
    countryCode: string

    @Column()
    @ForeignKey("cities")
    cityId: number

    @Column()
    dispatchCountryCode: string

    @ManyToOne(() => Country)
    dispatchCountry: Country

    @Column()
    dispatchCityId: number

    @ManyToOne(() => City)
    dispatchCity: City
}
@Entity("cities")
@Unique(["id", "countryCode"])
export class City {
    @PrimaryColumn()
    id: number

    @Column({ length: 2 })
    @ForeignKey("countries", { onDelete: "CASCADE", onUpdate: "CASCADE" })
    countryCode: string

    @Column()
    name: string
}
@Entity("countries")
export class Country {
    @PrimaryColumn({ length: 2 })
    code: string

    @Column()
    name: string
}
@Entity("users")
export class User {
    @PrimaryColumn({ name: "ref" })
    id: number

    @Column("uuid", { unique: true })
    uuid: string
}