The decorator @AfterUpdate() and classes what implements from EventSubscriber don't work for my project

[ramzini22]

@Entity({ tableName: 'users', repository: () => UsersRepository })
@Unique({ properties: ['email'] })
@Index({ properties: ['mid'] })
export class User extends CreatedUpdatedDeletedEntity {
    @Property({ nullable: true })
    readonly telephone!: string;

    @Property({ nullable: true })
    readonly email!: string;

    @Property()
    readonly mid: number;

    @Property({ default: false })
    readonly isOnline!: boolean;

    @ManyToOne(() => Department, { nullable: true })
    readonly department!: Department;

    @ManyToMany(() => Achievement, 'users', { owner: true })
    readonly achievements = new Collection<Achievement>(this);

    @AfterUpdate()
    doStuff(evt: any) {
        console.log('updated' + JSON.stringify(evt));
    }
}

I add @AfterUpdate(), but it doesn't work for my entity.
I also tired add eventSubscriber

@Injectable()
export class UsersSubscriber implements EventSubscriber {
    afterUpdate(args: EventArgs<User>): void {
        console.log(args);
    }
}

export default defineConfig({
    allowGlobalContext: true,
    extensions: [Migrator],
    host: Envs.db.host,
    port: Envs.db.port,
    user: Envs.db.username,
    password: Envs.db.password,
    dbName: Envs.db.name,
    entities: ['dist/**/*.entity{.ts,.js}'],
    entitiesTs: ['src/**/*.entity{.ts,.js}'],
    driver: PostgreSqlDriver,
    strict: true,
    ignoreUndefinedInQuery: true,
    validate: true,
    forceUtcTimezone: true,
    debug: Envs.db.logging,
    verbose: Envs.db.logging,
    migrations: {
        path: './dist/src/migrations',
        pathTs: './src/migrations',
        snapshot: false,
        tableName: 'mikro_orm_migrations',
        glob: '!(*.d).{js,ts}',
        transactional: true,
        allOrNothing: true,
        emit: 'ts',
        disableForeignKeys: false,
    },
    subscribers: [new UsersSubscriber()],
});

But i don't see logs at my app.
Please, help me!

[B4nan]

You haven't shared the most important part - what you are doing, how are you updating the entity? THe hooks are only for updates produced by em.flush, maybe you are doing it via QB directly? as that won't trigger any hooks (since there are no entities, just an update query).

[ramzini22]

@Injectable()
export class UsersService {
    constructor(private readonly usersRepository: UsersRepository) {}
    public async updateUser(
        userId: number,
        isOnline?: boolean,
        telephone?: string,
        email?: string,
        nickname?: string,
        name?: string,
        surname?: string,
        patronymic?: string,
        avatar?: string,
    ): Promise<void> {
        await this.usersRepository.update(
            { id: userId },
            { isOnline, telephone, email, name, surname, patronymic, nickname, avatar },
        );
    }
}

export class UsersRepository extends CustomBaseRepository<User> {
    public async createUser(name: string, surname: string, avatar: string, mid: number, email?: string): Promise<User> {
        const newUser = new User(name, surname, avatar, mid, email);
        await this.insert(newUser);

        return newUser;
    }
}

export class CustomBaseRepository<ENTITY extends object> extends SqlEntityRepository<ENTITY> {
    protected ALIAS!: string;
    getSelectQueryBuilder(): QueryBuilder<ENTITY> {
        return this.createQueryBuilder(this.ALIAS);
    }

    update(where: FilterQuery<ENTITY>, data: EntityData<ENTITY>): Promise<number> {
        const updateObject = Object.fromEntries(
            Object.entries(data).filter(([key, value]) => value !== undefined && key),
        );

        return this.nativeUpdate(where, <EntityData<ENTITY>>updateObject);
    }
}

[B4nan]

Yes, as I said, this wont trigger any hooks, you would have to use em.flush() for this, not em.nativeUpdate() (which is literally just a shortcut for query builder).