@flusys/nestjs-auth 3.0.0 → 4.0.0-rc

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

@@ -8,11 +8,13 @@ Object.defineProperty(exports, "AuthEmailService", {
         return AuthEmailService;
     }
 });
+const _constants = require("@flusys/nestjs-shared/constants");
+const _nestjsshared = require("@flusys/nestjs-shared");
+const _config = require("../config");
 const _common = require("@nestjs/common");
 const _bcrypt = /*#__PURE__*/ _interop_require_wildcard(require("bcrypt"));
 const _crypto = /*#__PURE__*/ _interop_require_wildcard(require("crypto"));
 const _typeorm = require("typeorm");
-const _config = require("../config");
 const _pendingregistrationentity = require("../entities/pending-registration.entity");
 const _usertokenentity = require("../entities/user-token.entity");
 const _userentity = require("../entities/user.entity");
@@ -92,7 +94,13 @@ let AuthEmailService = class AuthEmailService {
     }
     async getRepository(entity) {
         if (!this.dataSourceProvider) {
-            throw new _common.InternalServerErrorException(`${String(entity)} repository not available`);
+            throw new _common.InternalServerErrorException({
+                message: `${String(entity)} repository not available`,
+                messageKey: _constants.SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE,
+                messageParams: {
+                    entity: String(entity)
+                }
+            });
         }
         return this.dataSourceProvider.getRepository(entity);
     }
@@ -102,29 +110,36 @@ let AuthEmailService = 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 _common.BadRequestException('Email service is not configured');
+            throw new _common.BadRequestException({
+                message: 'Email service is not configured',
+                messageKey: _config.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 _common.BadRequestException('Failed to send verification email. Please try again.');
+        } catch  {
+            throw new _common.BadRequestException({
+                message: 'Failed to send verification email. Please try again.',
+                messageKey: _config.AUTH_MESSAGES.EMAIL_SEND_FAILED
+            });
         }
     }
-    validateTokenNotExpiredOrUsed(token, expiredMessage, usedMessage) {
+    validateTokenNotExpiredOrUsed(token, expiredMessage, expiredMessageKey, usedMessage, usedMessageKey) {
         if (token.expiresAt < new Date()) {
-            throw new _common.BadRequestException(expiredMessage);
+            throw new _common.BadRequestException({
+                message: expiredMessage,
+                messageKey: expiredMessageKey
+            });
         }
-        if (usedMessage && token.usedAt) {
-            throw new _common.BadRequestException(usedMessage);
+        if (usedMessage && usedMessageKey && token.usedAt) {
+            throw new _common.BadRequestException({
+                message: usedMessage,
+                messageKey: usedMessageKey
+            });
         }
     }
     async hasPendingRegistration(email) {
@@ -148,7 +163,10 @@ let AuthEmailService = class AuthEmailService {
             }
         });
         if (existingUser) {
-            throw new _common.BadRequestException('Registration failed. Please try again or contact support.');
+            throw new _common.BadRequestException({
+                message: 'Registration failed. Please try again or contact support.',
+                messageKey: _config.AUTH_MESSAGES.REGISTER_FAILED
+            });
         }
         // Delete any existing pending registration for this email
         await pendingRepository.delete({
@@ -172,10 +190,11 @@ let AuthEmailService = 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: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SENT
         };
     }
     async forgotPassword(email, resetUrlBase) {
@@ -189,10 +208,10 @@ let AuthEmailService = 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: _config.AUTH_MESSAGES.PASSWORD_RESET_EMAIL_SENT
             };
         }
         // Invalidate existing password reset tokens for this user
