Decoupling services in layered architecture with events - node.js

Question

I am working with a system which's 2 years old already using a layered approach (controllers, services, models, repos).
I have a set of requirements for sending several welcome/onbording emails based on actions on the system, specially on user-signup and user-password-reset-requested.
In the current implementation from the older team they do the following:
Signup the user
Send a basic welcome email, the same for everybody
That approach is simple, now I need to check for several fields in different entities to discover which email has to be sent. For me the service above is likely violating the SRP (single responsability pattern) and maybe the task of sending emails looks like more a side-effect. This is my current approach:
Signed the user, Blank the user password on reset
Trigger to SQS an user-signed-up and user-password-reset-requested events
Listen the event and process the email
I feel like adding this extra EDA (event-driven architecture) idea, brings the benefit of decoupling the app service, and reliability, since if the email failed, the user was created/resetted but no email was sent. Since I may retry on errors I will not loose any email, in fact I used the outbox pattern to make it more transactional to the user change.
export class UserService {
public async blankUserPasswordByEmail(email: string): Promise<void> {
await this.getManager().transaction(async (entityManager) => {
const userRepo = entityManager.getCustomRepository(UserRepository);
const outboxRepo = entityManager.getCustomRepository(OutboxRepository);
const user = await userRepo.findByEmail(email);
const outboxMessage = new Outbox();
outboxMessage.entityId = user.id;
outboxMessage.entityType = 'User';
outboxMessage.eventType = EventType.USER_PASSWORD_RESET_REQUESTED;
outboxMessage.eventPayload = JSON.stringify(new AfterUserPasswordResetRequestedEvent(user.id));
user.password = null;
await userRepo.save(user);
await outboxRepo.save(outboxMessage);
});
}
}
And the event handler:
export class AfterUserPasswordResetRequestedListener extends BaseListener<AfterUserPasswordResetRequestedEvent> {
protected queueUrl: string = process.env.AWS_SQS_AFTER_USER_PASSWORD_RESET_REQUESTED_URL;
protected visibilityTimeout: number = 60;
protected workerName: string = 'After User Password Reset Requested Handler';
protected batchSize: number = undefined;
constructor(
private readonly emailService = new EmailService(),
private readonly userService = new UserService(),
private readonly authService = new AuthService()
) {
super();
}
async onMessage(message: AfterUserPasswordResetRequestedEvent): Promise<void> {
try {
const user = await this.userService.findUserById(message.userId);
const loginUrl = await this.authService.createResetPasswordTokenizedUrl(user.email, process.env.FRONTEND_URL);
await this.emailService.send(
new PasswordResetEmail(
{
name: user.name,
loginurl: loginUrl,
},
user.email
)
);
} catch (err) {
APP_LOGGER.error(err);
if (process.env.NODE_ENV === 'production') {
Sentry.captureException(err);
}
throw err;
}
}
}
Is that an overkill? I feel like guilty with both approaches. Using IOC for managing emails increase my SRP problem (small) and unreliable send emails and using EDA looks like more robust and complex but it solves the issue very well. I am also thinking if I am not adding things that may wrongly mixing concepts from both EDA/Layered world.
Any experience with that? It looks like some people did it https://www.toptal.com/software/single-responsibility-principle