@solidxai/core 0.0.2

package/dist/services/authentication.service.js

@@ -0,0 +1,1016 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var AuthenticationService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationService = void 0;
+const axios_1 = require("@nestjs/axios");
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const jwt_1 = require("@nestjs/jwt");
+const typeorm_1 = require("@nestjs/typeorm");
+const class_validator_1 = require("class-validator");
+const crypto_1 = require("crypto");
+const error_messages_1 = require("../constants/error-messages");
+const success_messages_1 = require("../constants/success-messages");
+const mail_factory_1 = require("../factories/mail.factory");
+const user_repository_1 = require("../repository/user.repository");
+const typeorm_2 = require("typeorm");
+const uuid_1 = require("uuid");
+const constants_1 = require("../constants");
+const user_entity_1 = require("../entities/user.entity");
+const interfaces_1 = require("../interfaces");
+const hashing_service_1 = require("./hashing.service");
+const refresh_token_ids_storage_service_1 = require("./refresh-token-ids-storage.service");
+const role_metadata_service_1 = require("./role-metadata.service");
+const setting_service_1 = require("./setting.service");
+const user_activity_history_service_1 = require("./user-activity-history.service");
+const user_service_1 = require("./user.service");
+const sms_factory_1 = require("../factories/sms.factory");
+var LoginProvider;
+(function (LoginProvider) {
+    LoginProvider["LOCAL"] = "local";
+    LoginProvider["GOOGLE"] = "google";
+    LoginProvider["OTP"] = "otp";
+})(LoginProvider || (LoginProvider = {}));
+let AuthenticationService = AuthenticationService_1 = class AuthenticationService {
+    constructor(userService, userRepository, hashingService, jwtService, refreshTokenIdsStorage, httpService, mailServiceFactory, smsFactory, eventEmitter, settingService, roleMetadataService, userActivityHistoryService, dataSource) {
+        this.userService = userService;
+        this.userRepository = userRepository;
+        this.hashingService = hashingService;
+        this.jwtService = jwtService;
+        this.refreshTokenIdsStorage = refreshTokenIdsStorage;
+        this.httpService = httpService;
+        this.mailServiceFactory = mailServiceFactory;
+        this.smsFactory = smsFactory;
+        this.eventEmitter = eventEmitter;
+        this.settingService = settingService;
+        this.roleMetadataService = roleMetadataService;
+        this.userActivityHistoryService = userActivityHistoryService;
+        this.dataSource = dataSource;
+        this.logger = new common_1.Logger(AuthenticationService_1.name);
+    }
+    async getCompanyLogo() {
+        return this.settingService.getConfigValue('companylogo');
+    }
+    async resolveUser(username, email) {
+        return await this.userRepository.findOne({
+            where: [
+                { username: username },
+                { email: email },
+            ],
+            relations: {
+                roles: true
+            }
+        });
+    }
+    async updatePasswordDetails(user, newPassword) {
+        user.password = await this.hashingService.hash(newPassword);
+        user.passwordScheme = this.hashingService.name();
+        user.passwordSchemeVersion = this.hashingService.currentVersion();
+        user.rehashedAt = new Date();
+        await this.userRepository.update(user.id, {
+            password: user.password,
+            passwordScheme: user.passwordScheme,
+            passwordSchemeVersion: user.passwordSchemeVersion,
+            rehashedAt: user.rehashedAt
+        });
+        return user;
+    }
+    async resolveUserByVerificationToken(token) {
+        return await this.userRepository.findOne({
+            where: { verificationTokenOnForgotPassword: token },
+            relations: { roles: true }
+        });
+    }
+    async validateUserAndRehashPasswordIfRequired(signInDto) {
+        const user = await this.resolveUser(signInDto.username, signInDto.email);
+        if (!user) {
+            throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_CREDENTIALS);
+        }
+        if (!user.active) {
+            throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_NOT_ACTIVE);
+        }
+        const isEqual = await this.hashingService.compare(signInDto.password, user.password, user.passwordSchemeVersion);
+        if (!isEqual) {
+            throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_CREDENTIALS);
+        }
+        if (this.hashingService.needsRehash(user.password, user.passwordSchemeVersion)) {
+            const rehashedUser = await this.updatePasswordDetails(user, signInDto.password);
+            return rehashedUser;
+        }
+        return user;
+    }
+    async signUp(signUpDto, activeUser = null) {
+        try {
+            const onForcePasswordChange = this.settingService.getConfigValue('forceChangePasswordOnFirstLogin');
+            const activateUserOnRegistration = this.settingService.getConfigValue('activateUserOnRegistration');
+            const defaultRole = this.settingService.getConfigValue('defaultRole');
+            var { user, pwd, autoGeneratedPwd } = await this.populateForSignup(new user_entity_1.User(), signUpDto, activateUserOnRegistration, onForcePasswordChange);
+            const savedUser = await this.userRepository.save(user);
+            const userRoles = signUpDto.roles ?? [];
+            if (signUpDto.username !== 'sa' && defaultRole) {
+                userRoles.push(defaultRole);
+            }
+            await this.handlePostSignup(savedUser, userRoles, pwd, autoGeneratedPwd);
+            return savedUser;
+        }
+        catch (err) {
+            const pgUniqueViolationErrorCode = '23505';
+            if (err.code === pgUniqueViolationErrorCode) {
+                throw new common_1.ConflictException(error_messages_1.ERROR_MESSAGES.USER_ALREADY_EXISTS);
+            }
+            throw err;
+        }
+    }
+    async signupForExtensionUser(signUpDto, extensionUserDto, extensionUserRepo) {
+        try {
+            const onForcePasswordChange = this.settingService.getConfigValue('forceChangePasswordOnFirstLogin');
+            const extensionUser = extensionUserRepo.merge(extensionUserRepo.create(), extensionUserDto);
+            var { user, pwd, autoGeneratedPwd } = await this.populateForSignup(extensionUser, signUpDto, extensionUserDto.active ?? true, onForcePasswordChange);
+            const savedUser = await extensionUserRepo.save(user);
+            await this.handlePostSignup(savedUser, signUpDto.roles, pwd, autoGeneratedPwd);
+            return savedUser;
+        }
+        catch (err) {
+            const pgUniqueViolationErrorCode = '23505';
+            if (err.code === pgUniqueViolationErrorCode) {
+                throw new common_1.ConflictException(parseUniqueConstraintError(err.detail || error_messages_1.ERROR_MESSAGES.UNIQUE_CONSTRAINT_VIOLATION));
+            }
+            throw err;
+        }
+    }
+    async populateForSignup(user, signUpDto, isUserActive = true, onForcePasswordChange) {
+        let autoGeneratedPwdPermission = this.settingService.getConfigValue('iamAutoGeneratedPassword');
+        if (signUpDto.roles && signUpDto.roles.length > 0) {
+            for (let i = 0; i < signUpDto.roles.length; i++) {
+                const roleName = signUpDto.roles[i];
+                await this.roleMetadataService.findRoleByName(roleName);
+            }
+        }
+        user.username = signUpDto.username;
+        user.email = signUpDto.email;
+        user.fullName = signUpDto.fullName;
+        user.forcePasswordChange = onForcePasswordChange;
+        if (signUpDto.mobile) {
+            user.mobile = signUpDto.mobile;
+        }
+        let pwd = '';
+        let autoGeneratedPwd = '';
+        if (signUpDto.password) {
+            pwd = await this.hashingService.hash(signUpDto.password);
+        }
+        else {
+            if (autoGeneratedPwdPermission?.toString().toLowerCase() === 'true') {
+                autoGeneratedPwd = this.generatePassword();
+                pwd = await this.hashingService.hash(autoGeneratedPwd);
+                user.forcePasswordChange = true;
+            }
+            else {
+                if (!await this.isPasswordlessRegistrationEnabled()) {
+                    this.logger.error('User being created without password, and password less login is also not enabled in the system. Is this intentional?');
+                    throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
+                }
+                pwd = await this.hashingService.hash(pwd);
+            }
+        }
+        user.password = pwd;
+        user.passwordScheme = this.hashingService.name();
+        user.passwordSchemeVersion = this.hashingService.currentVersion();
+        user.active = isUserActive;
+        return { user, pwd, autoGeneratedPwd };
+    }
+    async handlePostSignup(user, roles = [], pwd, autoGeneratedPwd) {
+        await this.userService.initializeRolesForNewUser(roles, user);
+        if (user.forcePasswordChange && autoGeneratedPwd) {
+            await this.notifyUserOnForcePasswordChange(user, autoGeneratedPwd);
+        }
+        await this.notifyUserOnSignup(user);
+    }
+    generatePassword(length = 8) {
+        const upperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        const lowerCase = "abcdefghijklmnopqrstuvwxyz";
+        const numbers = "0123456789";
+        const specialChars = "@$#";
+        const allChars = upperCase + lowerCase + numbers + specialChars;
+        let password = "";
+        for (let i = 0; i < length; i++) {
+            const randomIndex = Math.floor(Math.random() * allChars.length);
+            password += allChars[randomIndex];
+        }
+        return password;
+    }
+    async notifyUserOnForcePasswordChange(user, autoGeneratedPwd) {
+        const companyLogo = await this.getCompanyLogo();
+        const mailService = this.mailServiceFactory.getMailService();
+        mailService.sendEmailUsingTemplate(user.email, 'on-force-password-change', {
+            solidAppName: this.settingService.getConfigValue('appTitle'),
+            solidAppWebsiteUrl: this.settingService.getConfigValue('solidAppWebsiteUrl'),
+            frontendLoginPageUrl: this.settingService.getConfigValue('frontendLoginPageUrl'),
+            email: user.email,
+            fullName: user.fullName,
+            userName: user.username,
+            password: autoGeneratedPwd,
+            companyLogoUrl: companyLogo
+        }, this.settingService.getConfigValue('shouldQueueEmails'), null, null, 'user', user.id);
+    }
+    async isWelcomeEmailEnabled() {
+        const sendWelcomeEmailOnSignup = this.settingService.getConfigValue('sendWelcomeEmailOnSignup');
+        return sendWelcomeEmailOnSignup;
+    }
+    async isWelcomeSmsEnabled() {
+        const sendWelcomeSmsOnSignup = this.settingService.getConfigValue('sendWelcomeSmsOnSignup');
+        return sendWelcomeSmsOnSignup;
+    }
+    async notifyUserOnSignup(user) {
+        const companyLogo = await this.getCompanyLogo();
+        if (await this.isWelcomeEmailEnabled()) {
+            const mailService = this.mailServiceFactory.getMailService();
+            mailService.sendEmailUsingTemplate(user.email, 'email-on-signup', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                solidAppWebsiteUrl: this.settingService.getConfigValue('solidAppWebsiteUrl'),
+                frontendLoginPageUrl: this.settingService.getConfigValue('frontendLoginPageUrl'),
+                email: user.email,
+                fullName: user.fullName,
+                userName: user.username,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueEmails'), null, null, 'user', user.id);
+        }
+        const isWelcomeSmsEnabled = await this.isWelcomeSmsEnabled();
+        if (isWelcomeSmsEnabled && user.mobile) {
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(user.mobile, 'text-on-signup', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                frontendLoginPageUrl: this.settingService.getConfigValue('frontendLoginPageUrl'),
+                firstName: user.username,
+                fullName: user.fullName ? user.fullName : user.username
+            }, this.settingService.getConfigValue('shouldQueueSms'));
+        }
+    }
+    async otpInitiateRegistration(signUpDto) {
+        try {
+            const isPasswordlessRegistrationEnabled = await this.isPasswordlessRegistrationEnabled();
+            if (!isPasswordlessRegistrationEnabled) {
+                throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
+            }
+            if ((0, class_validator_1.isEmpty)(signUpDto.mobile) && (0, class_validator_1.isEmpty)(signUpDto.email)) {
+                throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.REGISTRATION_REQUIRES_CONTACT);
+            }
+            if (signUpDto.validationSources.includes(constants_1.TransactionalRegistrationValidationSource.EMAIL) && (0, class_validator_1.isEmpty)(signUpDto.email)) {
+                throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.EMAIL_REQUIRED_FOR_VALIDATION);
+            }
+            if (signUpDto.validationSources.includes(constants_1.TransactionalRegistrationValidationSource.MOBILE) && (0, class_validator_1.isEmpty)(signUpDto.mobile)) {
+                throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.MOBILE_REQUIRED_FOR_VALIDATION);
+            }
+            const existingUser = await this.userRepository.findOne({
+                where: [
+                    { email: signUpDto.email, },
+                    { mobile: signUpDto.mobile, },
+                    { username: signUpDto.username, }
+                ]
+            });
+            if ((0, class_validator_1.isNotEmpty)(existingUser) && existingUser.active) {
+                throw new common_1.ConflictException(error_messages_1.ERROR_MESSAGES.USER_ALREADY_EXISTS);
+            }
+            let passwordlessRegistrationValidateWhat = this.settingService.getConfigValue('passwordlessRegistrationValidateWhat');
+            if (!Array.isArray(passwordlessRegistrationValidateWhat)) {
+                passwordlessRegistrationValidateWhat = [passwordlessRegistrationValidateWhat];
+            }
+            const finalRegistrationVerificationSources = this.calculateVerificationSources(passwordlessRegistrationValidateWhat, signUpDto);
+            let user = existingUser;
+            if ((0, class_validator_1.isEmpty)(user)) {
+                user = this.createUser(signUpDto);
+                await this.populateVerificationTokens(finalRegistrationVerificationSources, user);
+                await this.userRepository.save(user);
+                await this.userService.addRoleToUser(user.username, this.settingService.getConfigValue('defaultRole'));
+            }
+            else {
+                await this.populateVerificationTokens(finalRegistrationVerificationSources, user);
+                await this.userRepository.save(user);
+            }
+            await this.notifyUserOnOtpInitiateRegistration(user, finalRegistrationVerificationSources);
+            return { message: success_messages_1.SUCCESS_MESSAGES.OTP_SENT_SUCCESS_REGISTRATION };
+        }
+        catch (err) {
+            const pgUniqueViolationErrorCode = '23505';
+            if (err.code === pgUniqueViolationErrorCode) {
+                throw new common_1.ConflictException(error_messages_1.ERROR_MESSAGES.USER_ALREADY_EXISTS);
+            }
+            throw err;
+        }
+    }
+    createUser(signUpDto) {
+        const user = new user_entity_1.User();
+        user.username = signUpDto.username;
+        user.email = signUpDto.email;
+        user.mobile = signUpDto.mobile;
+        user.customPayload = signUpDto.customPayload;
+        user.lastLoginProvider = LoginProvider.OTP;
+        return user;
+    }
+    calculateVerificationSources(configuredRegistrationValidationSources, signUpDto) {
+        const finalRegistrationValidationSources = configuredRegistrationValidationSources.filter((source) => source !== constants_1.RegistrationValidationSource.TRANSACTIONAL);
+        if (configuredRegistrationValidationSources.includes(constants_1.RegistrationValidationSource.TRANSACTIONAL)) {
+            finalRegistrationValidationSources.push(...signUpDto.validationSources);
+        }
+        return finalRegistrationValidationSources;
+    }
+    async populateVerificationTokens(finalRegistrationValidationSources, user) {
+        if (finalRegistrationValidationSources.length === 0) {
+            throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.VALIDATION_SOURCE_REQUIRED);
+        }
+        if (finalRegistrationValidationSources.includes(constants_1.TransactionalRegistrationValidationSource.EMAIL)) {
+            const { token, expiresAt } = await this.otp();
+            user.emailVerificationTokenOnRegistration = token;
+            user.emailVerificationTokenOnRegistrationExpiresAt = expiresAt;
+            const autoLoginUserOnRegistration = this.settingService.getConfigValue('autoLoginUserOnRegistration');
+            if (autoLoginUserOnRegistration) {
+                user.emailVerificationTokenOnLogin = token;
+                user.emailVerificationTokenOnLoginExpiresAt = expiresAt;
+            }
+        }
+        if (finalRegistrationValidationSources.includes(constants_1.TransactionalRegistrationValidationSource.MOBILE)) {
+            const { token, expiresAt } = await this.otp();
+            user.mobileVerificationTokenOnRegistration = token;
+            user.mobileVerificationTokenOnRegistrationExpiresAt = expiresAt;
+            const autoLoginUserOnRegistration = this.settingService.getConfigValue('autoLoginUserOnRegistration');
+            if (autoLoginUserOnRegistration) {
+                user.mobileVerificationTokenOnLogin = token;
+                user.mobileVerificationTokenOnLoginExpiresAt = expiresAt;
+            }
+        }
+    }
+    async notifyUserOnOtpInitiateRegistration(user, registrationValidationSources) {
+        const companyLogo = await this.getCompanyLogo();
+        const dummyOtp = this.settingService.getConfigValue('dummyOtp');
+        if (dummyOtp)
+            return;
+        if (registrationValidationSources.includes(constants_1.RegistrationValidationSource.EMAIL)) {
+            const mailService = this.mailServiceFactory.getMailService();
+            mailService.sendEmailUsingTemplate(user.email, 'otp-on-register', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                solidAppWebsiteUrl: this.settingService.getConfigValue('solidAppWebsiteUrl'),
+                firstName: user.username,
+                fullName: user.fullName ? user.fullName : user.username,
+                emailVerificationTokenOnRegistration: user.emailVerificationTokenOnRegistration,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueEmails'), null, null, 'user', user.id);
+        }
+        if (registrationValidationSources.includes(constants_1.RegistrationValidationSource.MOBILE)) {
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(user.mobile, 'otp-on-register', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                otp: user.mobileVerificationTokenOnRegistration,
+                mobileVerificationTokenOnRegistration: user.mobileVerificationTokenOnRegistration,
+                firstName: user.username,
+                fullName: user.fullName ? user.fullName : user.username,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueSms'));
+        }
+    }
+    async otpConfirmRegistration(confirmSignUpDto) {
+        const isPasswordlessRegistrationEnabled = await this.isPasswordlessRegistrationEnabled();
+        if (!isPasswordlessRegistrationEnabled) {
+            throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
+        }
+        if (confirmSignUpDto.type === constants_1.RegistrationValidationSource.EMAIL) {
+            const user = await this.userRepository.findOne({
+                where: {
+                    email: confirmSignUpDto.identifier,
+                }
+            });
+            if (!user) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_NOT_FOUND);
+            }
+            if (user.emailVerificationTokenOnRegistration !== confirmSignUpDto.otp) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_OTP);
+            }
+            if (user.emailVerificationTokenOnRegistrationExpiresAt < new Date()) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.OTP_EXPIRED);
+            }
+            user.emailVerifiedOnRegistrationAt = new Date();
+            user.emailVerificationTokenOnRegistration = null;
+            user.emailVerificationTokenOnRegistrationExpiresAt = null;
+            user.active = this.settingService.getConfigValue('activateUserOnRegistration') && await this.areRegistrationValidationSourcesVerified(user);
+            const savedUser = await this.userRepository.save(user);
+            this.triggerRegistrationEvent(savedUser);
+            return { active: savedUser.active, message: `User registration verified for ${confirmSignUpDto.type}` };
+        }
+        else if (confirmSignUpDto.type === constants_1.RegistrationValidationSource.MOBILE) {
+            const user = await this.userRepository.findOne({
+                where: {
+                    mobile: confirmSignUpDto.identifier,
+                }
+            });
+            if (!user) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_NOT_FOUND);
+            }
+            if (user.mobileVerificationTokenOnRegistration !== confirmSignUpDto.otp) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_OTP);
+            }
+            if (user.mobileVerificationTokenOnRegistrationExpiresAt < new Date()) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_OTP);
+            }
+            user.mobileVerifiedOnRegistrationAt = new Date();
+            user.mobileVerificationTokenOnRegistration = null;
+            user.mobileVerificationTokenOnRegistrationExpiresAt = null;
+            user.active = this.settingService.getConfigValue('activateUserOnRegistration') && await this.areRegistrationValidationSourcesVerified(user);
+            const savedUser = await this.userRepository.save(user);
+            this.triggerRegistrationEvent(savedUser);
+            return { active: savedUser.active, message: `User registration verified for ${confirmSignUpDto.type}` };
+        }
+        throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.INVALID_VERIFICATION_TYPE);
+    }
+    triggerRegistrationEvent(savedUser) {
+        const event = new interfaces_1.EventDetails(interfaces_1.EventType.USER_REGISTERED, savedUser);
+        this.eventEmitter.emit(interfaces_1.EventType.USER_REGISTERED, event);
+    }
+    async areRegistrationValidationSourcesVerified(user) {
+        const passwordlessRegistrationValidateWhat = this.settingService.getConfigValue('passwordlessRegistrationValidateWhat');
+        const registrationValidationSources = passwordlessRegistrationValidateWhat;
+        if (registrationValidationSources.includes(constants_1.RegistrationValidationSource.EMAIL)) {
+            if (!user.emailVerifiedOnRegistrationAt) {
+                return false;
+            }
+        }
+        if (registrationValidationSources.includes(constants_1.RegistrationValidationSource.MOBILE)) {
+            if (!user.mobileVerifiedOnRegistrationAt) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async otp() {
+        const now = new Date();
+        const otpExpiry = this.settingService.getConfigValue('otpExpiry');
+        const dummyOtp = this.settingService.getConfigValue('dummyOtp');
+        now.setMinutes(now.getMinutes() + otpExpiry);
+        return {
+            token: dummyOtp ? dummyOtp : (0, crypto_1.randomInt)(100000, 999999).toString(),
+            expiresAt: now,
+        };
+    }
+    async signIn(signInDto) {
+        const user = await this.validateUserAndRehashPasswordIfRequired(signInDto);
+        const tokens = await this.generateTokens(user);
+        await this.userActivityHistoryService.logEvent('login', user);
+        return {
+            user: {
+                email: user.email,
+                mobile: user.mobile,
+                username: user.username,
+                forcePasswordChange: user.forcePasswordChange,
+                id: user.id,
+                roles: user.roles.map((role) => role.name)
+            },
+            ...tokens
+        };
+    }
+    maskEmail(email) {
+        if (!email)
+            return null;
+        const [localPart, domain] = email.split('@');
+        if (localPart.length <= 2) {
+            return `${localPart[0]}***@${domain}`;
+        }
+        const visibleStart = localPart.slice(0, 2);
+        const visibleEnd = localPart.slice(-1);
+        return `${visibleStart}***${visibleEnd}@${domain}`;
+    }
+    maskMobile(mobile) {
+        if (!mobile)
+            return null;
+        if (mobile.length <= 4) {
+            return mobile;
+        }
+        const visibleEnd = mobile.slice(-4);
+        return `***${visibleEnd}`;
+    }
+    async otpInitiateLogin(signInDto) {
+        const isPasswordlessRegistrationEnabled = await this.isPasswordlessRegistrationEnabled();
+        if (!isPasswordlessRegistrationEnabled) {
+            throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
+        }
+        if (signInDto.type === constants_1.RegistrationValidationSource.EMAIL) {
+            const user = await this.userRepository.findOne({
+                where: [
+                    { username: signInDto.identifier },
+                    { email: signInDto.identifier },
+                ]
+            });
+            if (!user) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_NOT_FOUND);
+            }
+            if (!user.active) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_INACTIVE);
+            }
+            const { token, expiresAt } = await this.otp();
+            user.emailVerificationTokenOnLogin = token;
+            user.emailVerificationTokenOnLoginExpiresAt = expiresAt;
+            await this.userRepository.save(user);
+            this.notifyUserOnOtpInititateLogin(user, constants_1.RegistrationValidationSource.EMAIL);
+            return {
+                message: success_messages_1.SUCCESS_MESSAGES.OTP_SENT_SUCCESS_LOGIN,
+                user: {
+                    email: this.maskEmail(user.email)
+                }
+            };
+        }
+        else if (signInDto.type === constants_1.RegistrationValidationSource.MOBILE) {
+            const user = await this.userRepository.findOne({
+                where: [
+                    { username: signInDto.identifier },
+                    { mobile: signInDto.identifier },
+                ]
+            });
+            if (!user) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_NOT_FOUND);
+            }
+            const { token, expiresAt } = await this.otp();
+            user.mobileVerificationTokenOnLogin = token;
+            user.mobileVerificationTokenOnLoginExpiresAt = expiresAt;
+            await this.userRepository.save(user);
+            this.notifyUserOnOtpInititateLogin(user, constants_1.RegistrationValidationSource.MOBILE);
+            return {
+                message: success_messages_1.SUCCESS_MESSAGES.OTP_SENT_SUCCESS_LOGIN,
+                user: {
+                    mobile: this.maskMobile(user.mobile)
+                }
+            };
+        }
+        else {
+            throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.INVALID_VERIFICATION_TYPE);
+        }
+    }
+    async notifyUserOnOtpInititateLogin(user, loginType) {
+        const companyLogo = await this.getCompanyLogo();
+        const dummyOtp = this.settingService.getConfigValue('dummyOtp');
+        if (dummyOtp)
+            return;
+        if (loginType === constants_1.RegistrationValidationSource.EMAIL) {
+            const mailService = this.mailServiceFactory.getMailService();
+            mailService.sendEmailUsingTemplate(user.email, 'otp-on-login', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                solidAppWebsiteUrl: this.settingService.getConfigValue('solidAppWebsiteUrl'),
+                firstName: user.username,
+                emailVerificationTokenOnLogin: user.emailVerificationTokenOnLogin,
+                fullName: user.fullName ? user.fullName : user.username,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueEmails'), null, null, 'user', user.id);
+        }
+        if (loginType === constants_1.RegistrationValidationSource.MOBILE) {
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(user.mobile, 'otp-on-login', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                otp: user.mobileVerificationTokenOnLogin,
+                mobileVerificationTokenOnLogin: user.mobileVerificationTokenOnLogin,
+                firstName: user.username,
+                fullName: user.fullName ? user.fullName : user.username,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueSms'));
+        }
+    }
+    async otpConfirmLogin(confirmSignInDto) {
+        const isPasswordlessRegistrationEnabled = await this.isPasswordlessRegistrationEnabled();
+        if (!isPasswordlessRegistrationEnabled) {
+            throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
+        }
+        if (confirmSignInDto.type === constants_1.RegistrationValidationSource.EMAIL) {
+            const user = await this.userRepository.findOne({
+                where: [
+                    { username: confirmSignInDto.identifier },
+                    { email: confirmSignInDto.identifier },
+                ],
+                relations: {
+                    roles: true
+                }
+            });
+            if (!user) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_NOT_FOUND);
+            }
+            if (!user.active) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_INACTIVE);
+            }
+            if (user.emailVerificationTokenOnLogin !== confirmSignInDto.otp) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_OTP);
+            }
+            if (user.emailVerificationTokenOnLoginExpiresAt < new Date()) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_OTP);
+            }
+            user.emailVerifiedOnLoginAt = new Date();
+            user.emailVerificationTokenOnLogin = null;
+            user.emailVerificationTokenOnLoginExpiresAt = null;
+            await this.userRepository.save(user);
+            const { accessToken, refreshToken } = await this.generateTokens(user);
+            const { id, username, email, mobile, lastLoginProvider } = user;
+            const roles = user.roles.map((role) => role.name);
+            return { accessToken, refreshToken, user: { id, username, email, mobile, lastLoginProvider, roles } };
+        }
+        else if (confirmSignInDto.type === constants_1.RegistrationValidationSource.MOBILE) {
+            const user = await this.userRepository.findOne({
+                where: [
+                    { username: confirmSignInDto.identifier },
+                    { mobile: confirmSignInDto.identifier },
+                ],
+                relations: {
+                    roles: true
+                }
+            });
+            if (!user) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_NOT_ACTIVE);
+            }
+            if (!user.active) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_INACTIVE);
+            }
+            if (user.mobileVerificationTokenOnLogin !== confirmSignInDto.otp) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_OTP);
+            }
+            if (user.mobileVerificationTokenOnLoginExpiresAt < new Date()) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_OTP);
+            }
+            user.mobileVerifiedOnLoginAt = new Date();
+            user.mobileVerificationTokenOnLogin = null;
+            user.mobileVerificationTokenOnLoginExpiresAt = null;
+            await this.userRepository.save(user);
+            const { accessToken, refreshToken } = await this.generateTokens(user);
+            const { id, username, email, mobile, lastLoginProvider } = user;
+            const roles = user.roles.map((role) => role.name);
+            return { accessToken, refreshToken, user: { id, username, email, mobile, lastLoginProvider, roles } };
+        }
+        throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.INVALID_VERIFICATION_TYPE);
+    }
+    async changePassword(changePasswordDto, activeUser) {
+        const user = await this.userRepository.findOne({
+            where: { id: changePasswordDto.id }
+        });
+        if (!user) {
+            throw new common_1.NotFoundException(error_messages_1.ERROR_MESSAGES.USER_NOT_FOUND);
+        }
+        if (!user.active) {
+            throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.USER_INACTIVE);
+        }
+        if (user.lastLoginProvider !== 'local') {
+            throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.NON_LOCAL_PROVIDER);
+        }
+        if (!(user.id === activeUser.sub)) {
+            throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.USER_ID_MISMATCH);
+        }
+        if (!(user.username === activeUser.username)) {
+            throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.USERNAME_MISMATCH);
+        }
+        const isEqual = await this.hashingService.compare(changePasswordDto.currentPassword, user.password, user.passwordSchemeVersion);
+        if (!isEqual) {
+            throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INCORRECT_CURRENT_PASSWORD);
+        }
+        const pwdData = await this.userService.hashPassword(changePasswordDto.newPassword);
+        user.password = changePasswordDto.newPassword;
+        user.password = pwdData.password;
+        user.passwordScheme = pwdData.passwordScheme;
+        user.passwordSchemeVersion = pwdData.passwordSchemeVersion;
+        user.forcePasswordChange = false;
+        await this.userRepository.save(user);
+        return true;
+    }
+    async generateForgotPasswordToken() {
+        const expiryTime = new Date();
+        const forgotPasswordVerificationTokenExpiry = this.settingService.getConfigValue('forgotPasswordVerificationTokenExpiry');
+        const dummyOtp = this.settingService.getConfigValue('dummyOtp');
+        expiryTime.setMinutes(expiryTime.getMinutes() + forgotPasswordVerificationTokenExpiry);
+        return {
+            token: dummyOtp
+                ? dummyOtp
+                : (0, uuid_1.v4)(),
+            expiresAt: expiryTime,
+        };
+    }
+    async initiateForgotPassword(initiateForgotPasswordDto) {
+        const user = await this.resolveUser(initiateForgotPasswordDto.username, initiateForgotPasswordDto.email);
+        let isValidUser = true;
+        if (!user) {
+            isValidUser = false;
+        }
+        if (isValidUser && !user?.active) {
+            isValidUser = false;
+        }
+        if (isValidUser && user?.lastLoginProvider !== 'local') {
+            isValidUser = false;
+        }
+        if (isValidUser) {
+            const { token, expiresAt } = await this.generateForgotPasswordToken();
+            user.verificationTokenOnForgotPassword = token;
+            user.verificationTokenOnForgotPasswordExpiresAt = expiresAt;
+            await this.userRepository.save(user);
+            await this.notifyUserOnForgotPassword(user);
+        }
+        return {
+            status: 'success',
+            message: success_messages_1.SUCCESS_MESSAGES.FORGOT_PASSWORD_TOKEN_SENT,
+            error: '',
+            errorCode: '',
+            data: {
+                user: {
+                    email: user?.email,
+                },
+            }
+        };
+    }
+    async notifyUserOnForgotPassword(user) {
+        const companyLogo = await this.getCompanyLogo();
+        const forgotPasswordSendVerificationTokenOn = this.settingService.getConfigValue('forgotPasswordSendVerificationTokenOn');
+        if (forgotPasswordSendVerificationTokenOn == constants_1.ForgotPasswordSendVerificationTokenOn.EMAIL) {
+            const mailService = this.mailServiceFactory.getMailService();
+            mailService.sendEmailUsingTemplate(user.email, 'forgot-password', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                solidAppWebsiteUrl: this.settingService.getConfigValue('solidAppWebsiteUrl'),
+                firstName: user.username,
+                fullName: user.fullName,
+                passwordResetLink: `${this.settingService.getConfigValue('frontendForgotPasswordPageUrl')}?token=${user.verificationTokenOnForgotPassword}`,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueEmails'), null, null, 'user', user.id);
+        }
+        if (forgotPasswordSendVerificationTokenOn == constants_1.ForgotPasswordSendVerificationTokenOn.MOBILE && user.mobile) {
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(user.mobile, 'forgot-password', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                otp: user.verificationTokenOnForgotPassword,
+                verificationTokenOnForgotPassword: user.verificationTokenOnForgotPassword,
+                firstName: user.username,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueSms'));
+        }
+    }
+    async confirmForgotPassword(confirmForgotPasswordDto) {
+        return this.dataSource.transaction(async (m) => {
+            const user = await this.resolveUserByVerificationToken(confirmForgotPasswordDto.verificationToken);
+            if (!user)
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_CREDENTIALS);
+            if (user.lastLoginProvider !== 'local')
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_CREDENTIALS);
+            if (!user.active)
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_CREDENTIALS);
+            const { affected } = await m
+                .createQueryBuilder()
+                .update(user_entity_1.User)
+                .set({
+                forgotPasswordConfirmedAt: () => 'NOW()',
+                verificationTokenOnForgotPassword: () => 'NULL',
+                verificationTokenOnForgotPasswordExpiresAt: () => 'NULL',
+            })
+                .where('id = :id', { id: user.id })
+                .andWhere('verificationTokenOnForgotPassword = :token', { token: confirmForgotPasswordDto.verificationToken })
+                .andWhere('verificationTokenOnForgotPasswordExpiresAt > NOW()')
+                .execute();
+            if (affected !== 1) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_CREDENTIALS);
+            }
+            const pwdHash = await this.hashingService.hash(confirmForgotPasswordDto.password);
+            const pwdScheme = this.hashingService.name();
+            const pwdSchemeVersion = this.hashingService.currentVersion();
+            await m.getRepository(user_entity_1.User).update({ id: user.id }, { password: pwdHash, passwordScheme: pwdScheme, passwordSchemeVersion: pwdSchemeVersion });
+            await this.notifyUserOnPasswordChanged(user);
+            return {
+                status: 'success',
+                message: success_messages_1.SUCCESS_MESSAGES.FORGOT_PASSWORD_CONFIRMED,
+                error: '',
+                errorCode: '',
+                data: {},
+            };
+        });
+    }
+    async notifyUserOnPasswordChanged(user) {
+        const companyLogo = await this.getCompanyLogo();
+        const forgotPasswordSendVerificationTokenOn = this.settingService.getConfigValue('forgotPasswordSendVerificationTokenOn');
+        if (forgotPasswordSendVerificationTokenOn == constants_1.ForgotPasswordSendVerificationTokenOn.EMAIL) {
+            const mailService = this.mailServiceFactory.getMailService();
+            mailService.sendEmailUsingTemplate(user.email, 'password-changed', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                solidAppWebsiteUrl: this.settingService.getConfigValue('solidAppWebsiteUrl'),
+                email: user.email,
+                firstName: user.username,
+                fullName: user.fullName,
+                passwordResetLink: `${this.settingService.getConfigValue('frontendForgotPasswordPageUrl')}?token=${user.verificationTokenOnForgotPassword}`,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueEmails'), null, null, 'user', user.id);
+        }
+        if (forgotPasswordSendVerificationTokenOn == constants_1.ForgotPasswordSendVerificationTokenOn.MOBILE && user.mobile) {
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(user.mobile, 'forgot-password', {
+                solidAppName: this.settingService.getConfigValue('appTitle'),
+                otp: user.verificationTokenOnForgotPassword,
+                verificationTokenOnForgotPassword: user.verificationTokenOnForgotPassword,
+                firstName: user.username,
+                companyLogoUrl: companyLogo
+            }, this.settingService.getConfigValue('shouldQueueSms'));
+        }
+    }
+    async generateTokens(user) {
+        const [accessToken, refreshToken] = await Promise.all([
+            await this.generateAccessToken(user),
+            await this.generateRefreshToken(user),
+        ]);
+        return {
+            accessToken,
+            refreshToken,
+        };
+    }
+    async generateAccessToken(user) {
+        const userRoleNames = user.roles.map((role) => role.name);
+        const accessTokenTtl = this.settingService.getConfigValue("accessTokenTtl");
+        const accessToken = await this.signToken(user.id, accessTokenTtl, { username: user.username, email: user.email, roles: userRoleNames });
+        return accessToken;
+    }
+    async generateRefreshToken(user, previousRefreshToken) {
+        const refreshTokenId = (0, crypto_1.randomUUID)();
+        const refreshTokenTtl = this.settingService.getConfigValue("refreshTokenTtl");
+        const refreshToken = await this.signToken(user.id, refreshTokenTtl, {
+            refreshTokenId,
+        });
+        await this.refreshTokenIdsStorage.insert(user.id, refreshToken, previousRefreshToken);
+        return refreshToken;
+    }
+    async refreshTokens(refreshTokenDto) {
+        try {
+            const secret = this.settingService.getConfigValue("secret");
+            const audience = this.settingService.getConfigValue("audience");
+            const issuer = this.settingService.getConfigValue("issuer");
+            const { sub } = await this.jwtService.verifyAsync(refreshTokenDto.refreshToken, {
+                secret,
+                audience,
+                issuer,
+            });
+            const user = await this.userRepository.findOne({
+                where: {
+                    id: sub,
+                },
+                relations: {
+                    roles: true
+                }
+            });
+            if (!user) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.SESSION_INVALID);
+            }
+            const currentRefreshToken = await this.refreshTokenIdsStorage.validateAndRotate(user, refreshTokenDto.refreshToken);
+            await this.userActivityHistoryService.logEvent('tokenRefreshed', user);
+            return {
+                accessToken: await this.generateAccessToken(user),
+                refreshToken: currentRefreshToken,
+            };
+        }
+        catch (err) {
+            if (err instanceof refresh_token_ids_storage_service_1.InvalidatedRefreshTokenError) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.ACCESS_DENIED);
+            }
+            throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.SESSION_EXPIRED);
+        }
+    }
+    async signToken(userId, expiresIn, payload) {
+        const audience = this.settingService.getConfigValue("audience");
+        const issuer = this.settingService.getConfigValue("issuer");
+        const secret = this.settingService.getConfigValue("secret");
+        return await this.jwtService.signAsync({
+            sub: userId,
+            ...payload,
+        }, {
+            audience,
+            issuer,
+            secret,
+            expiresIn,
+        });
+    }
+    async validateUserUsingGoogle(user) {
+        try {
+            const response = await this.httpService.axiosRef.get(`https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token=${user.googleAccessToken}`);
+            const userProfile = response.data;
+            if (userProfile.email === user.email && userProfile.id === user.googleId) {
+                return userProfile;
+            }
+            else {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_USER_PROFILE);
+            }
+        }
+        catch (error) {
+            throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.GOOGLE_OAUTH_PROFILE_FETCH_FAILED);
+        }
+    }
+    async signInUsingGoogle(accessCode) {
+        const user = await this.userRepository.findOne({
+            where: {
+                accessCode: accessCode
+            },
+            relations: {
+                roles: true
+            }
+        });
+        await this.validateUserUsingGoogle(user);
+        const tokens = await this.generateTokens(user);
+        return {
+            user: {
+                email: user.email,
+                mobile: user.mobile,
+                username: user.username,
+                id: user.id,
+                roles: user.roles.map((role) => role.name)
+            },
+            ...tokens
+        };
+    }
+    async isPasswordlessRegistrationEnabled() {
+        return this.settingService.getConfigValue('passwordLessAuth');
+    }
+    async logout(refreshToken) {
+        try {
+            const payload = this.jwtService.decode(refreshToken);
+            if (!payload || !payload.sub) {
+                throw new common_1.UnauthorizedException(error_messages_1.ERROR_MESSAGES.INVALID_REFRESH_TOKEN);
+            }
+            const userId = payload.sub;
+            await this.refreshTokenIdsStorage.invalidate(userId);
+            const user = await this.userRepository.findOne({
+                where: {
+                    id: userId,
+                }
+            });
+            await this.userActivityHistoryService.logEvent('logout', user);
+            return { message: success_messages_1.SUCCESS_MESSAGES.LOGOUT_SUCCESS };
+        }
+        catch (err) {
+            throw err instanceof common_1.UnauthorizedException || err instanceof common_1.InternalServerErrorException
+                ? err
+                : new common_1.InternalServerErrorException(error_messages_1.ERROR_MESSAGES.LOGOUT_FAILED);
+        }
+    }
+    async activateUser(userId) {
+        const user = await this.userService.findOne(userId, {});
+        if (!user) {
+            throw new common_1.NotFoundException(error_messages_1.ERROR_MESSAGES.USER_NOT_FOUND);
+        }
+        user.active = true;
+        await this.userRepository.save(user);
+    }
+    async me(activeUser) {
+        const user = await this.userRepository.findOne({
+            where: {
+                id: activeUser.sub,
+            },
+            relations: {
+                roles: true
+            }
+        });
+        const refreshTokenState = await this.refreshTokenIdsStorage.getCurrentRefreshTokenState(user.id);
+        const response = {
+            user: {
+                email: user.email,
+                mobile: user.mobile,
+                username: user.username,
+                id: user.id,
+                roles: user.roles.map((role) => role.name)
+            },
+            refreshToken: refreshTokenState.currentRefreshToken,
+        };
+        return response;
+    }
+};
+exports.AuthenticationService = AuthenticationService;
+exports.AuthenticationService = AuthenticationService = AuthenticationService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(12, (0, typeorm_1.InjectDataSource)()),
+    __metadata("design:paramtypes", [user_service_1.UserService,
+        user_repository_1.UserRepository,
+        hashing_service_1.HashingService,
+        jwt_1.JwtService,
+        refresh_token_ids_storage_service_1.RefreshTokenIdsStorageService,
+        axios_1.HttpService,
+        mail_factory_1.MailFactory,
+        sms_factory_1.SmsFactory,
+        event_emitter_1.EventEmitter2,
+        setting_service_1.SettingService,
+        role_metadata_service_1.RoleMetadataService,
+        user_activity_history_service_1.UserActivityHistoryService,
+        typeorm_2.DataSource])
+], AuthenticationService);
+function parseUniqueConstraintError(detail) {
+    const match = detail.match(/Key \(([^)]+)\)=\(([^)]+)\) already exists\./);
+    if (match) {
+        const field = match[1];
+        const value = match[2];
+        const fieldMap = {
+            username: 'username',
+            email: 'email address',
+            full_name_user_key: 'full name',
+        };
+        const friendlyField = fieldMap[field] || field;
+        return `A user with ${friendlyField} "${value}" already exists.`;
+    }
+    return detail;
+}
+//# sourceMappingURL=authentication.service.js.map