@@ -214,14 +233,16 @@ let AuthEmailService = 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 _common.BadRequestException('Failed to process request. Please try again later.');
+        } catch  {
+            throw new _common.BadRequestException({
+                message: 'Failed to process request. Please try again later.',
+                messageKey: _constants.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: _config.AUTH_MESSAGES.PASSWORD_RESET_EMAIL_SENT
         };
     }
     async resetPassword(token, newPassword) {
@@ -236,16 +257,22 @@ let AuthEmailService = class AuthEmailService {
             }
         });
         if (!userToken) {
-            throw new _common.BadRequestException('Invalid or expired reset token');
+            throw new _common.BadRequestException({
+                message: 'Invalid or expired reset token',
+                messageKey: _config.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.', _config.AUTH_MESSAGES.PASSWORD_RESET_TOKEN_EXPIRED, 'This reset token has already been used.', _config.AUTH_MESSAGES.PASSWORD_RESET_TOKEN_USED);
         const user = await userRepository.findOne({
             where: {
                 id: userToken.userId
             }
         });
         if (!user) {
-            throw new _common.BadRequestException('User not found');
+            throw new _common.BadRequestException({
+                message: 'User not found',
+                messageKey: _config.USER_MESSAGES.NOT_FOUND
+            });
         }
         // Update password
         user.password = await _bcrypt.hash(newPassword, _config.BCRYPT_SALT_ROUNDS);
@@ -253,10 +280,10 @@ let AuthEmailService = 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: _config.AUTH_MESSAGES.PASSWORD_RESET_SUCCESS
         };
     }
     async verifyEmail(token) {
@@ -276,7 +303,10 @@ let AuthEmailService = class AuthEmailService {
                 await pendingRepository.delete({
                     id: pending.id
                 });
-                throw new _common.BadRequestException('Verification token has expired. Please register again.');
+                throw new _common.BadRequestException({
+                    message: 'Verification token has expired. Please register again.',
+                    messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_EXPIRED
+                });
             }
             // Delete pending registration (will be consumed by caller to create user)
             await pendingRepository.delete({
@@ -295,18 +325,25 @@ let AuthEmailService = class AuthEmailService {
             }
         });
         if (!userToken) {
-            throw new _common.BadRequestException('Invalid or expired verification token');
+            throw new _common.BadRequestException({
+                message: 'Invalid or expired verification token',
+                messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_INVALID
+            });
         }
         if (userToken.expiresAt < new Date()) {
             await tokenRepository.delete({
                 id: userToken.id
             });
-            throw new _common.BadRequestException('Verification token has expired. Please request a new one.');
+            throw new _common.BadRequestException({
+                message: 'Verification token has expired. Please request a new one.',
+                messageKey: _config.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: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SUCCESS
             };
         }
         const user = await userRepository.findOne({
@@ -315,7 +352,10 @@ let AuthEmailService = class AuthEmailService {
             }
         });
         if (!user) {
-            throw new _common.BadRequestException('User not found');
+            throw new _common.BadRequestException({
+                message: 'User not found',
+                messageKey: _config.USER_MESSAGES.NOT_FOUND
+            });
         }
         // Mark email as verified
         user.emailVerified = true;
@@ -323,10 +363,10 @@ let AuthEmailService = 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: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SUCCESS
         };
     }
     async resendVerificationEmail(email, verifyUrlBase) {
@@ -346,10 +386,11 @@ let AuthEmailService = 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: _config.EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
             };
         }
         // Check existing user
@@ -361,7 +402,8 @@ let AuthEmailService = 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: _config.EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
             };
         }
         // Invalidate existing tokens and create new one
@@ -378,10 +420,11 @@ let AuthEmailService = 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: _config.EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
         };
     }
     async cleanupExpired() {
@@ -396,7 +439,6 @@ let AuthEmailService = 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
@@ -405,16 +447,84 @@ let AuthEmailService = 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 _common.Logger(AuthEmailService.name);
         this.PASSWORD_RESET_EXPIRY = 60 * 60 * 1000;
         this.EMAIL_VERIFICATION_EXPIRY = 24 * 60 * 60 * 1000;
     }
 };
+_ts_decorate([
+    (0, _nestjsshared.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([
+    (0, _nestjsshared.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([
+    (0, _nestjsshared.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([
+    (0, _nestjsshared.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([
+    (0, _nestjsshared.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([
+    (0, _nestjsshared.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([
     (0, _common.Injectable)({
         scope: _common.Scope.REQUEST