@flusys/nestjs-auth 1.0.0-beta → 1.1.0-beta

package/cjs/services/authentication.service.js

@@ -19,6 +19,7 @@ const _authdatasourceprovider = require("./auth-datasource.provider");
 const _enums = require("../enums");
 const _config = require("../config");
 const _classes = require("@flusys/nestjs-shared/classes");
+const _authemailservice = require("./auth-email.service");
 const _companybranchentity = require("../entities/company-branch.entity");
 const _companyentity = require("../entities/company.entity");
 const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
@@ -130,7 +131,14 @@ let AuthenticationService = class AuthenticationService {
         if (!user.isActive) {
             throw new _common.UnauthorizedException('User account is deactivated');
         }
-        // If company feature not enabled, return simple token
+        // Check email verification if email service is enabled
+        if (this.authEmailService?.isEmailEnabled() && !user.emailVerified) {
+            return {
+                requiresEmailVerification: true,
+                email: user.email,
+                message: 'Please verify your email address before logging in.'
+            };
+        }
         if (!this.authConfig.isCompanyFeatureEnabled()) {
             return this.generateLoginResponse(user);
         }
@@ -187,10 +195,8 @@ let AuthenticationService = class AuthenticationService {
         return await this.generateCompanySelectionResponse(user, companies, branches);
     }
     // Registration
-    /** Register a new user. If company feature enabled, optionally join/create company. */ async register(dto) {
+    /** Register a new user. If email enabled, creates pending registration. Otherwise creates user directly. */ async register(dto, verifyUrlBase) {
         const userRepository = await this.getUserRepository();
-        // Check if user exists
-        // Note: Generic error message to prevent email enumeration attacks
         const existingUser = await userRepository.findOne({
             where: {
                 email: dto.email
@@ -199,7 +205,33 @@ let AuthenticationService = class AuthenticationService {
         if (existingUser) {
             throw new _common.BadRequestException('Registration failed. Please try again or contact support.');
         }
-        // Create user
+        // If email verification is enabled, create pending registration instead of user
+        if (this.authEmailService?.isEmailEnabled() && verifyUrlBase) {
+            const companyData = this.authConfig.isCompanyFeatureEnabled() ? {
+                companySlug: dto.companySlug,
+                branchSlug: dto.branchSlug,
+                newCompanyName: dto.newCompanyName,
+                newCompanyPhone: dto.newCompanyPhone,
+                newCompanyAddress: dto.newCompanyAddress
+            } : undefined;
+            const result = await this.authEmailService.createPendingRegistration({
+                email: dto.email,
+                name: dto.name,
+                phone: dto.phone,
+                password: dto.password,
+                companyData,
+                verifyUrlBase
+            });
+            return {
+                requiresEmailVerification: true,
+                message: result.message
+            };
+        }
+        // No email verification - create user directly
+        return this.createUserDirectly(dto);
+    }
+    /** Create user directly (no email verification) */ async createUserDirectly(dto) {
+        const userRepository = await this.getUserRepository();
         const hashedPassword = await _bcrypt.hash(dto.password, _config.BCRYPT_SALT_ROUNDS);
         const user = userRepository.create({
             name: dto.name,
@@ -211,38 +243,68 @@ let AuthenticationService = class AuthenticationService {
             phoneVerified: false
         });
         await userRepository.save(user);
-        // If company feature not enabled, return simple response
         if (!this.authConfig.isCompanyFeatureEnabled()) {
-            return this.generateLoginResponse(user, false);
+            return this.generateRegistrationResponse(user, false, false);
+        }
+        return this.handleCompanyRegistration(user, dto, false);
+    }
+    /** Create user from pending registration (after email verification) */ async createUserFromPendingRegistration(pending) {
+        const userRepository = await this.getUserRepository();
+        // Check if user already exists (race condition protection)
+        const existingUser = await userRepository.findOne({
+            where: {
+                email: pending.email
+            }
+        });
+        if (existingUser) {
+            throw new _common.BadRequestException('This email has already been registered.');
+        }
+        // Create user with verified email
+        const user = userRepository.create({
+            name: pending.name,
+            email: pending.email,
+            phone: pending.phone,
+            password: pending.passwordHash,
+            isActive: true,
+            emailVerified: true,
+            phoneVerified: false
+        });
+        await userRepository.save(user);
+        // Handle company feature if enabled
+        if (this.authConfig.isCompanyFeatureEnabled() && pending.companyData) {
+            return this.handleCompanyRegistrationFromPending(user, pending.companyData);
         }
-        // Handle company feature
-        return this.handleCompanyRegistration(user, dto);
+        return this.generateRegistrationResponse(user, this.authConfig.isCompanyFeatureEnabled(), false);
+    }
+    /** Handle company registration from pending registration data */ async handleCompanyRegistrationFromPending(user, companyData) {
+        return this.processCompanyRegistration(user, companyData, false);
+    }
+    /** Handle company-related registration logic */ async handleCompanyRegistration(user, dto, requiresEmailVerification) {
+        return this.processCompanyRegistration(user, dto, requiresEmailVerification);
     }
-    /** Handle company-related registration logic */ async handleCompanyRegistration(user, dto) {
+    /** Shared logic for company registration (join existing or create new) */ async processCompanyRegistration(user, data, requiresEmailVerification) {
         const companyRepository = await this.getCompanyRepository();
         const branchRepository = await this.getBranchRepository();
         const permissionRepository = await this.getPermissionRepository();
         if (!companyRepository || !branchRepository || !permissionRepository) {
-            return this.generateLoginResponse(user, true);
+            return this.generateRegistrationResponse(user, true, requiresEmailVerification);
         }
         let company = null;
         let branch = null;
-        // Case 1: Join existing company by slug
-        if (dto.companySlug) {
+        if (data.companySlug) {
             company = await companyRepository.findOne({
                 where: {
-                    slug: dto.companySlug,
+                    slug: data.companySlug,
                     isActive: true
                 }
             });
             if (!company) {
                 throw new _common.BadRequestException('Company not found or inactive');
             }
-            // Find branch by slug or get default
-            if (dto.branchSlug) {
+            if (data.branchSlug) {
                 branch = await branchRepository.findOne({
                     where: {
-                        slug: dto.branchSlug,
+                        slug: data.branchSlug,
                         companyId: company.id,
                         isActive: true
                     }
@@ -251,7 +313,6 @@ let AuthenticationService = class AuthenticationService {
                     throw new _common.BadRequestException('Branch not found or inactive');
                 }
             } else {
-                // Get first active branch
                 branch = await branchRepository.findOne({
                     where: {
                         companyId: company.id,
@@ -263,9 +324,8 @@ let AuthenticationService = class AuthenticationService {
                     }
                 });
             }
-        } else if (dto.newCompanyName) {
-            const slug = this.generateSlug(dto.newCompanyName);
-            // Check if slug exists
+        } else if (data.newCompanyName) {
+            const slug = this.generateSlug(data.newCompanyName);
             const existingCompany = await companyRepository.findOne({
                 where: {
                     slug
@@ -274,16 +334,14 @@ let AuthenticationService = class AuthenticationService {
             if (existingCompany) {
                 throw new _common.BadRequestException('Company creation failed. Please try a different name.');
             }
-            // Create company
             company = companyRepository.create({
-                name: dto.newCompanyName,
+                name: data.newCompanyName,
                 slug,
-                phone: dto.newCompanyPhone,
-                address: dto.newCompanyAddress,
+                phone: data.newCompanyPhone,
+                address: data.newCompanyAddress,
                 isActive: true
             });
             await companyRepository.save(company);
-            // Create default branch
             branch = branchRepository.create({
                 name: 'Main Branch',
                 slug: 'main-branch',
@@ -292,16 +350,13 @@ let AuthenticationService = class AuthenticationService {
             });
             await branchRepository.save(branch);
         }
-        // Create permissions if company exists
         if (company) {
-            // Create company permission
             const companyPermission = permissionRepository.create({
                 userId: user.id,
                 permissionType: _enums.PermissionType.COMPANY,
                 targetId: company.id
             });
             await permissionRepository.save(companyPermission);
-            // Create branch permission if branch exists
             if (branch) {
                 const branchPermission = permissionRepository.create({
                     userId: user.id,
@@ -310,10 +365,9 @@ let AuthenticationService = class AuthenticationService {
                 });
                 await permissionRepository.save(branchPermission);
             }
-            return this.generateLoginResponseWithCompany(user, company, branch ?? undefined);
+            return this.generateRegistrationResponseWithCompany(user, company, branch ?? undefined, requiresEmailVerification);
         }
-        // No company assigned
-        return this.generateLoginResponse(user, true);
+        return this.generateRegistrationResponse(user, true, requiresEmailVerification);
     }
     /** Generate URL-friendly slug from name */ generateSlug(name) {
         return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').substring(0, 100);
@@ -666,6 +720,7 @@ let AuthenticationService = class AuthenticationService {
                 id: user.id,
                 email: user.email,
                 name: user.name ?? undefined,
+                phone: user.phone ?? undefined,
                 profilePictureId: user.profilePictureId ?? undefined
             }
         };
@@ -752,6 +807,7 @@ let AuthenticationService = class AuthenticationService {
                 id: user.id,
                 email: user.email,
                 name: user.name ?? undefined,
+                phone: user.phone ?? null,
                 profilePictureId: user.profilePictureId ?? null
             },
             companyFeatureEnabled
@@ -787,6 +843,7 @@ let AuthenticationService = class AuthenticationService {
                 id: user.id,
                 email: user.email,
                 name: user.name ?? undefined,
+                phone: user.phone ?? null,
                 profilePictureId: user.profilePictureId ?? null
             },
             company: {
@@ -832,18 +889,76 @@ let AuthenticationService = class AuthenticationService {
                 id: user.id,
                 email: user.email,
                 name: user.name ?? undefined,
+                phone: user.phone ?? null,
                 profilePictureId: user.profilePictureId ?? null
             },
             companies: companiesWithBranches
         };
     }
+    /** Generate registration response - tokens included only if email verification not required */ generateRegistrationResponse(user, companyFeatureEnabled, requiresEmailVerification) {
+        const userInfo = {
+            id: user.id,
+            email: user.email,
+            name: user.name ?? undefined,
+            phone: user.phone ?? null,
+            profilePictureId: user.profilePictureId ?? null
+        };
+        if (requiresEmailVerification) {
+            return {
+                user: userInfo,
+                companyFeatureEnabled,
+                requiresEmailVerification: true
+            };
+        }
+        const loginResponse = this.generateLoginResponse(user, companyFeatureEnabled);
+        return {
+            ...loginResponse,
+            requiresEmailVerification: false
+        };
+    }
+    /** Generate registration response with company - tokens included only if email verification not required */ generateRegistrationResponseWithCompany(user, company, branch, requiresEmailVerification = false) {
+        const userInfo = {
+            id: user.id,
+            email: user.email,
+            name: user.name ?? undefined,
+            phone: user.phone ?? null,
+            profilePictureId: user.profilePictureId ?? null
+        };
+        const companyInfo = {
+            id: company.id,
+            name: company.name,
+            slug: company.slug,
+            logoId: company.logoId ?? null
+        };
+        const branchInfo = branch ? {
+            id: branch.id,
+            name: branch.name,
+            slug: branch.slug,
+            logoId: branch.logoId ?? null
+        } : undefined;
+        if (requiresEmailVerification) {
+            return {
+                user: userInfo,
+                company: companyInfo,
+                branch: branchInfo,
+                companyFeatureEnabled: true,
+                requiresEmailVerification: true
+            };
+        }
+        const loginResponse = this.generateLoginResponseWithCompany(user, company, branch);
+        return {
+            ...loginResponse,
+            requiresEmailVerification: false
+        };
+    }
     // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    constructor(jwtService, authConfig, cacheManager, dataSourceProvider, sessionService, injectedUserRepository, injectedPermissionRepository, injectedCompanyRepository, injectedBranchRepository){
+    constructor(jwtService, authConfig, cacheManager, dataSourceProvider, sessionService, authEmailService, injectedUserRepository, injectedPermissionRepository, injectedCompanyRepository, injectedBranchRepository){
         _define_property(this, "jwtService", void 0);
         _define_property(this, "authConfig", void 0);
         _define_property(this, "cacheManager", void 0);
         _define_property(this, "dataSourceProvider", void 0);
         _define_property(this, "sessionService", void 0);
+        _define_property(this, "authEmailService", void 0);
         _define_property(this, "injectedUserRepository", void 0);
         _define_property(this, "injectedPermissionRepository", void 0);
         _define_property(this, "injectedCompanyRepository", void 0);
@@ -854,6 +969,7 @@ let AuthenticationService = class AuthenticationService {
         this.cacheManager = cacheManager;
         this.dataSourceProvider = dataSourceProvider;
         this.sessionService = sessionService;
+        this.authEmailService = authEmailService;
         this.injectedUserRepository = injectedUserRepository;
         this.injectedPermissionRepository = injectedPermissionRepository;
         this.injectedCompanyRepository = injectedCompanyRepository;
@@ -874,13 +990,15 @@ AuthenticationService = _ts_decorate([
     _ts_param(4, (0, _common.Optional)()),
     _ts_param(4, (0, _common.Inject)(_companyselectionsessionservice.CompanySelectionSessionService)),
     _ts_param(5, (0, _common.Optional)()),
-    _ts_param(5, (0, _typeorm.InjectRepository)(_userentity.User)),
+    _ts_param(5, (0, _common.Inject)(_authemailservice.AuthEmailService)),
     _ts_param(6, (0, _common.Optional)()),
-    _ts_param(6, (0, _typeorm.InjectRepository)(_usercompanypermissionentity.UserCompanyPermission)),
+    _ts_param(6, (0, _typeorm.InjectRepository)(_userentity.User)),
     _ts_param(7, (0, _common.Optional)()),
-    _ts_param(7, (0, _typeorm.InjectRepository)(_companyentity.Company)),
+    _ts_param(7, (0, _typeorm.InjectRepository)(_usercompanypermissionentity.UserCompanyPermission)),
     _ts_param(8, (0, _common.Optional)()),
-    _ts_param(8, (0, _typeorm.InjectRepository)(_companybranchentity.CompanyBranch)),
+    _ts_param(8, (0, _typeorm.InjectRepository)(_companyentity.Company)),
+    _ts_param(9, (0, _common.Optional)()),
+    _ts_param(9, (0, _typeorm.InjectRepository)(_companybranchentity.CompanyBranch)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _jwt.JwtService === "undefined" ? Object : _jwt.JwtService,
@@ -888,6 +1006,7 @@ AuthenticationService = _ts_decorate([
         typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
         typeof _authdatasourceprovider.AuthDataSourceProvider === "undefined" ? Object : _authdatasourceprovider.AuthDataSourceProvider,
         typeof _companyselectionsessionservice.CompanySelectionSessionService === "undefined" ? Object : _companyselectionsessionservice.CompanySelectionSessionService,
+        typeof _authemailservice.AuthEmailService === "undefined" ? Object : _authemailservice.AuthEmailService,
         typeof _typeorm1.Repository === "undefined" ? Object : _typeorm1.Repository,
         typeof _typeorm1.Repository === "undefined" ? Object : _typeorm1.Repository,
         typeof _typeorm1.Repository === "undefined" ? Object : _typeorm1.Repository,

package/cjs/services/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./authentication.service"), exports);
+_export_star(require("./auth-email.service"), exports);
 _export_star(require("./company-selection-session.service"), exports);
 _export_star(require("./user.service"), exports);
 _export_star(require("./company.service"), exports);

package/cjs/services/user.service.js

@@ -17,6 +17,7 @@ const _authconfigservice = require("./auth-config.service");
 const _authdatasourceprovider = require("./auth-datasource.provider");
 const _config = require("../config");
 const _enums = require("../enums");
+const _userenricherinterface = require("../interfaces/user-enricher.interface");
 const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
 const _userentity = require("../entities/user.entity");
 function _define_property(obj, key, value) {
@@ -170,8 +171,8 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     /** Convert DTO to entity (hash password before saving) */ async convertSingleDtoToEntity(dto, user) {
         // Repository initialization is handled automatically by RequestScopedApiService
         const entity = await super.convertSingleDtoToEntity(dto, user);
-        // Hash password if provided
-        if (dto.password) {
+        // Hash password if provided (CreateUserDto has password field)
+        if ('password' in dto && dto.password) {
             entity.password = await _bcrypt.hash(dto.password, _config.BCRYPT_SALT_ROUNDS);
         }
         return entity;
@@ -213,7 +214,11 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     }
     /** Add company permission-based isActive check when company feature enabled. Returns isRaw: true for computed fields. */ async getExtraManipulateQuery(query, filterAndPaginationDto, user) {
         // Repository initialization is handled automatically by RequestScopedApiService
-        const result = await super.getExtraManipulateQuery(query, filterAndPaginationDto, user);
+        let result = await super.getExtraManipulateQuery(query, filterAndPaginationDto, user);
+        // Apply user enricher query modifications if available
+        if (this.userEnricher?.enrichListQuery) {
+            await this.userEnricher.enrichListQuery(query, user);
+        }
         // Only apply company filtering if:
         // 1. Company feature is enabled at bootstrap
         // 2. User has company context
@@ -333,16 +338,140 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             await queryRunner.release();
         }
     }
-    /** Update user profile with password handling */ async profile(dto, user) {
-        // Repository initialization is handled automatically by RequestScopedApiService
+    /**
+   * Get user profile with extras from enricher
+   * Returns base user data plus any extra data provided by enricher (roles, permissions, etc.)
+   */ async getProfileWithExtras(userId, user) {
+        await this.ensureRepositoryInitialized();
+        const userEntity = await this.repository.findOne({
+            where: {
+                id: userId
+            }
+        });
+        if (!userEntity) {
+            throw new _common.NotFoundException('User not found');
+        }
+        const userData = this.convertEntityToResponseDto(userEntity, false);
+        // Get extras from enricher if available
+        let extras;
+        if (this.userEnricher?.getProfileExtras) {
+            extras = await this.userEnricher.getProfileExtras(userId, user);
+        }
+        return {
+            user: userData,
+            extras
+        };
+    }
+    /**
+   * Get enriched user list
+   * Applies enricher transformations after query execution
+   */ async getEnrichedList(users, user) {
+        if (this.userEnricher?.enrichListItems) {
+            return this.userEnricher.enrichListItems(users, user);
+        }
+        return users;
+    }
+    // ============================================
+    // Multi-Step Profile Methods (via Enricher)
+    // ============================================
+    /**
+   * Get profile section definitions from enricher
+   */ async getProfileSections() {
+        if (this.userEnricher?.getProfileSections) {
+            return this.userEnricher.getProfileSections();
+        }
+        return [];
+    }
+    /**
+   * Get specific profile section data
+   */ async getProfileSectionData(userId, sectionId, user) {
+        await this.ensureRepositoryInitialized();
+        // Verify user exists
+        const userEntity = await this.repository.findOne({
+            where: {
+                id: userId
+            }
+        });
+        if (!userEntity) {
+            throw new _common.NotFoundException('User not found');
+        }
+        if (this.userEnricher?.getProfileSectionData) {
+            return this.userEnricher.getProfileSectionData(userId, sectionId, user);
+        }
+        return null;
+    }
+    /**
+   * Update specific profile section
+   */ async updateProfileSection(userId, sectionId, data, user) {
+        await this.ensureRepositoryInitialized();
+        if (!this.dataSource) {
+            throw new _common.BadRequestException('DataSource not available');
+        }
+        // Verify user exists
+        const userEntity = await this.repository.findOne({
+            where: {
+                id: userId
+            }
+        });
+        if (!userEntity) {
+            throw new _common.NotFoundException('User not found');
+        }
+        if (!this.userEnricher?.updateProfileSection) {
+            throw new _common.BadRequestException('Profile sections not supported');
+        }
+        const queryRunner = this.dataSource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            await this.userEnricher.updateProfileSection(userId, sectionId, data, queryRunner);
+            await queryRunner.commitTransaction();
+            await this.clearCacheForId([
+                userEntity
+            ]);
+        } catch (error) {
+            await queryRunner.rollbackTransaction();
+            _utils.ErrorHandler.logError(this.logger, error, 'updateProfileSection', {
+                entity: this.entityName,
+                sectionId
+            });
+            _utils.ErrorHandler.rethrowError(error);
+        } finally{
+            await queryRunner.release();
+        }
+    }
+    /**
+   * Get profile completion percentage
+   */ async getProfileCompletion(userId, user) {
+        await this.ensureRepositoryInitialized();
+        // Verify user exists
+        const userEntity = await this.repository.findOne({
+            where: {
+                id: userId
+            }
+        });
+        if (!userEntity) {
+            throw new _common.NotFoundException('User not found');
+        }
+        if (this.userEnricher?.calculateProfileCompletion) {
+            return this.userEnricher.calculateProfileCompletion(userId, user);
+        }
+        return 100; // Default to 100% if no enricher
+    }
+    /** Update user profile with password handling and extras */ async profile(dto, user) {
+        // Ensure repository and dataSource are initialized
+        await this.ensureRepositoryInitialized();
         if (!this.dataSource) {
             throw new _common.BadRequestException('DataSource not available');
         }
+        const userId = dto.id ?? user.id;
+        // Validate extras if enricher provides validation
+        if (dto.extras && this.userEnricher?.validateProfileExtras) {
+            await this.userEnricher.validateProfileExtras(userId, dto.extras, user);
+        }
         const queryRunner = this.dataSource.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
         try {
-            const userId = dto.id ?? user.id;
             const findUser = await queryRunner.manager.findOne(this.repository.target, {
                 where: {
                     id: userId
@@ -361,10 +490,14 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
                 const salt = await _bcrypt.genSalt();
                 findUser.password = await _bcrypt.hash(dto.password, salt);
             }
-            // Merge other fields (excluding password)
-            const { password, ...restDto } = dto;
+            // Merge other fields (excluding password and extras)
+            const { password, extras, ...restDto } = dto;
             Object.assign(findUser, restDto);
             await queryRunner.manager.save(this.repository.target, findUser);
+            // Handle extras update via enricher
+            if (extras && this.userEnricher?.updateProfileExtras) {
+                await this.userEnricher.updateProfileExtras(userId, extras, queryRunner);
+            }
             await queryRunner.commitTransaction();
             await this.clearCacheForId([
                 findUser
@@ -380,8 +513,8 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             await queryRunner.release();
         }
     }
-    constructor(cacheManager, utilsService, dataSourceProvider, authConfig){
-        super('user', null, cacheManager, utilsService, UserService.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), _define_property(this, "permissionRepository", void 0), _define_property(this, "dataSource", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.authConfig = authConfig;
+    constructor(cacheManager, utilsService, dataSourceProvider, authConfig, userEnricher){
+        super('user', null, cacheManager, utilsService, UserService.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), _define_property(this, "userEnricher", void 0), _define_property(this, "permissionRepository", void 0), _define_property(this, "dataSource", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.authConfig = authConfig, this.userEnricher = userEnricher;
     }
 };
 UserService = _ts_decorate([
@@ -392,11 +525,14 @@ UserService = _ts_decorate([
     _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
     _ts_param(2, (0, _common.Inject)(_authdatasourceprovider.AuthDataSourceProvider)),
     _ts_param(3, (0, _common.Inject)(_authconfigservice.AuthConfigService)),
+    _ts_param(4, (0, _common.Optional)()),
+    _ts_param(4, (0, _common.Inject)(_config.USER_ENRICHER)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
         typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
         typeof _authdatasourceprovider.AuthDataSourceProvider === "undefined" ? Object : _authdatasourceprovider.AuthDataSourceProvider,
-        typeof _authconfigservice.AuthConfigService === "undefined" ? Object : _authconfigservice.AuthConfigService
+        typeof _authconfigservice.AuthConfigService === "undefined" ? Object : _authconfigservice.AuthConfigService,
+        typeof _userenricherinterface.IUserEnricher === "undefined" ? Object : _userenricherinterface.IUserEnricher
     ])
 ], UserService);

package/config/auth.constants.d.ts

@@ -1,4 +1,5 @@
 export declare const AUTH_MODULE_OPTIONS = "AUTH_MODULE_OPTIONS";
+export declare const USER_ENRICHER = "USER_ENRICHER";
 export declare const BCRYPT_SALT_ROUNDS = 12;
 export declare const SESSION_CACHE_PREFIX = "auth:session";
 export declare const TOKEN_REVOKED_PREFIX = "auth:revoked";

package/controllers/authentication.controller.d.ts

@@ -1,22 +1,26 @@
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { Request } from 'express';
-import { ChangePasswordDto, CompanySelectionResponseDto, LoginDto, LoginResponseDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto } from '../dtos/authentication.dto';
+import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
 import { AuthConfigService } from '../services/auth-config.service';
+import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
 export declare class AuthenticationController {
     private readonly authService;
     private readonly authConfig?;
-    constructor(authService: AuthenticationService, authConfig?: AuthConfigService);
+    private readonly authEmailService?;
+    constructor(authService: AuthenticationService, authConfig?: AuthConfigService, authEmailService?: AuthEmailService);
+    private buildAuthUrl;
     login(loginDto: LoginDto): Promise<LoginResponseDto | CompanySelectionResponseDto>;
-    register(registrationDto: RegistrationDto): Promise<RegistrationResponseDto>;
+    register(req: Request, registrationDto: RegistrationDto): Promise<RegistrationResponseDto>;
     refreshToken(req: Request, refreshTokenDto: RefreshTokenDto): Promise<{
         accessToken: string;
     }>;
     getCurrentUser(user: ILoggedUserInfo): Promise<MeResponseDto>;
-    logout(userId: string): Promise<{
-        message: string;
-    }>;
-    changePassword(userId: string, dto: ChangePasswordDto): Promise<{
-        message: string;
-    }>;
+    logout(userId: string): Promise<MessageResponseDto>;
+    changePassword(userId: string, dto: ChangePasswordDto): Promise<MessageResponseDto>;
+    forgotPassword(req: Request, dto: ForgotPasswordDto): Promise<MessageResponseDto>;
+    resetPassword(dto: ResetPasswordDto): Promise<MessageResponseDto>;
+    resendVerification(req: Request, dto: ResendVerificationDto): Promise<MessageResponseDto>;
+    verifyEmail(dto: VerifyEmailDto): Promise<MessageResponseDto | RegistrationResponseDto>;
 }