@flusys/nestjs-auth 3.0.0 → 4.0.0-rc

package/fesm/services/authentication.service.js

@@ -26,14 +26,21 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { HybridCache } from '@flusys/nestjs-shared/classes';
-import { ErrorHandler, generateUniqueSlug } from '@flusys/nestjs-shared/utils';
-import { BadRequestException, Inject, Injectable, Logger, NotFoundException, Optional, Scope, UnauthorizedException } 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 { INotificationAdapter, NOTIFICATION_ADAPTER } from '@flusys/nestjs-shared/interfaces';
+import { NotificationType } from '@flusys/nestjs-shared/enums';
+import { generateUniqueSlug } from '@flusys/nestjs-shared/utils';
+import { BadRequestException, Inject, Injectable, InternalServerErrorException, NotFoundException, Optional, Scope, UnauthorizedException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import * as bcrypt from 'bcrypt';
 import { BCRYPT_SALT_ROUNDS, TOKEN_REVOKED_PREFIX, USER_ENRICHER } from '../config';
 import { IUserEnricher } from '../interfaces/user-enricher.interface';
+import { RegistrationDto } from '../dtos/authentication.dto';
 import { CompanyBranch } from '../entities/company-branch.entity';
 import { Company } from '../entities/company.entity';
+import { PendingRegistration } from '../entities/pending-registration.entity';
 import { UserCompanyPermission } from '../entities/user-company-permission.entity';
 import { User } from '../entities/user.entity';
 import { PermissionType } from '../enums';
@@ -52,7 +59,10 @@ export class AuthenticationService {
     }
     async getUserRepository() {
         if (!this.dataSourceProvider) {
-            throw new Error('User repository not available');
+            throw new InternalServerErrorException({
+                message: 'User repository not available',
+                messageKey: SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE
+            });
         }
         return this.dataSourceProvider.getRepository(User);
     }
@@ -73,24 +83,29 @@ export class AuthenticationService {
             return {
                 requiresEmailVerification: true,
                 email,
-                message: 'Please verify your email address to complete registration.'
+                message: 'Please verify your email address to complete registration.',
+                messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SENT
             };
         }
         const user = await this.validateUser(email, password);
         if (!user.isActive) {
-            throw new UnauthorizedException('User account is deactivated');
+            throw new UnauthorizedException({
+                message: 'User account is deactivated',
+                messageKey: AUTH_MESSAGES.LOGIN_ACCOUNT_DEACTIVATED
+            });
         }
         if (this.isEmailVerificationEnabled() && !user.emailVerified) {
             return {
                 requiresEmailVerification: true,
                 email: user.email,
-                message: 'Please verify your email address before logging in.'
+                message: 'Please verify your email address before logging in.',
+                messageKey: AUTH_MESSAGES.LOGIN_EMAIL_NOT_VERIFIED
             };
         }
         if (!this.isCompanyFeatureEnabled()) {
             return this.generateLoginResponse(user);
         }
-        return this.handleCompanyBasedLogin(user);
+        return await this.handleCompanyBasedLogin(user);
     }
     async handleCompanyBasedLogin(user) {
         const permissionRepository = await this.getPermissionRepository();
@@ -142,10 +157,13 @@ export class AuthenticationService {
             }
         });
         if (existingUser && this.isCompanyFeatureEnabled()) {
-            return this.handleExistingUserCompanyRegistration(existingUser, dto);
+            return await this.handleExistingUserCompanyRegistration(existingUser, dto);
         }
         if (existingUser) {
-            throw new BadRequestException('Registration failed due to email exists. Please try again or contact support.');
+            throw new BadRequestException({
+                message: 'Registration failed due to email exists. Please try again or contact support.',
+                messageKey: AUTH_MESSAGES.REGISTER_EMAIL_EXISTS
+            });
         }
         if (this.isEmailVerificationEnabled() && verifyUrlBase) {
             const companyData = this.isCompanyFeatureEnabled() ? {
@@ -166,19 +184,26 @@ export class AuthenticationService {
             });
             return {
                 requiresEmailVerification: true,
-                message: result.message
+                message: result.message,
+                messageKey: EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SENT
             };
         }
