@flusys/nestjs-auth 3.0.1 → 4.0.0-lts

package/fesm/services/authentication.service.js

@@ -26,16 +26,21 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { HybridCache } from '@flusys/nestjs-shared/classes';
+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 { ErrorHandler, generateUniqueSlug } from '@flusys/nestjs-shared/utils';
-import { BadRequestException, Inject, Injectable, Logger, NotFoundException, Optional, Scope, UnauthorizedException } from '@nestjs/common';
+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';
@@ -54,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);
     }
@@ -75,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();
@@ -144,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() ? {
@@ -168,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({
@@ -198,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();
@@ -231,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();
@@ -258,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,
@@ -275,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) {
@@ -283,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();
         }
@@ -294,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);
@@ -312,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,
@@ -329,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
@@ -385,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();
@@ -405,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: {
@@ -421,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: {
@@ -430,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: {
@@ -440,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: {
@@ -450,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);
     }
@@ -460,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({
@@ -469,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,
@@ -483,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) {
@@ -495,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) {
@@ -548,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: {
@@ -569,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: {
@@ -579,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: {
@@ -626,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);
             }
         }
@@ -647,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) {
@@ -658,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);
@@ -747,13 +861,16 @@ export class AuthenticationService {
             message: 'You have successfully logged in to your account.',
             type: NotificationType.INFO,
             companyId
-        }).catch((error)=>{
-            this.logger.warn(`Failed to send login notification: ${error.message}`);
+        }).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)=>({
@@ -794,7 +911,6 @@ export class AuthenticationService {
         _define_property(this, "authEmailService", void 0);
         _define_property(this, "userEnricher", void 0);
         _define_property(this, "notificationAdapter", void 0);
-        _define_property(this, "logger", void 0);
         this.jwtService = jwtService;
         this.authConfig = authConfig;
         this.cacheManager = cacheManager;
@@ -803,9 +919,108 @@ export class AuthenticationService {
         this.authEmailService = authEmailService;
         this.userEnricher = userEnricher;
         this.notificationAdapter = notificationAdapter;
-        this.logger = new Logger(AuthenticationService.name);
     }
 }
+_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

package/fesm/services/branch.service.js

@@ -79,7 +79,7 @@ export class BranchService extends RequestScopedApiService {
         return result;
     }
     constructor(cacheManager, utilsService, dataSourceProvider, authConfig){
-        super('company_branch', null, cacheManager, utilsService, BranchService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "authConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.authConfig = authConfig;
+        super('company_branch', null, cacheManager, utilsService, BranchService.name, true, 'auth'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "authConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.authConfig = authConfig;
     }
 }
 BranchService = _ts_decorate([