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

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;
 
@@ -165,6 +166,60 @@ export class ReturningResultsEntityUpdator {
         });
     }
 
+    /**
+     * Updates entities with a special columns after soft delete and restore query execution.
+     */
+    async softDelete(updateResult: UpdateResult, entities: ObjectLiteral[]): Promise<void> {
+        const metadata = this.expressionMap.mainAlias!.metadata;
+
+        await Promise.all(entities.map(async (entity, entityIndex) => {
+
+            // if database supports returning/output statement then we already should have updating values in the raw data returned by insert query
+            if (this.queryRunner.connection.driver.isReturningSqlSupported()) {
+                if (this.queryRunner.connection.driver instanceof OracleDriver && Array.isArray(updateResult.raw) && this.expressionMap.extraReturningColumns.length > 0) {
+                    updateResult.raw = updateResult.raw.reduce((newRaw, rawItem, rawItemIndex) => {
+                        newRaw[this.expressionMap.extraReturningColumns[rawItemIndex].databaseName] = rawItem[0];
+                        return newRaw;
+                    }, {} as ObjectLiteral);
+                }
+                const result = Array.isArray(updateResult.raw) ? updateResult.raw[entityIndex] : updateResult.raw;
+                const returningColumns = this.queryRunner.connection.driver.createGeneratedMap(metadata, result);
+                if (returningColumns) {
+                    this.queryRunner.manager.merge(metadata.target as any, entity, returningColumns);
+                    updateResult.generatedMaps.push(returningColumns);
+                }
+
+            } else {
+
+                // for driver which do not support returning/output statement we need to perform separate query and load what we need
+                const updationColumns = this.getSoftDeletionReturningColumns();
+                if (updationColumns.length > 0) {
+
+                    // get entity id by which we will get needed data
+                    const entityId = this.expressionMap.mainAlias!.metadata.getEntityIdMap(entity);
+                    if (!entityId)
+                        throw new TypeORMError(`Cannot update entity because entity id is not set in the entity.`);
+
+                    // execute query to get needed data
+                    const loadedReturningColumns = await this.queryRunner.manager
+                        .createQueryBuilder()
+                        .select(metadata.primaryColumns.map(column => metadata.targetName + "." + column.propertyPath))
+                        .addSelect(this.getSoftDeletionReturningColumns().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;
+
+                    if (loadedReturningColumns) {
+                        this.queryRunner.manager.merge(metadata.target as any, entity, loadedReturningColumns);
+                        updateResult.generatedMaps.push(loadedReturningColumns);
+                    }
+                }
+            }
+        }));
+    }
+
     /**
      * Columns we need to be returned from the database when we insert entity.
      */
@@ -194,4 +249,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
@@ -86,7 +86,7 @@ export class SoftDeleteQueryBuilder<Entity> extends QueryBuilder<Entity> impleme
             if (this.expressionMap.updateEntity === true &&
                 this.expressionMap.mainAlias!.hasMetadata &&
                 this.expressionMap.whereEntities.length > 0) {
-                await returningResultsEntityUpdator.update(updateResult, this.expressionMap.whereEntities);
+                await returningResultsEntityUpdator.softDelete(updateResult, this.expressionMap.whereEntities);
             }
 
             // call after updation methods in listeners and subscribers

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;
+        }
+    }
+}