-        return this.createUserDirectly(dto);
+        return await this.createUserDirectly(dto);
     }
     async handleExistingUserCompanyRegistration(existingUser, dto) {
         if (!dto.companySlug && !dto.newCompanyName) {
-            throw new BadRequestException('Email already registered. Please login or provide a company to join/create.');
+            throw new BadRequestException({
+                message: 'Email already registered. Please login or provide a company to join/create.',
+                messageKey: AUTH_MESSAGES.REGISTER_EMAIL_EXISTS
+            });
         }
         const permissionRepository = await this.getPermissionRepository();
         const companyRepository = await this.getCompanyRepository();
         if (!permissionRepository || !companyRepository) {
-            throw new BadRequestException('Company feature repositories not available');
+            throw new BadRequestException({
+                message: 'Company feature repositories not available',
+                messageKey: SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE
+            });
         }
         if (dto.companySlug) {
             const company = await companyRepository.findOne({
@@ -196,15 +221,21 @@ export class AuthenticationService {
                     }
                 });
                 if (existingPermission) {
-                    throw new BadRequestException('You are already assigned to this company. Please login.');
+                    throw new BadRequestException({
+                        message: 'You are already assigned to this company. Please login.',
+                        messageKey: AUTH_MESSAGES.REGISTER_COMPANY_ALREADY_ASSIGNED
+                    });
                 }
             }
         }
