Entitäts-Listener und Abonnenten

Inoffizielle Beta-Übersetzung

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

Was ist ein Entity Listener?

Jede Ihrer Entitäten kann Methoden mit benutzerdefinierter Logik enthalten, die auf bestimmte Entitätsereignisse reagieren. Sie müssen diese Methoden mit speziellen Decorators markieren, abhängig davon, auf welches Ereignis Sie reagieren möchten.

Hinweis: Führen Sie keine Datenbankaufrufe innerhalb eines Listeners durch. Verwenden Sie stattdessen Abonnenten.

`@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
    }
}

`@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()
    }
}

`@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
    }
}

`@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. Beachten Sie jedoch, dass dies nur geschieht, wenn Informationen im Modell geändert wurden. Wenn Sie save ohne Änderungen aufrufen, werden @BeforeUpdate und @AfterUpdate nicht ausgeführt. Beispiel:

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

`@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
    }
}

`@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"
    }
}

`@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"
    }
}

`@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"
    }
}

`@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"
    }
}

`@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"
    }
}

`@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"
    }
}

Was ist ein Subscriber?

Markiert eine Klasse als Ereignis-Abonnent, der auf bestimmte Entitätsereignisse oder alle Entitätsereignisse reagieren kann. Ereignisse werden durch 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 beliebige Methoden aus EntitySubscriberInterface implementieren. Um auf alle Entitäten zu reagieren, lassen Sie die listenTo-Methode einfach weg und verwenden any:

@EventSubscriber()
export class PostSubscriber implements EntitySubscriberInterface {
    /**
     * Called after entity is loaded.
     */
    afterLoad(entity: any) {
        console.log(`AFTER ENTITY LOADED: `, entity)
    }

    /**
     * Called before query execution.
     */
    beforeQuery(event: BeforeQueryEvent<any>) {
        console.log(`BEFORE QUERY: `, event.query)
    }

    /**
     * Called after query execution.
     */
    afterQuery(event: AfterQueryEvent<any>) {
        console.log(`AFTER QUERY: `, event.query)
    }

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

    /**
     * Called after entity insertion.
     */
    afterInsert(event: InsertEvent<any>) {
        console.log(`AFTER ENTITY INSERTED: `, event.entity)
    }

    /**
     * Called before entity update.
     */
    beforeUpdate(event: UpdateEvent<any>) {
        console.log(`BEFORE ENTITY UPDATED: `, event.entity)
    }

    /**
     * Called after entity update.
     */
    afterUpdate(event: UpdateEvent<any>) {
        console.log(`AFTER ENTITY UPDATED: `, event.entity)
    }

    /**
     * Called before entity removal.
     */
    beforeRemove(event: RemoveEvent<any>) {
        console.log(
            `BEFORE ENTITY WITH ID ${event.entityId} REMOVED: `,
            event.entity,
        )
    }

    /**
     * Called after entity removal.
     */
    afterRemove(event: RemoveEvent<any>) {
        console.log(
            `AFTER ENTITY WITH ID ${event.entityId} REMOVED: `,
            event.entity,
        )
    }

    /**
     * Called before entity removal.
     */
    beforeSoftRemove(event: SoftRemoveEvent<any>) {
        console.log(
            `BEFORE ENTITY WITH ID ${event.entityId} SOFT REMOVED: `,
            event.entity,
        )
    }

    /**
     * Called after entity removal.
     */
    afterSoftRemove(event: SoftRemoveEvent<any>) {
        console.log(
            `AFTER ENTITY WITH ID ${event.entityId} SOFT REMOVED: `,
            event.entity,
        )
    }

    /**
     * Called before entity recovery.
     */
    beforeRecover(event: RecoverEvent<any>) {
        console.log(
            `BEFORE ENTITY WITH ID ${event.entityId} RECOVERED: `,
            event.entity,
        )
    }

    /**
     * Called after entity recovery.
     */
    afterRecover(event: RecoverEvent<any>) {
        console.log(
            `AFTER ENTITY WITH ID ${event.entityId} RECOVERED: `,
            event.entity,
        )
    }

    /**
     * Called before transaction start.
     */
    beforeTransactionStart(event: TransactionStartEvent) {
        console.log(`BEFORE TRANSACTION STARTED: `, event)
    }

    /**
     * Called after transaction start.
     */
    afterTransactionStart(event: TransactionStartEvent) {
        console.log(`AFTER TRANSACTION STARTED: `, event)
    }

    /**
     * Called before transaction commit.
     */
    beforeTransactionCommit(event: TransactionCommitEvent) {
        console.log(`BEFORE TRANSACTION COMMITTED: `, event)
    }

    /**
     * Called after transaction commit.
     */
    afterTransactionCommit(event: TransactionCommitEvent) {
        console.log(`AFTER TRANSACTION COMMITTED: `, event)
    }

    /**
     * Called before transaction rollback.
     */
    beforeTransactionRollback(event: TransactionRollbackEvent) {
        console.log(`BEFORE TRANSACTION ROLLBACK: `, event)
    }

    /**
     * Called after transaction rollback.
     */
    afterTransactionRollback(event: TransactionRollbackEvent) {
        console.log(`AFTER TRANSACTION ROLLBACK: `, event)
    }
}

Stellen Sie sicher, dass Ihre subscribers-Eigenschaft in Ihren DataSourceOptions konfiguriert ist, damit TypeORM Ihren Subscriber laden kann.

`Event Object`

Mit Ausnahme von listenTo erhalten alle Methoden der EntitySubscriberInterface ein Ereignisobjekt mit folgenden Basiseigenschaften:

dataSource: DataSource - Im Ereignis verwendete DataSource.
queryRunner: QueryRunner - Für die Ereignistransaktion verwendeter QueryRunner.
manager: EntityManager - Für die Ereignistransaktion verwendeter EntityManager.

Zusätzliche Eigenschaften finden Sie in den jeweiligen Event-Interfaces.

Beachten Sie: event.entity enthält möglicherweise keine Primärschlüssel, wenn Repository.update() verwendet wird. Nur die im partiellen Entitätsobjekt bereitgestellten Werte sind verfügbar. Um Primärschlüssel in Subscribers verfügbar zu machen, übergeben Sie diese explizit im partiellen Entitätsobjektliteral oder verwenden Sie Repository.save(), das einen erneuten Abruf durchführt.

await postRepository.update(post.id, { description: "Bacon ipsum dolor amet cow" })

// post.subscriber.ts
afterUpdate(event: UpdateEvent<Post>) {
  console.log(event.entity) // outputs { description: 'Bacon ipsum dolor amet cow' }
}

Hinweis: Alle Datenbankoperationen in abonnierten Ereignis-Listenern sollten über die queryRunner- oder manager-Instanz des Ereignisobjekts erfolgen.

Was ist ein Entity Listener?​

@AfterLoad​

@BeforeInsert​

@AfterInsert​

@BeforeUpdate​

@AfterUpdate​

@BeforeRemove​

@AfterRemove​

@BeforeSoftRemove​

@AfterSoftRemove​

@BeforeRecover​

@AfterRecover​

Was ist ein Subscriber?​

Event Object​