fix: resolve issue delete column null on after update event subscriber (

#8318)

Closes: #6327

src/persistence/SubjectExecutor.ts

@@ -735,11 +735,11 @@ export class SubjectExecutor {
             this.updateSpecialColumnsInInsertedAndUpdatedEntities(this.updateSubjects);
 
         // update soft-removed entity properties
-        if (this.updateSubjects.length)
+        if (this.softRemoveSubjects.length)
             this.updateSpecialColumnsInInsertedAndUpdatedEntities(this.softRemoveSubjects);
 
         // update recovered entity properties
-        if (this.updateSubjects.length)
+        if (this.recoverSubjects.length)
             this.updateSpecialColumnsInInsertedAndUpdatedEntities(this.recoverSubjects);
 
         // remove ids from the entities that were removed

src/query-builder/ReturningResultsEntityUpdator.ts

@@ -50,7 +50,7 @@ export class ReturningResultsEntityUpdator {
             } else {
 
                 // for driver which do not support returning/output statement we need to perform separate query and load what we need
-                const updationColumns = this.getUpdationReturningColumns();
+                const updationColumns = this.expressionMap.extraReturningColumns;
                 if (updationColumns.length > 0) {
 
                     // get entity id by which we will get needed data
@@ -62,9 +62,10 @@ export class ReturningResultsEntityUpdator {
                     const loadedReturningColumns = await this.queryRunner.manager
                         .createQueryBuilder()
                         .select(metadata.primaryColumns.map(column => metadata.targetName + "." + column.propertyPath))
-                        .addSelect(this.getUpdationReturningColumns().map(column => metadata.targetName + "." + column.propertyPath))
+                        .addSelect(updationColumns.map(column => metadata.targetName + "." + column.propertyPath))
                         .from(metadata.target, metadata.targetName)
                         .where(entityId)
+                        .withDeleted()
                         .setOption("create-pojo") // use POJO because created object can contain default values, e.g. property = null and those properties maight be overridden by merge process
                         .getOne() as any;
 
@@ -194,4 +195,13 @@ export class ReturningResultsEntityUpdator {
         });
     }
 
+    /**
+     * Columns we need to be returned from the database when we soft delete and restore entity.
+     */
+    getSoftDeletionReturningColumns(): ColumnMetadata[] {
+        return this.expressionMap.mainAlias!.metadata.columns.filter(column => {
+            return column.isUpdateDate || column.isVersion || column.isDeleteDate;
+        });
+    }
+
 }

src/query-builder/SoftDeleteQueryBuilder.ts

@@ -73,7 +73,7 @@ export class SoftDeleteQueryBuilder<Entity> extends QueryBuilder<Entity> impleme
             if (this.expressionMap.updateEntity === true &&
                 this.expressionMap.mainAlias!.hasMetadata &&
                 this.expressionMap.whereEntities.length > 0) {
-                this.expressionMap.extraReturningColumns = returningResultsEntityUpdator.getUpdationReturningColumns();
+                this.expressionMap.extraReturningColumns = returningResultsEntityUpdator.getSoftDeletionReturningColumns();
             }
 
             // execute update query

test/github-issues/6327/entity/Post.ts

@@ -0,0 +1,13 @@
+import { DeleteDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from "../../../../src";
+
+@Entity()
+export class Post {
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @UpdateDateColumn()
+    updatedAt: Date;
+
+    @DeleteDateColumn()
+    deletedAt: Date;
+}

test/github-issues/6327/issue-6327.ts

@@ -0,0 +1,31 @@
+import "reflect-metadata";
+import { createTestingConnections, closeTestingConnections, reloadTestingDatabases } from "../../utils/test-utils";
+import { Connection } from "../../../src/connection/Connection";
+import { Post } from "./entity/Post";
+
+describe("github issues > #6327 softRemove DeleteDateColumn is null at Susbscriber's AfterUpdate method", () => {
+
+    let connections: Connection[];
+    before(async () => connections = await createTestingConnections({
+        entities: [__dirname + "/entity/*{.js,.ts}"],
+        subscribers: [__dirname + "/subscriber/*{.js,.ts}"],
+        schemaCreate: true,
+        dropSchema: true,
+    }));
+    beforeEach(() => reloadTestingDatabases(connections));
+    after(() => closeTestingConnections(connections));
+
+    it("should send correct update and delete date columns to after update subscriber", () => Promise.all(connections.map(async connection => {
+
+        const manager = connection.manager;
+
+        const entity = new Post();
+        await manager.save(entity);
+
+        const deletedEntity = await manager.softRemove(entity, { data: { action: "soft-delete" } });
+
+        await manager.recover(deletedEntity, { data: { action: "restore" } });
+
+    })));
+
+});

test/github-issues/6327/subscriber/PostSubscriber.ts

@@ -0,0 +1,24 @@
+import { expect } from "chai";
+import { EntitySubscriberInterface, EventSubscriber, UpdateEvent } from "../../../../src";
+import { Post } from "../entity/Post";
+
+@EventSubscriber()
+export class PostSubscriber implements EntitySubscriberInterface<Post> {
+    listenTo() {
+        return Post;
+    }
+
+    afterUpdate(event: UpdateEvent<Post>): void {
+        const { entity, queryRunner: { data } } = event;
+
+        expect(["soft-delete", "restore"]).to.include(data!.action);
+
+        if (data!.action === "soft-delete") {
+            expect(Object.prototype.toString.call(entity!.deletedAt)).to.be.eq("[object Date]");
+        }
+
+        if (data!.action === "restore") {
+            expect(entity!.deletedAt).to.be.null;
+        }
+    }
+}