-        return this.processCompanyRegistration(existingUser, dto, true);
+        return await this.processCompanyRegistration(existingUser, dto, true);
     }
     async createUserDirectly(dto) {
         if (!this.dataSourceProvider) {
-            throw new BadRequestException('Data source not available');
+            throw new BadRequestException({
+                message: 'Data source not available',
+                messageKey: SYSTEM_MESSAGES.DATASOURCE_NOT_AVAILABLE
+            });
         }
         const dataSource = await this.dataSourceProvider.getDataSource();
         const queryRunner = dataSource.createQueryRunner();
@@ -229,21 +260,26 @@ export class AuthenticationService {
             if (!this.isCompanyFeatureEnabled()) {
                 return this.generateRegistrationResponse(user);
             }
-            return this.processCompanyRegistration(user, dto);
+            return await this.processCompanyRegistration(user, dto);
         } catch (error) {
             await queryRunner.rollbackTransaction();
             if (error instanceof BadRequestException) {
                 throw error;
             }
-            ErrorHandler.logError(this.logger, error, 'createUserDirectly');
-            throw new BadRequestException('Registration failed. Please try again.');
+            throw new BadRequestException({
+                message: 'Registration failed. Please try again.',
+                messageKey: AUTH_MESSAGES.REGISTER_FAILED
+            });
         } finally{
             await queryRunner.release();
         }
     }
     async createUserFromPendingRegistration(pending) {
         if (!this.dataSourceProvider) {
-            throw new BadRequestException('Data source not available');
+            throw new BadRequestException({
+                message: 'Data source not available',
+                messageKey: SYSTEM_MESSAGES.DATASOURCE_NOT_AVAILABLE
+            });
         }
         const dataSource = await this.dataSourceProvider.getDataSource();
         const queryRunner = dataSource.createQueryRunner();
@@ -256,7 +292,10 @@ export class AuthenticationService {
                 }
             });
             if (existingUser) {
-                throw new BadRequestException('This email has already been registered.');
+                throw new BadRequestException({
+                    message: 'This email has already been registered.',
+                    messageKey: AUTH_MESSAGES.REGISTER_EMAIL_EXISTS
+                });
             }
             const user = queryRunner.manager.create(User, {
                 name: pending.name,
@@ -273,7 +312,7 @@ export class AuthenticationService {
             }
             await queryRunner.commitTransaction();
             if (this.isCompanyFeatureEnabled() && pending.companyData) {
-                return this.processCompanyRegistration(user, pending.companyData);
+                return await this.processCompanyRegistration(user, pending.companyData);
             }
             return this.generateRegistrationResponse(user);
         } catch (error) {
@@ -281,8 +320,10 @@ export class AuthenticationService {
             if (error instanceof BadRequestException) {
                 throw error;
             }
-            ErrorHandler.logError(this.logger, error, 'createUserFromPendingRegistration');
-            throw new BadRequestException('Registration failed. Please try again.');
+            throw new BadRequestException({
+                message: 'Registration failed. Please try again.',
+                messageKey: AUTH_MESSAGES.REGISTER_FAILED
+            });
         } finally{
             await queryRunner.release();
         }
@@ -292,7 +333,10 @@ export class AuthenticationService {
         const branchRepository = await this.getBranchRepository();
         const permissionRepository = await this.getPermissionRepository();
         if (!companyRepository || !branchRepository || !permissionRepository) {
-            if (throwOnUnavailable) throw new BadRequestException('Company feature repositories not available');
+            if (throwOnUnavailable) throw new BadRequestException({
+                message: 'Company feature repositories not available',
+                messageKey: SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE
+            });
             return this.generateRegistrationResponse(user);
         }
         const { company, branch } = await this.findOrCreateCompanyAndBranch(data, companyRepository, branchRepository);
@@ -310,7 +354,10 @@ export class AuthenticationService {
                     isActive: true
                 }
             });
-            if (!company) throw new BadRequestException('Company not found or inactive');
+            if (!company) throw new BadRequestException({
+                message: 'Company not found or inactive',
+                messageKey: AUTH_MESSAGES.COMPANY_NOT_FOUND
+            });
             const branch = data.branchSlug ? await branchRepo.findOne({
                 where: {
                     slug: data.branchSlug,
@@ -327,7 +374,10 @@ export class AuthenticationService {
                     createdAt: 'ASC'
                 }
             });
-            if (data.branchSlug && !branch) throw new BadRequestException('Branch not found or inactive');
+            if (data.branchSlug && !branch) throw new BadRequestException({
+                message: 'Branch not found or inactive',
+                messageKey: AUTH_MESSAGES.BRANCH_NOT_FOUND
+            });
             return {
                 company,
                 branch
@@ -383,17 +433,23 @@ export class AuthenticationService {
     async select(sessionId, companyId, branchId) {
         this.ensureCompanyFeatureEnabled();
         if (!this.sessionService) {
-            throw new BadRequestException('Session service not available');
+            throw new BadRequestException({
+                message: 'Session service not available',
+                messageKey: AUTH_MESSAGES.SESSION_NOT_AVAILABLE
+            });
         }
         const session = await this.sessionService.consumeSession(sessionId);
         if (!session) {
-            throw new UnauthorizedException('Invalid or expired session');
+            throw new UnauthorizedException({
+                message: 'Invalid or expired session',
+                messageKey: AUTH_MESSAGES.SESSION_INVALID
+            });
         }
-        return this.validateAndLoginWithCompany(session.userId, companyId, branchId);
+        return await this.validateAndLoginWithCompany(session.userId, companyId, branchId);
     }
     async switchCompany(userId, companyId, branchId) {
         this.ensureCompanyFeatureEnabled();
-        return this.validateAndLoginWithCompany(userId, companyId, branchId);
+        return await this.validateAndLoginWithCompany(userId, companyId, branchId);
     }
     async validateAndLoginWithCompany(userId, companyId, branchId) {
         const userRepository = await this.getUserRepository();
@@ -403,13 +459,19 @@ export class AuthenticationService {
             }
         });
         if (!user) {
-            throw new NotFoundException('User not found');
+            throw new NotFoundException({
+                message: 'User not found',
+                messageKey: USER_MESSAGES.NOT_FOUND
+            });
         }
         const permissionRepository = await this.getPermissionRepository();
         const companyRepository = await this.getCompanyRepository();
         const branchRepository = await this.getBranchRepository();
         if (!permissionRepository || !companyRepository || !branchRepository) {
-            throw new BadRequestException('Repositories not available');
+            throw new BadRequestException({
+                message: 'Repositories not available',
+                messageKey: SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE
+            });
         }
         const hasCompanyAccess = await permissionRepository.findOne({
             where: {
@@ -419,7 +481,10 @@ export class AuthenticationService {
             }
         });
         if (!hasCompanyAccess) {
-            throw new UnauthorizedException('No access to this company');
+            throw new UnauthorizedException({
+                message: 'No access to this company',
+                messageKey: AUTH_MESSAGES.COMPANY_NO_ACCESS
+            });
         }
         const company = await companyRepository.findOne({
             where: {
@@ -428,7 +493,10 @@ export class AuthenticationService {
             }
         });
         if (!company) {
-            throw new UnauthorizedException('Company not found or inactive');
+            throw new UnauthorizedException({
+                message: 'Company not found or inactive',
+                messageKey: AUTH_MESSAGES.COMPANY_NOT_FOUND
+            });
         }
         const hasBranchAccess = await permissionRepository.findOne({
             where: {
@@ -438,7 +506,10 @@ export class AuthenticationService {
             }
         });
         if (!hasBranchAccess) {
-            throw new UnauthorizedException('No access to this branch');
+            throw new UnauthorizedException({
+                message: 'No access to this branch',
+                messageKey: AUTH_MESSAGES.BRANCH_NO_ACCESS
+            });
         }
         const branch = await branchRepository.findOne({
             where: {
@@ -448,7 +519,10 @@ export class AuthenticationService {
             }
         });
         if (!branch) {
-            throw new UnauthorizedException('Branch not found or inactive');
+            throw new UnauthorizedException({
+                message: 'Branch not found or inactive',
+                messageKey: AUTH_MESSAGES.BRANCH_NOT_FOUND
+            });
         }
         return this.generateLoginResponseWithCompany(user, company, branch);
     }
@@ -458,7 +532,10 @@ export class AuthenticationService {
                 secret: this.authConfig.getRefreshTokenSecret()
             });
             if (await this.isTokenRevoked(payload.id, payload.iat)) {
-                throw new UnauthorizedException('Token has been revoked');
+                throw new UnauthorizedException({
+                    message: 'Token has been revoked',
+                    messageKey: AUTH_MESSAGES.TOKEN_REVOKED
+                });
             }
             const userRepository = await this.getUserRepository();
             const user = await userRepository.findOne({
@@ -467,7 +544,10 @@ export class AuthenticationService {
                 }
             });
             if (!user || !user.isActive) {
-                throw new UnauthorizedException('Invalid refresh token');
+                throw new UnauthorizedException({
+                    message: 'Invalid refresh token',
+                    messageKey: AUTH_MESSAGES.TOKEN_INVALID
+                });
             }
             return this.generateTokens({
                 id: user.id,
@@ -481,9 +561,11 @@ export class AuthenticationService {
                     branchId: payload.branchId
                 }
             });
-        } catch (error) {
-            ErrorHandler.logError(this.logger, error, 'refreshToken');
-            throw new UnauthorizedException('Invalid or expired refresh token');
+        } catch  {
+            throw new UnauthorizedException({
+                message: 'Invalid or expired refresh token',
+                messageKey: AUTH_MESSAGES.TOKEN_EXPIRED
+            });
         }
     }
     async changePassword(userId, currentPassword, newPassword) {
@@ -493,24 +575,31 @@ export class AuthenticationService {
                 id: userId
             }
         });
-        if (!user) throw new UnauthorizedException('User not found');
+        if (!user) throw new UnauthorizedException({
+            message: 'User not found',
+            messageKey: USER_MESSAGES.NOT_FOUND
+        });
         if (!await bcrypt.compare(currentPassword, user.password || '')) {
-            throw new UnauthorizedException('Current password is incorrect');
+            throw new UnauthorizedException({
+                message: 'Current password is incorrect',
+                messageKey: AUTH_MESSAGES.PASSWORD_CHANGE_INVALID_CURRENT
+            });
         }
         user.password = await bcrypt.hash(newPassword, BCRYPT_SALT_ROUNDS);
         await userRepository.save(user);
     }
     async logout(userId) {
         if (!this.cacheManager) {
-            this.logger.error(`SECURITY: Cache not available for logout (userId: ${userId}). ` + 'Token revocation failed - tokens will remain valid until expiry. ' + 'Configure cache (Redis) to enable proper token revocation.');
-            throw new BadRequestException('Logout service temporarily unavailable. Please try again later.');
+            throw new BadRequestException({
+                message: 'Logout service temporarily unavailable. Please try again later.',
+                messageKey: AUTH_MESSAGES.LOGOUT_SERVICE_UNAVAILABLE
+            });
         }
         const revokedAt = Math.floor(Date.now() / 1000);
         const cacheKey = `${TOKEN_REVOKED_PREFIX}:${userId}`;
         const refreshTokenExpiry = this.authConfig.getRefreshTokenExpiration();
         const ttlMs = this.parseExpiryToMs(refreshTokenExpiry);
         await this.cacheManager.set(cacheKey, revokedAt, ttlMs);
-        this.logger.log(`User ${userId} logged out - all tokens revoked`);
     }
     async isTokenRevoked(userId, tokenIssuedAt) {
         if (!this.cacheManager || !tokenIssuedAt) {
@@ -546,7 +635,10 @@ export class AuthenticationService {
         const permissionRepository = await this.getPermissionRepository();
         const companyRepository = await this.getCompanyRepository();
         if (!permissionRepository || !companyRepository) {
-            throw new BadRequestException('Repositories not available');
+            throw new BadRequestException({
+                message: 'Repositories not available',
+                messageKey: SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE
+            });
         }
         const permissions = await permissionRepository.find({
             where: {
@@ -567,7 +659,10 @@ export class AuthenticationService {
         const permissionRepository = await this.getPermissionRepository();
         const branchRepository = await this.getBranchRepository();
         if (!permissionRepository || !branchRepository) {
-            throw new BadRequestException('Repositories not available');
+            throw new BadRequestException({
+                message: 'Repositories not available',
+                messageKey: SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE
+            });
         }
         const companyPermission = await permissionRepository.findOne({
             where: {
@@ -577,7 +672,10 @@ export class AuthenticationService {
             }
         });
         if (!companyPermission) {
-            throw new UnauthorizedException('No access to this company');
+            throw new UnauthorizedException({
+                message: 'No access to this company',
+                messageKey: AUTH_MESSAGES.COMPANY_NO_ACCESS
+            });
         }
         const branchPermissions = await permissionRepository.find({
             where: {
@@ -624,20 +722,32 @@ export class AuthenticationService {
                 id: userId
             }
         });
-        if (!user) throw new UnauthorizedException('User not found');
+        if (!user) throw new UnauthorizedException({
+            message: 'User not found',
+            messageKey: USER_MESSAGES.NOT_FOUND
+        });
         const response = {
             user: this.toUserInfo(user)
         };
         if (this.isCompanyFeatureEnabled()) {
             if (!companyId) {
-                throw new UnauthorizedException('Company feature is enabled but user has no company assigned.');
+                throw new UnauthorizedException({
+                    message: 'Company feature is enabled but user has no company assigned.',
+                    messageKey: AUTH_MESSAGES.COMPANY_REQUIRED
+                });
             }
             const company = await this.getCompanyById(companyId);
-            if (!company) throw new UnauthorizedException('Company not found.');
+            if (!company) throw new UnauthorizedException({
+                message: 'Company not found.',
+                messageKey: AUTH_MESSAGES.COMPANY_NOT_FOUND
+            });
             response.company = this.toCompanyInfo(company);
             if (branchId) {
                 const branch = await this.getBranchById(branchId);
-                if (!branch) throw new UnauthorizedException('Branch not found.');
+                if (!branch) throw new UnauthorizedException({
+                    message: 'Branch not found.',
+                    messageKey: AUTH_MESSAGES.BRANCH_NOT_FOUND
+                });
                 response.branch = this.toBranchInfo(branch);
             }
         }
@@ -645,7 +755,10 @@ export class AuthenticationService {
     }
     ensureCompanyFeatureEnabled() {
         if (!this.isCompanyFeatureEnabled()) {
-            throw new BadRequestException('Company feature is not enabled');
+            throw new BadRequestException({
+                message: 'Company feature is not enabled',
+                messageKey: AUTH_MESSAGES.COMPANY_FEATURE_NOT_ENABLED
+            });
         }
     }
     async validateUser(email, password) {
@@ -656,7 +769,10 @@ export class AuthenticationService {
             }
         });
         if (!user || !await bcrypt.compare(password, user.password || '')) {
-            throw new UnauthorizedException('Invalid credentials');
+            throw new UnauthorizedException({
+                message: 'Invalid credentials',
+                messageKey: AUTH_MESSAGES.LOGIN_INVALID_CREDENTIALS
+            });
         }
         user.lastLoginAt = new Date();
         await userRepository.save(user);
@@ -713,6 +829,7 @@ export class AuthenticationService {
             email: user.email,
             type: 'access'
         });
+        this.sendLoginNotification(user.id);
         return {
             accessToken,
             refreshToken,
@@ -727,6 +844,7 @@ export class AuthenticationService {
             companyId: company.id,
             branchId: branch?.id
         });
+        this.sendLoginNotification(user.id, company.id);
         return {
             accessToken,
             refreshToken,
@@ -735,9 +853,24 @@ export class AuthenticationService {
             branch: branch ? this.toBranchInfo(branch) : undefined
         };
     }
+    sendLoginNotification(userId, companyId) {
+        if (!this.notificationAdapter) return;
+        this.notificationAdapter.send({
+            userId,
+            title: 'Login successful',
+            message: 'You have successfully logged in to your account.',
+            type: NotificationType.INFO,
+            companyId
+        }).catch(()=>{
+        // Silent failure - notification is non-critical
+        });
+    }
     async generateCompanySelectionResponse(user, companies, branches) {
         if (!this.sessionService) {
-            throw new BadRequestException('Session service not available');
+            throw new BadRequestException({
+                message: 'Session service not available',
+                messageKey: AUTH_MESSAGES.SESSION_NOT_AVAILABLE
+            });
         }
         const sessionId = await this.sessionService.createSession(user.id);
         const companiesWithBranches = companies.map((company)=>({
@@ -769,7 +902,7 @@ export class AuthenticationService {
         };
     }
     // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    constructor(jwtService, authConfig, cacheManager, dataSourceProvider, sessionService, authEmailService, userEnricher){
+    constructor(jwtService, authConfig, cacheManager, dataSourceProvider, sessionService, authEmailService, userEnricher, notificationAdapter){
         _define_property(this, "jwtService", void 0);
         _define_property(this, "authConfig", void 0);
         _define_property(this, "cacheManager", void 0);
@@ -777,7 +910,7 @@ export class AuthenticationService {
         _define_property(this, "sessionService", void 0);
         _define_property(this, "authEmailService", void 0);
         _define_property(this, "userEnricher", void 0);
-        _define_property(this, "logger", void 0);
+        _define_property(this, "notificationAdapter", void 0);
         this.jwtService = jwtService;
         this.authConfig = authConfig;
         this.cacheManager = cacheManager;
@@ -785,9 +918,109 @@ export class AuthenticationService {
         this.sessionService = sessionService;
         this.authEmailService = authEmailService;
         this.userEnricher = userEnricher;
-        this.logger = new Logger(AuthenticationService.name);
+        this.notificationAdapter = notificationAdapter;
     }
 }
+_ts_decorate([
+    LogAction({
+        action: 'auth.login',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthenticationService.prototype, "login", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.register',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof RegistrationDto === "undefined" ? Object : RegistrationDto,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthenticationService.prototype, "register", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.createUser',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof RegistrationDto === "undefined" ? Object : RegistrationDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthenticationService.prototype, "createUserDirectly", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.createUserFromPending',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof PendingRegistration === "undefined" ? Object : PendingRegistration
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthenticationService.prototype, "createUserFromPendingRegistration", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.companySwitch',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthenticationService.prototype, "validateAndLoginWithCompany", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.refreshToken',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthenticationService.prototype, "refreshToken", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.changePassword',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthenticationService.prototype, "changePassword", null);
+_ts_decorate([
+    LogAction({
+        action: 'auth.logout',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], AuthenticationService.prototype, "logout", null);
 AuthenticationService = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST
@@ -804,6 +1037,8 @@ AuthenticationService = _ts_decorate([
     _ts_param(5, Inject(AuthEmailService)),
     _ts_param(6, Optional()),
     _ts_param(6, Inject(USER_ENRICHER)),
+    _ts_param(7, Optional()),
+    _ts_param(7, Inject(NOTIFICATION_ADAPTER)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof JwtService === "undefined" ? Object : JwtService,
@@ -812,6 +1047,7 @@ AuthenticationService = _ts_decorate([
         typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider,
         typeof CompanySelectionSessionService === "undefined" ? Object : CompanySelectionSessionService,
         typeof AuthEmailService === "undefined" ? Object : AuthEmailService,
-        typeof IUserEnricher === "undefined" ? Object : IUserEnricher
+        typeof IUserEnricher === "undefined" ? Object : IUserEnricher,
+        typeof INotificationAdapter === "undefined" ? Object : INotificationAdapter
     ])
 ], AuthenticationService);