@flusys/nestjs-auth 3.0.0 → 4.0.0-lts

package/fesm/controllers/user.controller.js

@@ -26,6 +26,7 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { createApiController, USER_PERMISSIONS } from '@flusys/nestjs-shared/classes';
+import { USER_MESSAGES } from '../config';
 import { CurrentUser, RequirePermission } from '@flusys/nestjs-shared/decorators';
 import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
@@ -34,6 +35,7 @@ import { ApiBearerAuth, ApiBody, ApiOperation, ApiParam, ApiTags } from '@nestjs
 import { CreateUserDto, UpdateUserDto, UserResponseDto } from '../dtos/user.dto';
 import { UserService } from '../services/user.service';
 export class UserController extends createApiController(CreateUserDto, UpdateUserDto, UserResponseDto, {
+    entityName: 'user',
     security: {
         insert: {
             level: 'permission',
@@ -83,6 +85,8 @@ export class UserController extends createApiController(CreateUserDto, UpdateUse
         const data = await this.service.getProfileWithExtras(id, user);
         return {
             success: true,
+            message: 'Profile extras retrieved successfully',
+            messageKey: USER_MESSAGES.PROFILE_EXTRAS_SUCCESS,
             data
         };
     }
@@ -90,21 +94,24 @@ export class UserController extends createApiController(CreateUserDto, UpdateUse
         await this.service.verifyEmail(id);
         return {
             success: true,
-            message: 'Email verified successfully'
+            message: 'Email verified successfully',
+            messageKey: USER_MESSAGES.EMAIL_VERIFY_SUCCESS
         };
     }
     async verifyPhone(id) {
         await this.service.verifyPhone(id);
         return {
             success: true,
-            message: 'Phone verified successfully'
+            message: 'Phone verified successfully',
+            messageKey: USER_MESSAGES.PHONE_VERIFY_SUCCESS
         };
     }
     async updateStatus(id, isActive, user) {
         await this.service.updateStatus(id, isActive, user);
         return {
             success: true,
-            message: 'Status updated successfully'
+            message: 'Status updated successfully',
+            messageKey: USER_MESSAGES.STATUS_UPDATE_SUCCESS
         };
     }
     async profile(dto, user) {
@@ -112,6 +119,7 @@ export class UserController extends createApiController(CreateUserDto, UpdateUse
         return {
             success: true,
             message: 'Profile updated successfully',
+            messageKey: USER_MESSAGES.PROFILE_UPDATE_SUCCESS,
             data
         };
     }
@@ -120,6 +128,7 @@ export class UserController extends createApiController(CreateUserDto, UpdateUse
         return {
             success: true,
             message: 'Profile sections retrieved successfully',
+            messageKey: USER_MESSAGES.PROFILE_SECTIONS_SUCCESS,
             data: sections
         };
     }
@@ -128,6 +137,7 @@ export class UserController extends createApiController(CreateUserDto, UpdateUse
         return {
             success: true,
             message: 'Profile section data retrieved successfully',
+            messageKey: USER_MESSAGES.PROFILE_SECTION_DATA_SUCCESS,
             data
         };
     }
@@ -135,7 +145,8 @@ export class UserController extends createApiController(CreateUserDto, UpdateUse
         await this.service.updateProfileSection(id, sectionId, data, user);
         return {
             success: true,
-            message: 'Section updated successfully'
+            message: 'Section updated successfully',
+            messageKey: USER_MESSAGES.PROFILE_SECTION_UPDATE_SUCCESS
         };
     }
     async getProfileCompletion(id, user) {
@@ -143,6 +154,7 @@ export class UserController extends createApiController(CreateUserDto, UpdateUse
         return {
             success: true,
             message: 'Profile completion retrieved successfully',
+            messageKey: USER_MESSAGES.PROFILE_COMPLETION_SUCCESS,
             data: {
                 completionPercentage: percentage
             }

package/fesm/dtos/authentication.dto.js

@@ -613,6 +613,7 @@ export class LoginResponseRequiresEmailVerificationDto {
         _define_property(this, "requiresEmailVerification", void 0);
         _define_property(this, "email", void 0);
         _define_property(this, "message", void 0);
+        _define_property(this, "messageKey", void 0);
     }
 }
 _ts_decorate([
@@ -633,6 +634,13 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], LoginResponseRequiresEmailVerificationDto.prototype, "message", void 0);
+_ts_decorate([
+    ApiProperty({
+        example: 'auth.login.email.not.verified',
+        description: 'Translation key for localization'
+    }),
+    _ts_metadata("design:type", String)
+], LoginResponseRequiresEmailVerificationDto.prototype, "messageKey", void 0);
 export class ForgotPasswordDto {
     constructor(){
         _define_property(this, "email", void 0);

package/fesm/dtos/user-permission.dto.js

@@ -235,6 +235,7 @@ _ts_decorate([
     constructor(){
         _define_property(this, "success", void 0);
         _define_property(this, "message", void 0);
+        _define_property(this, "messageKey", void 0);
         _define_property(this, "data", void 0);
     }
 }
@@ -250,6 +251,12 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], UserCompaniesResponseDto.prototype, "message", void 0);
+_ts_decorate([
+    ApiProperty({
+        example: 'userPermission.company.list.success'
+    }),
+    _ts_metadata("design:type", String)
+], UserCompaniesResponseDto.prototype, "messageKey", void 0);
 _ts_decorate([
     ApiProperty({
         description: 'List of companies the user has access to',
@@ -281,6 +288,7 @@ _ts_decorate([
     constructor(){
         _define_property(this, "success", void 0);
         _define_property(this, "message", void 0);
+        _define_property(this, "messageKey", void 0);
         _define_property(this, "data", void 0);
     }
 }
@@ -296,6 +304,12 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], UserBranchesResponseDto.prototype, "message", void 0);
+_ts_decorate([
+    ApiProperty({
+        example: 'userPermission.branch.list.success'
+    }),
+    _ts_metadata("design:type", String)
+], UserBranchesResponseDto.prototype, "messageKey", void 0);
 _ts_decorate([
     ApiProperty({
         description: 'List of branches the user has access to',

package/fesm/interceptors/set-token.interceptor.js

@@ -26,6 +26,7 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { buildCookieOptions, isBrowserRequest, parseDurationToMs } from '@flusys/nestjs-shared/utils';
+import { AUTH_MESSAGES } from '../config';
 import { Inject, Injectable, Optional, PayloadTooLargeException } from '@nestjs/common';
 import { Buffer } from 'buffer';
 import { catchError, map, throwError } from 'rxjs';
@@ -42,10 +43,13 @@ export class SetToken {
         const req = context.switchToHttp().getRequest();
         const res = context.switchToHttp().getResponse();
         return next.handle().pipe(map((value)=>{
-            if (!value?.refreshToken) return value;
+            if (typeof value !== 'object' || value === null || !('refreshToken' in value)) {
+                return value;
+            }
+            const response = value;
             if (isBrowserRequest(req)) {
-                this.setRefreshTokenCookie(req, res, value.refreshToken);
-                const { refreshToken, ...responseWithoutToken } = value;
+                this.setRefreshTokenCookie(req, res, String(response.refreshToken));
+                const { refreshToken, ...responseWithoutToken } = response;
                 return responseWithoutToken;
             }
             return value;
@@ -55,7 +59,13 @@ export class SetToken {
         const rawCookieString = `${this.cookieName}=${tokenValue}; HttpOnly`;
         const estimatedBytes = Buffer.byteLength(rawCookieString, 'utf8');
         if (estimatedBytes > MAX_COOKIE_BYTES) {
-            throw new PayloadTooLargeException(`Refresh token too large (≈${estimatedBytes} bytes)`);
+            throw new PayloadTooLargeException({
+                message: `Refresh token too large (≈${estimatedBytes} bytes)`,
+                messageKey: AUTH_MESSAGES.TOKEN_TOO_LARGE,
+                messageParams: {
+                    size: estimatedBytes
+                }
+            });
         }
         res.cookie(this.cookieName, tokenValue, {
             httpOnly: true,

package/fesm/services/auth-config.service.js

@@ -26,7 +26,8 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { envConfig } from '@flusys/nestjs-core/config';
-import { Inject, Injectable, InternalServerErrorException, Logger, Optional } from '@nestjs/common';
+import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
+import { Inject, Injectable, InternalServerErrorException, Optional } from '@nestjs/common';
 import { AUTH_MODULE_OPTIONS } from '../config/auth.constants';
 import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
 export class AuthConfigService {
@@ -47,7 +48,10 @@ export class AuthConfigService {
     // JWT Configuration
     getJwtSecret() {
         if (!this.config.jwtSecret) {
-            throw new InternalServerErrorException('[AuthModule] JWT_SECRET is required - set via environment or module config');
+            throw new InternalServerErrorException({
+                message: '[AuthModule] JWT_SECRET is required - set via environment or module config',
+                messageKey: SYSTEM_MESSAGES.CONFIG_REQUIRED
+            });
         }
         return this.config.jwtSecret;
     }
@@ -59,11 +63,10 @@ export class AuthConfigService {
             return this.config.refreshTokenSecret;
         }
         if (envConfig.isProduction()) {
-            throw new InternalServerErrorException('[AuthModule] REFRESH_TOKEN_SECRET is required in production - ' + 'using the same secret for access and refresh tokens is a security risk');
-        }
-        if (!this.refreshTokenSecretWarned) {
-            this.refreshTokenSecretWarned = true;
-            this.logger.warn('REFRESH_TOKEN_SECRET not configured - using JWT_SECRET as fallback. ' + 'For better security, configure a separate refresh token secret.');
+            throw new InternalServerErrorException({
+                message: '[AuthModule] REFRESH_TOKEN_SECRET is required in production - using the same secret for access and refresh tokens is a security risk',
+                messageKey: SYSTEM_MESSAGES.CONFIG_REQUIRED
+            });
         }
         return this.getJwtSecret();
     }
@@ -78,10 +81,8 @@ export class AuthConfigService {
         return this.config.frontendUrl;
     }
     constructor(injectedOptions){
-        _define_property(this, "logger", new Logger(AuthConfigService.name));
         _define_property(this, "options", void 0);
         _define_property(this, "config", void 0);
-        _define_property(this, "refreshTokenSecretWarned", false);
         this.options = injectedOptions ?? {
             global: false,
             includeController: true

package/fesm/services/auth-datasource.provider.js

@@ -25,8 +25,8 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, InternalServerErrorException, Logger, Optional, Scope } from '@nestjs/common';
+import { MultiTenantDataSourceService, SYSTEM_MESSAGES } from '@flusys/nestjs-shared';
+import { Inject, Injectable, InternalServerErrorException, Optional, Scope } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { Request } from 'express';
 import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
@@ -40,7 +40,10 @@ export class AuthDataSourceProvider extends MultiTenantDataSourceService {
             const lockPromise = (async ()=>{
                 const config = this.getDefaultDatabaseConfig();
                 if (!config) {
-                    throw new InternalServerErrorException('Default database config is not available');
+                    throw new InternalServerErrorException({
+                        message: 'Default database config is not available',
+                        messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+                    });
                 }
                 const ds = await this.createDataSourceFromConfig(config);
                 AuthDataSourceProvider.singleDataSource = ds;
@@ -103,7 +106,7 @@ export class AuthDataSourceProvider extends MultiTenantDataSourceService {
         return super.createDataSourceFromConfig(config, await this.getAuthEntities());
     }
     constructor(authOptions, request){
-        super(AuthDataSourceProvider.buildParentOptions(authOptions), request), _define_property(this, "authOptions", void 0), _define_property(this, "logger", void 0), this.authOptions = authOptions, this.logger = new Logger(AuthDataSourceProvider.name);
+        super(AuthDataSourceProvider.buildParentOptions(authOptions), request), _define_property(this, "authOptions", void 0), this.authOptions = authOptions;
     }
 }
 _define_property(AuthDataSourceProvider, "tenantConnections", new Map());

package/fesm/services/auth-email.service.js

@@ -25,7 +25,10 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { BadRequestException, Inject, Injectable, InternalServerErrorException, Logger, Optional, Scope } from '@nestjs/common';
+import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
+import { LogAction } from '@flusys/nestjs-shared';
+import { AUTH_MESSAGES, EMAIL_VERIFICATION_MESSAGES, USER_MESSAGES } from '../config';
+import { BadRequestException, Inject, Injectable, InternalServerErrorException, Optional, Scope } from '@nestjs/common';
 import * as bcrypt from 'bcrypt';
 import * as crypto from 'crypto';
 import { LessThan } from 'typeorm';
@@ -41,7 +44,13 @@ export class AuthEmailService {
     }
     async getRepository(entity) {
         if (!this.dataSourceProvider) {
-            throw new InternalServerErrorException(`${String(entity)} repository not available`);
+            throw new InternalServerErrorException({
+                message: `${String(entity)} repository not available`,
+                messageKey: SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE,
+                messageParams: {
+                    entity: String(entity)
+                }
+            });
         }
         return this.dataSourceProvider.getRepository(entity);
     }
@@ -51,29 +60,36 @@ export class AuthEmailService {
     hashToken(token) {
         return crypto.createHash('sha256').update(token).digest('hex');
     }
-    getErrorMessage(error) {
-        return error instanceof Error ? error.message : 'Unknown error';
-    }
     assertEmailEnabled() {
         if (!this.emailProvider) {
-            throw new BadRequestException('Email service is not configured');
+            throw new BadRequestException({
+                message: 'Email service is not configured',
+                messageKey: AUTH_MESSAGES.EMAIL_NOT_CONFIGURED
+            });
         }
     }
-    async sendVerificationEmailSafe(email, token, verifyUrl, logContext) {
+    async sendVerificationEmailSafe(email, token, verifyUrl) {
         try {
             await this.emailProvider.sendVerificationEmail(email, token, verifyUrl);
-            this.logger.log(`${logContext} verification email sent to: ${email}`);
-        } catch (error) {
-            this.logger.error(`Failed to send verification email: ${this.getErrorMessage(error)}`);
-            throw new BadRequestException('Failed to send verification email. Please try again.');
+        } catch  {
+            throw new BadRequestException({
+                message: 'Failed to send verification email. Please try again.',
+                messageKey: AUTH_MESSAGES.EMAIL_SEND_FAILED
+            });
         }
     }
-    validateTokenNotExpiredOrUsed(token, expiredMessage, usedMessage) {
+    validateTokenNotExpiredOrUsed(token, expiredMessage, expiredMessageKey, usedMessage, usedMessageKey) {
         if (token.expiresAt < new Date()) {
-            throw new BadRequestException(expiredMessage);
+            throw new BadRequestException({
+                message: expiredMessage,
+                messageKey: expiredMessageKey
+            });
         }
-        if (usedMessage && token.usedAt) {
-            throw new BadRequestException(usedMessage);
+        if (usedMessage && usedMessageKey && token.usedAt) {
+            throw new BadRequestException({
+                message: usedMessage,
+                messageKey: usedMessageKey
+            });
         }
     }
     async hasPendingRegistration(email) {
@@ -97,7 +113,10 @@ export class AuthEmailService {
             }
         });
         if (existingUser) {
-            throw new BadRequestException('Registration failed. Please try again or contact support.');
+            throw new BadRequestException({
+                message: 'Registration failed. Please try again or contact support.',
+                messageKey: AUTH_MESSAGES.REGISTER_FAILED
+            });
         }
         // Delete any existing pending registration for this email
         await pendingRepository.delete({
@@ -121,10 +140,11 @@ export class AuthEmailService {
         await pendingRepository.save(pending);
         // Send verification email with raw token (user receives this)
         const verifyUrl = `${data.verifyUrlBase}?token=${token}`;
-        await this.sendVerificationEmailSafe(data.email, token, verifyUrl, 'Registration');
+        await this.sendVerificationEmailSafe(data.email, token, verifyUrl);
         return {
             success: true,
-            message: 'Please check your email to verify your registration.'
+            message: 'Please check your email to verify your registration.',
+            messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SENT
         };
     }
     async forgotPassword(email, resetUrlBase) {
@@ -138,10 +158,10 @@ export class AuthEmailService {
         });
         // Always return success to prevent email enumeration
         if (!user || !user.isActive) {
-            this.logger.warn(`Password reset requested for non-existent/inactive email: ${email}`);
             return {
                 success: true,
-                message: 'If the email exists, a password reset link has been sent.'
+                message: 'If the email exists, a password reset link has been sent.',
+                messageKey: AUTH_MESSAGES.PASSWORD_RESET_EMAIL_SENT
             };
         }
         // Invalidate existing password reset tokens for this user
@@ -163,14 +183,16 @@ export class AuthEmailService {
         const resetUrl = `${resetUrlBase}?token=${token}`;
         try {
             await this.emailProvider.sendPasswordResetEmail(email, token, resetUrl);
-            this.logger.log(`Password reset email sent to: ${email}`);
-        } catch (error) {
-            this.logger.error(`Failed to send password reset email: ${this.getErrorMessage(error)}`);
-            throw new BadRequestException('Failed to process request. Please try again later.');
+        } catch  {
+            throw new BadRequestException({
+                message: 'Failed to process request. Please try again later.',
+                messageKey: SYSTEM_MESSAGES.INTERNAL_ERROR
+            });
         }
         return {
             success: true,
-            message: 'If the email exists, a password reset link has been sent.'
+            message: 'If the email exists, a password reset link has been sent.',
+            messageKey: AUTH_MESSAGES.PASSWORD_RESET_EMAIL_SENT
         };
     }
     async resetPassword(token, newPassword) {
@@ -185,16 +207,22 @@ export class AuthEmailService {
             }
         });
         if (!userToken) {
-            throw new BadRequestException('Invalid or expired reset token');
+            throw new BadRequestException({
+                message: 'Invalid or expired reset token',
+                messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_INVALID
+            });
         }
-        this.validateTokenNotExpiredOrUsed(userToken, 'Reset token has expired. Please request a new one.', 'This reset token has already been used.');
+        this.validateTokenNotExpiredOrUsed(userToken, 'Reset token has expired. Please request a new one.', AUTH_MESSAGES.PASSWORD_RESET_TOKEN_EXPIRED, 'This reset token has already been used.', AUTH_MESSAGES.PASSWORD_RESET_TOKEN_USED);
         const user = await userRepository.findOne({
             where: {
                 id: userToken.userId
             }
         });
         if (!user) {
-            throw new BadRequestException('User not found');
+            throw new BadRequestException({
+                message: 'User not found',
+                messageKey: USER_MESSAGES.NOT_FOUND
+            });
         }
         // Update password
         user.password = await bcrypt.hash(newPassword, BCRYPT_SALT_ROUNDS);
@@ -202,10 +230,10 @@ export class AuthEmailService {
         // Mark token as used
         userToken.usedAt = new Date();
         await tokenRepository.save(userToken);
-        this.logger.log(`Password reset successful for user: ${user.email}`);
         return {
             success: true,
-            message: 'Password has been reset successfully.'
+            message: 'Password has been reset successfully.',
+            messageKey: AUTH_MESSAGES.PASSWORD_RESET_SUCCESS
         };
     }
     async verifyEmail(token) {
@@ -225,7 +253,10 @@ export class AuthEmailService {
                 await pendingRepository.delete({
                     id: pending.id
                 });
-                throw new BadRequestException('Verification token has expired. Please register again.');
+                throw new BadRequestException({
+                    message: 'Verification token has expired. Please register again.',
+                    messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_EXPIRED
+                });
             }
             // Delete pending registration (will be consumed by caller to create user)
             await pendingRepository.delete({
@@ -244,18 +275,25 @@ export class AuthEmailService {
             }
         });
         if (!userToken) {
-            throw new BadRequestException('Invalid or expired verification token');
+            throw new BadRequestException({
+                message: 'Invalid or expired verification token',
+                messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_INVALID
+            });
         }
         if (userToken.expiresAt < new Date()) {
             await tokenRepository.delete({
                 id: userToken.id
             });
-            throw new BadRequestException('Verification token has expired. Please request a new one.');
+            throw new BadRequestException({
+                message: 'Verification token has expired. Please request a new one.',
+                messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_EXPIRED
+            });
         }
         if (userToken.usedAt) {
             return {
                 type: 'verified',
-                message: 'Email has already been verified.'
+                message: 'Email has already been verified.',
+                messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SUCCESS
             };
         }
         const user = await userRepository.findOne({
@@ -264,7 +302,10 @@ export class AuthEmailService {
             }
         });
         if (!user) {
-            throw new BadRequestException('User not found');
+            throw new BadRequestException({
+                message: 'User not found',
+                messageKey: USER_MESSAGES.NOT_FOUND
+            });
         }
         // Mark email as verified
         user.emailVerified = true;
@@ -272,10 +313,10 @@ export class AuthEmailService {
         // Mark token as used
         userToken.usedAt = new Date();
         await tokenRepository.save(userToken);
-        this.logger.log(`Email verified for user: ${user.email}`);
         return {
             type: 'verified',
-            message: 'Email has been verified successfully.'
+            message: 'Email has been verified successfully.',
+            messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SUCCESS
         };
     }
     async resendVerificationEmail(email, verifyUrlBase) {
@@ -295,10 +336,11 @@ export class AuthEmailService {
             pending.expiresAt = new Date(Date.now() + this.EMAIL_VERIFICATION_EXPIRY);
             await pendingRepository.save(pending);
             const verifyUrl = `${verifyUrlBase}?token=${token}`;
-            await this.sendVerificationEmailSafe(email, token, verifyUrl, 'Re-sent registration');
+            await this.sendVerificationEmailSafe(email, token, verifyUrl);
             return {
                 success: true,
-                message: 'If the email requires verification, a link has been sent.'
+                message: 'If the email requires verification, a link has been sent.',
+                messageKey: EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
             };
         }
         // Check existing user
@@ -310,7 +352,8 @@ export class AuthEmailService {
         if (!user || user.emailVerified) {
             return {
                 success: true,
-                message: 'If the email requires verification, a link has been sent.'
+                message: 'If the email requires verification, a link has been sent.',
+                messageKey: EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
             };
         }
         // Invalidate existing tokens and create new one
@@ -327,10 +370,11 @@ export class AuthEmailService {
         });
         await tokenRepository.save(userToken);
         const verifyUrl = `${verifyUrlBase}?token=${token}`;
-        await this.sendVerificationEmailSafe(user.email, token, verifyUrl, 'Verification');
+        await this.sendVerificationEmailSafe(user.email, token, verifyUrl);
         return {
             success: true,
-            message: 'If the email requires verification, a link has been sent.'
+            message: 'If the email requires verification, a link has been sent.',
+            messageKey: EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
         };
     }
     async cleanupExpired() {
@@ -345,7 +389,6 @@ export class AuthEmailService {
         });
         const deletedTokens = tokenResult.affected ?? 0;
         const deletedPending = pendingResult.affected ?? 0;
-        this.logger.log(`Cleaned up ${deletedTokens} expired tokens and ${deletedPending} expired pending registrations`);
         return {
             deletedTokens,
             deletedPending
@@ -354,16 +397,84 @@ export class AuthEmailService {
     constructor(dataSourceProvider, emailProvider){
         _define_property(this, "dataSourceProvider", void 0);
         _define_property(this, "emailProvider", void 0);
-        _define_property(this, "logger", void 0);
         _define_property(this, "PASSWORD_RESET_EXPIRY", void 0); // 1 hour
         _define_property(this, "EMAIL_VERIFICATION_EXPIRY", void 0); // 24 hours
         this.dataSourceProvider = dataSourceProvider;
         this.emailProvider = emailProvider;
-        this.logger = new Logger(AuthEmailService.name);
         this.PASSWORD_RESET_EXPIRY = 60 * 60 * 1000;
         this.EMAIL_VERIFICATION_EXPIRY = 24 * 60 * 60 * 1000;
     }
 }
+_ts_decorate([
+    LogAction({
+        action: 'auth.createPendingRegistration',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthEmailService.prototype, "createPendingRegistration", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.forgotPassword',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthEmailService.prototype, "forgotPassword", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.resetPassword',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthEmailService.prototype, "resetPassword", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.verifyEmailToken',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthEmailService.prototype, "verifyEmail", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.sendVerificationEmail',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthEmailService.prototype, "resendVerificationEmail", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.cleanupExpiredTokens',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], AuthEmailService.prototype, "cleanupExpired", null);
 AuthEmailService = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST