@flusys/nestjs-auth 1.0.0-beta → 1.0.0

package/cjs/services/authentication.service.js

@@ -8,21 +8,20 @@ Object.defineProperty(exports, "AuthenticationService", {
         return AuthenticationService;
     }
 });
+const _classes = require("@flusys/nestjs-shared/classes");
+const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
 const _jwt = require("@nestjs/jwt");
-const _typeorm = require("@nestjs/typeorm");
 const _bcrypt = /*#__PURE__*/ _interop_require_wildcard(require("bcrypt"));
-const _typeorm1 = require("typeorm");
-const _utils = require("@flusys/nestjs-shared/utils");
-const _authconfigservice = require("./auth-config.service");
-const _authdatasourceprovider = require("./auth-datasource.provider");
-const _enums = require("../enums");
 const _config = require("../config");
-const _classes = require("@flusys/nestjs-shared/classes");
 const _companybranchentity = require("../entities/company-branch.entity");
 const _companyentity = require("../entities/company.entity");
 const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
 const _userentity = require("../entities/user.entity");
+const _enums = require("../enums");
+const _authconfigservice = require("./auth-config.service");
+const _authdatasourceprovider = require("./auth-datasource.provider");
+const _authemailservice = require("./auth-email.service");
 const _companyselectionsessionservice = require("./company-selection-session.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -93,45 +92,51 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let AuthenticationService = class AuthenticationService {
+    // Feature Flags
+    /** Check if company feature is enabled (tenant-aware with global fallback) */ isCompanyFeatureEnabled() {
+        return this.dataSourceProvider?.isCompanyFeatureEnabled() ?? this.authConfig.isCompanyFeatureEnabled();
+    }
     // Repository Getters
     async getUserRepository() {
-        if (this.dataSourceProvider) {
-            return this.dataSourceProvider.getRepository(_userentity.User);
-        }
-        if (this.injectedUserRepository) {
-            return this.injectedUserRepository;
+        if (!this.dataSourceProvider) {
+            throw new Error('User repository not available');
         }
-        throw new Error('User repository not available');
+        return this.dataSourceProvider.getRepository(_userentity.User);
     }
     async getPermissionRepository() {
-        if (!this.authConfig.isCompanyFeatureEnabled()) return null;
-        if (this.dataSourceProvider) {
-            return this.dataSourceProvider.getRepository(_usercompanypermissionentity.UserCompanyPermission);
-        }
-        return this.injectedPermissionRepository ?? null;
+        if (!this.isCompanyFeatureEnabled() || !this.dataSourceProvider) return null;
+        return this.dataSourceProvider.getRepository(_usercompanypermissionentity.UserCompanyPermission);
     }
     async getCompanyRepository() {
-        if (!this.authConfig.isCompanyFeatureEnabled()) return null;
-        if (this.dataSourceProvider) {
-            return this.dataSourceProvider.getRepository(_companyentity.Company);
-        }
-        return this.injectedCompanyRepository ?? null;
+        if (!this.isCompanyFeatureEnabled() || !this.dataSourceProvider) return null;
+        return this.dataSourceProvider.getRepository(_companyentity.Company);
     }
     async getBranchRepository() {
-        if (!this.authConfig.isCompanyFeatureEnabled()) return null;
-        if (this.dataSourceProvider) {
-            return this.dataSourceProvider.getRepository(_companybranchentity.CompanyBranch);
-        }
-        return this.injectedBranchRepository ?? null;
+        if (!this.isCompanyFeatureEnabled() || !this.dataSourceProvider) return null;
+        return this.dataSourceProvider.getRepository(_companybranchentity.CompanyBranch);
     }
     // Login
-    /** Login with email and password. Returns tokens or requires company/branch selection. */ async login(email, password) {
+    async login(email, password) {
+        // Check for pending registration first (user registered but hasn't verified email yet)
+        if (await this.authEmailService?.hasPendingRegistration(email)) {
+            return {
+                requiresEmailVerification: true,
+                email,
+                message: 'Please verify your email address to complete registration.'
+            };
+        }
         const user = await this.validateUser(email, password);
         if (!user.isActive) {
             throw new _common.UnauthorizedException('User account is deactivated');
         }
-        // If company feature not enabled, return simple token
-        if (!this.authConfig.isCompanyFeatureEnabled()) {
+        if (this.authEmailService?.isEmailEnabled() && !user.emailVerified) {
+            return {
+                requiresEmailVerification: true,
+                email: user.email,
+                message: 'Please verify your email address before logging in.'
+            };
+        }
+        if (!this.isCompanyFeatureEnabled()) {
             return this.generateLoginResponse(user);
         }
         return this.handleCompanyBasedLogin(user);
@@ -163,7 +168,7 @@ let AuthenticationService = class AuthenticationService {
         // If user has no company assignments yet, return simple login response
         // This allows users to login and be assigned to companies later
         if (companies.length === 0) {
-            return this.generateLoginResponse(user, true);
+            return this.generateLoginResponse(user);
         }
         // Get branch permissions
         const branchPermissions = await permissionRepository.find({
@@ -187,19 +192,80 @@ 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
             }
         });
+        // When company feature is enabled and user exists, allow joining/creating company
+        if (existingUser && this.isCompanyFeatureEnabled()) {
+            return this.handleExistingUserCompanyRegistration(existingUser, dto);
+        }
+        // User exists but company feature is off - email must be unique
         if (existingUser) {
-            throw new _common.BadRequestException('Registration failed. Please try again or contact support.');
+            throw new _common.BadRequestException('Registration failed due to email exists. Please try again or contact support.');
+        }
+        // If email verification is enabled, create pending registration instead of user
+        if (this.authEmailService?.isEmailEnabled() && verifyUrlBase) {
+            const companyData = this.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
+            };
         }
-        // Create user
+        // No email verification - create user directly
+        return this.createUserDirectly(dto);
+    }
+    /** Handle registration for existing user when company feature is enabled */ async handleExistingUserCompanyRegistration(existingUser, dto) {
+        if (!dto.companySlug && !dto.newCompanyName) {
+            throw new _common.BadRequestException('Email already registered. Please login or provide a company to join/create.');
+        }
+        const permissionRepository = await this.getPermissionRepository();
+        const companyRepository = await this.getCompanyRepository();
+        if (!permissionRepository || !companyRepository) {
+            throw new _common.BadRequestException('Company feature repositories not available');
+        }
+        // For existing users joining a company, check if already assigned
+        if (dto.companySlug) {
+            const company = await companyRepository.findOne({
+                where: {
+                    slug: dto.companySlug,
+                    isActive: true
+                }
+            });
+            if (company) {
+                const existingPermission = await permissionRepository.findOne({
+                    where: {
+                        userId: existingUser.id,
+                        permissionType: _enums.PermissionType.COMPANY,
+                        targetId: company.id
+                    }
+                });
+                if (existingPermission) {
+                    throw new _common.BadRequestException('You are already assigned to this company. Please login.');
+                }
+            }
+        }
+        return this.processCompanyRegistration(existingUser, dto, true);
+    }
+    /** 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,112 +277,128 @@ 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);
+        if (!this.isCompanyFeatureEnabled()) {
+            return this.generateRegistrationResponse(user);
         }
-        // Handle company feature
-        return this.handleCompanyRegistration(user, dto);
+        return this.processCompanyRegistration(user, dto);
     }
-    /** Handle company-related registration logic */ async handleCompanyRegistration(user, dto) {
+    /** Create user from pending registration (after email verification) */ async createUserFromPendingRegistration(pending) {
+        const userRepository = await this.getUserRepository();
+        const existingUser = await userRepository.findOne({
+            where: {
+                email: pending.email
+            }
+        });
+        if (existingUser) {
+            throw new _common.BadRequestException('This email has already been registered.');
+        }
+        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);
+        if (this.isCompanyFeatureEnabled() && pending.companyData) {
+            return this.processCompanyRegistration(user, pending.companyData);
+        }
+        return this.generateRegistrationResponse(user);
+    }
+    /** Process company registration (join existing or create new) */ async processCompanyRegistration(user, data, throwOnUnavailable = false) {
         const companyRepository = await this.getCompanyRepository();
         const branchRepository = await this.getBranchRepository();
         const permissionRepository = await this.getPermissionRepository();
         if (!companyRepository || !branchRepository || !permissionRepository) {
-            return this.generateLoginResponse(user, true);
+            if (throwOnUnavailable) throw new _common.BadRequestException('Company feature repositories not available');
+            return this.generateRegistrationResponse(user);
         }
-        let company = null;
-        let branch = null;
-        // Case 1: Join existing company by slug
-        if (dto.companySlug) {
-            company = await companyRepository.findOne({
+        const { company, branch } = await this.findOrCreateCompanyAndBranch(data, companyRepository, branchRepository);
+        if (company) {
+            await this.assignUserPermissions(user.id, company.id, branch?.id, permissionRepository);
+            return this.generateRegistrationResponseWithCompany(user, company, branch ?? undefined);
+        }
+        return this.generateRegistrationResponse(user);
+    }
+    /** Find existing company/branch or create new ones */ async findOrCreateCompanyAndBranch(data, companyRepo, branchRepo) {
+        if (data.companySlug) {
+            const company = await companyRepo.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) {
-                branch = await branchRepository.findOne({
-                    where: {
-                        slug: dto.branchSlug,
-                        companyId: company.id,
-                        isActive: true
-                    }
-                });
-                if (!branch) {
-                    throw new _common.BadRequestException('Branch not found or inactive');
+            if (!company) throw new _common.BadRequestException('Company not found or inactive');
+            const branch = data.branchSlug ? await branchRepo.findOne({
+                where: {
+                    slug: data.branchSlug,
+                    companyId: company.id,
+                    isActive: true
                 }
-            } else {
-                // Get first active branch
-                branch = await branchRepository.findOne({
-                    where: {
-                        companyId: company.id,
-                        isActive: true
-                    },
-                    order: {
-                        serial: 'ASC',
-                        createdAt: 'ASC'
-                    }
-                });
-            }
-        } else if (dto.newCompanyName) {
-            const slug = this.generateSlug(dto.newCompanyName);
-            // Check if slug exists
-            const existingCompany = await companyRepository.findOne({
+            }) : await branchRepo.findOne({
                 where: {
-                    slug
+                    companyId: company.id,
+                    isActive: true
+                },
+                order: {
+                    serial: 'ASC',
+                    createdAt: 'ASC'
                 }
             });
-            if (existingCompany) {
-                throw new _common.BadRequestException('Company creation failed. Please try a different name.');
-            }
-            // Create company
-            company = companyRepository.create({
-                name: dto.newCompanyName,
+            if (data.branchSlug && !branch) throw new _common.BadRequestException('Branch not found or inactive');
+            return {
+                company,
+                branch
+            };
+        }
+        if (data.newCompanyName) {
+            const slug = await (0, _utils.generateUniqueSlug)(data.newCompanyName, async (baseSlug)=>{
+                const rows = await companyRepo.createQueryBuilder('c').select('c.slug').where('c.slug = :base OR c.slug LIKE :pattern', {
+                    base: baseSlug,
+                    pattern: `${baseSlug}-%`
+                }).getMany();
+                return rows.map((r)=>r.slug);
+            });
+            const company = companyRepo.create({
+                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({
+            await companyRepo.save(company);
+            const branch = branchRepo.create({
                 name: 'Main Branch',
                 slug: 'main-branch',
                 companyId: company.id,
                 isActive: true
             });
-            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,
-                    permissionType: _enums.PermissionType.BRANCH,
-                    targetId: branch.id
-                });
-                await permissionRepository.save(branchPermission);
-            }
-            return this.generateLoginResponseWithCompany(user, company, branch ?? undefined);
+            await branchRepo.save(branch);
+            return {
+                company,
+                branch
+            };
         }
-        // No company assigned
-        return this.generateLoginResponse(user, true);
+        return {
+            company: null,
+            branch: null
+        };
     }
-    /** Generate URL-friendly slug from name */ generateSlug(name) {
-        return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').substring(0, 100);
+    /** Assign user to company and optionally branch */ async assignUserPermissions(userId, companyId, branchId, permissionRepo) {
+        await permissionRepo.save(permissionRepo.create({
+            userId,
+            permissionType: _enums.PermissionType.COMPANY,
+            targetId: companyId
+        }));
+        if (branchId) {
+            await permissionRepo.save(permissionRepo.create({
+                userId,
+                permissionType: _enums.PermissionType.BRANCH,
+                targetId: branchId
+            }));
+        }
     }
     // Company/Branch Selection
     /** Select company and branch (step 2 of login). Frontend receives all options and user selects both. */ async select(sessionId, companyId, branchId) {
@@ -328,66 +410,13 @@ let AuthenticationService = class AuthenticationService {
         if (!session) {
             throw new _common.UnauthorizedException('Invalid or expired session');
         }
-        const userRepository = await this.getUserRepository();
-        const user = await userRepository.findOne({
-            where: {
-                id: session.userId
-            }
-        });
-        if (!user) {
-            throw new _common.NotFoundException('User not found');
-        }
-        const permissionRepository = await this.getPermissionRepository();
-        const companyRepository = await this.getCompanyRepository();
-        const branchRepository = await this.getBranchRepository();
-        if (!permissionRepository || !companyRepository || !branchRepository) {
-            throw new _common.BadRequestException('Repositories not available');
-        }
-        // Validate company access
-        const companyPermission = await permissionRepository.findOne({
-            where: {
-                userId: user.id,
-                permissionType: _enums.PermissionType.COMPANY,
-                targetId: companyId
-            }
-        });
-        if (!companyPermission) {
-            throw new _common.UnauthorizedException('No access to this company');
-        }
-        const company = await companyRepository.findOne({
-            where: {
-                id: companyId,
-                isActive: true
-            }
-        });
-        if (!company) {
-            throw new _common.UnauthorizedException('Company not found or inactive');
-        }
-        // Validate branch access
-        const branchPermission = await permissionRepository.findOne({
-            where: {
-                userId: user.id,
-                permissionType: _enums.PermissionType.BRANCH,
-                targetId: branchId
-            }
-        });
-        if (!branchPermission) {
-            throw new _common.UnauthorizedException('No access to this branch');
-        }
-        const branch = await branchRepository.findOne({
-            where: {
-                id: branchId,
-                companyId,
-                isActive: true
-            }
-        });
-        if (!branch) {
-            throw new _common.UnauthorizedException('Branch not found or inactive');
-        }
-        return this.generateLoginResponseWithCompany(user, company, branch);
+        return this.validateAndLoginWithCompany(session.userId, companyId, branchId);
     }
     /** Switch company/branch after login */ async switchCompany(userId, companyId, branchId) {
         this.ensureCompanyFeatureEnabled();
+        return this.validateAndLoginWithCompany(userId, companyId, branchId);
+    }
+    /** Shared: Validate user access to company/branch and generate login response */ async validateAndLoginWithCompany(userId, companyId, branchId) {
         const userRepository = await this.getUserRepository();
         const user = await userRepository.findOne({
             where: {
@@ -404,14 +433,14 @@ let AuthenticationService = class AuthenticationService {
             throw new _common.BadRequestException('Repositories not available');
         }
         // Validate company access
-        const companyPermission = await permissionRepository.findOne({
+        const hasCompanyAccess = await permissionRepository.findOne({
             where: {
                 userId,
                 permissionType: _enums.PermissionType.COMPANY,
                 targetId: companyId
             }
         });
-        if (!companyPermission) {
+        if (!hasCompanyAccess) {
             throw new _common.UnauthorizedException('No access to this company');
         }
         const company = await companyRepository.findOne({
@@ -423,14 +452,15 @@ let AuthenticationService = class AuthenticationService {
         if (!company) {
             throw new _common.UnauthorizedException('Company not found or inactive');
         }
-        const branchPermission = await permissionRepository.findOne({
+        // Validate branch access
+        const hasBranchAccess = await permissionRepository.findOne({
             where: {
                 userId,
                 permissionType: _enums.PermissionType.BRANCH,
                 targetId: branchId
             }
         });
-        if (!branchPermission) {
+        if (!hasBranchAccess) {
             throw new _common.UnauthorizedException('No access to this branch');
         }
         const branch = await branchRepository.findOne({
@@ -451,6 +481,9 @@ let AuthenticationService = class AuthenticationService {
             const payload = this.jwtService.verify(refreshToken, {
                 secret: this.authConfig.getRefreshTokenSecret()
             });
+            if (await this.isTokenRevoked(payload.id, payload.iat)) {
+                throw new _common.UnauthorizedException('Token has been revoked');
+            }
             const userRepository = await this.getUserRepository();
             const user = await userRepository.findOne({
                 where: {
@@ -460,7 +493,7 @@ let AuthenticationService = class AuthenticationService {
             if (!user || !user.isActive) {
                 throw new _common.UnauthorizedException('Invalid refresh token');
             }
-            const accessPayload = {
+            return this.generateTokens({
                 id: user.id,
                 email: user.email,
                 type: 'access',
@@ -470,44 +503,9 @@ let AuthenticationService = class AuthenticationService {
                 },
                 ...payload.branchId && {
                     branchId: payload.branchId
-                },
-                ...payload.companyLogoId && {
-                    companyLogoId: payload.companyLogoId
-                },
-                ...payload.branchLogoId && {
-                    branchLogoId: payload.branchLogoId
                 }
-            };
-            const refreshPayload = {
-                id: user.id,
-                email: user.email,
-                type: 'refresh',
-                profilePictureId: user.profilePictureId ?? undefined,
-                ...payload.companyId && {
-                    companyId: payload.companyId
-                },
-                ...payload.branchId && {
-                    branchId: payload.branchId
-                },
-                ...payload.companyLogoId && {
-                    companyLogoId: payload.companyLogoId
-                },
-                ...payload.branchLogoId && {
-                    branchLogoId: payload.branchLogoId
-                }
-            };
-            return {
-                accessToken: this.jwtService.sign(accessPayload, {
-                    secret: this.authConfig.getJwtSecret(),
-                    expiresIn: this.authConfig.getJwtExpiration()
-                }),
-                refreshToken: this.jwtService.sign(refreshPayload, {
-                    secret: this.authConfig.getRefreshTokenSecret(),
-                    expiresIn: this.authConfig.getRefreshTokenExpiration()
-                })
-            };
+            });
         } catch (error) {
-            // Log error details for debugging (not exposed to client)
             _utils.ErrorHandler.logError(this.logger, error, 'refreshToken');
             throw new _common.UnauthorizedException('Invalid or expired refresh token');
         }
@@ -519,11 +517,8 @@ let AuthenticationService = class AuthenticationService {
                 id: userId
             }
         });
-        if (!user) {
-            throw new _common.UnauthorizedException('User not found');
-        }
-        const isPasswordValid = await _bcrypt.compare(currentPassword, user.password || '');
-        if (!isPasswordValid) {
+        if (!user) throw new _common.UnauthorizedException('User not found');
+        if (!await _bcrypt.compare(currentPassword, user.password || '')) {
             throw new _common.UnauthorizedException('Current password is incorrect');
         }
         user.password = await _bcrypt.hash(newPassword, _config.BCRYPT_SALT_ROUNDS);
@@ -531,8 +526,9 @@ let AuthenticationService = class AuthenticationService {
     }
     /** Logout - Revokes all tokens. Stores revocation timestamp in cache. */ async logout(userId) {
         if (!this.cacheManager) {
-            // Cache not available - graceful degradation (client-side logout only)
-            return;
+            // Cache is required for secure logout - tokens cannot be revoked without it
+            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 _common.BadRequestException('Logout service temporarily unavailable. Please try again later.');
         }
         const revokedAt = Math.floor(Date.now() / 1000); // Unix timestamp in seconds
         const cacheKey = `${_config.TOKEN_REVOKED_PREFIX}:${userId}`;
@@ -540,6 +536,7 @@ let AuthenticationService = class AuthenticationService {
         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`);
     }
     /** Check if a token is revoked (issued before user's revocation timestamp) */ async isTokenRevoked(userId, tokenIssuedAt) {
         if (!this.cacheManager || !tokenIssuedAt) {
@@ -657,53 +654,28 @@ let AuthenticationService = class AuthenticationService {
                 id: userId
             }
         });
-        if (!user) {
-            throw new _common.UnauthorizedException('User not found');
-        }
-        // Build response (no tokens)
+        if (!user) throw new _common.UnauthorizedException('User not found');
         const response = {
-            user: {
-                id: user.id,
-                email: user.email,
-                name: user.name ?? undefined,
-                profilePictureId: user.profilePictureId ?? undefined
-            }
+            user: this.toUserInfo(user)
         };
-        // Add company/branch if available (when company feature is enabled)
-        if (this.authConfig.isCompanyFeatureEnabled()) {
-            // When company feature is enabled, companyId MUST be present
+        if (this.isCompanyFeatureEnabled()) {
             if (!companyId) {
-                throw new _common.UnauthorizedException('Company feature is enabled but user has no company assigned. Please select a company.');
+                throw new _common.UnauthorizedException('Company feature is enabled but user has no company assigned.');
             }
             const company = await this.getCompanyById(companyId);
-            if (!company) {
-                throw new _common.UnauthorizedException(`Company with ID ${companyId} not found. Please select a valid company.`);
-            }
-            response.company = {
-                id: company.id,
-                name: company.name,
-                slug: company.slug,
-                logoId: company.logoId ?? null
-            };
-            // Branch is optional in some configurations, but if provided it must exist
+            if (!company) throw new _common.UnauthorizedException('Company not found.');
+            response.company = this.toCompanyInfo(company);
             if (branchId) {
                 const branch = await this.getBranchById(branchId);
-                if (!branch) {
-                    throw new _common.UnauthorizedException(`Branch with ID ${branchId} not found. Please select a valid branch.`);
-                }
-                response.branch = {
-                    id: branch.id,
-                    name: branch.name,
-                    slug: branch.slug,
-                    logoId: branch.logoId ?? null
-                };
+                if (!branch) throw new _common.UnauthorizedException('Branch not found.');
+                response.branch = this.toBranchInfo(branch);
             }
         }
         return response;
     }
     // Helper Methods
     ensureCompanyFeatureEnabled() {
-        if (!this.authConfig.isCompanyFeatureEnabled()) {
+        if (!this.isCompanyFeatureEnabled()) {
             throw new _common.BadRequestException('Company feature is not enabled');
         }
     }
@@ -714,11 +686,7 @@ let AuthenticationService = class AuthenticationService {
                 email
             }
         });
-        if (!user) {
-            throw new _common.UnauthorizedException('Invalid credentials');
-        }
-        const isPasswordValid = await _bcrypt.compare(password, user.password || '');
-        if (!isPasswordValid) {
+        if (!user || !await _bcrypt.compare(password, user.password || '')) {
             throw new _common.UnauthorizedException('Invalid credentials');
         }
         user.lastLoginAt = new Date();
@@ -726,82 +694,77 @@ let AuthenticationService = class AuthenticationService {
         return user;
     }
     // Response Generators
-    generateLoginResponse(user, companyFeatureEnabled = false) {
-        const payload = {
+    /** Create user info object */ toUserInfo(user) {
+        return {
             id: user.id,
             email: user.email,
-            type: 'access'
+            name: user.name ?? undefined,
+            phone: user.phone ?? null,
+            profilePictureId: user.profilePictureId ?? null
+        };
+    }
+    /** Create company info object */ toCompanyInfo(company) {
+        return {
+            id: company.id,
+            name: company.name,
+            slug: company.slug,
+            logoId: company.logoId ?? null
+        };
+    }
+    /** Create branch info object */ toBranchInfo(branch) {
+        return {
+            id: branch.id,
+            name: branch.name,
+            slug: branch.slug,
+            logoId: branch.logoId ?? null
         };
-        const accessToken = this.jwtService.sign(payload, {
+    }
+    /** Generate JWT tokens */ generateTokens(payload) {
+        const accessToken = this.jwtService.sign({
+            ...payload,
+            type: 'access'
+        }, {
             secret: this.authConfig.getJwtSecret(),
             expiresIn: this.authConfig.getJwtExpiration()
         });
-        const refreshPayload = {
-            id: user.id,
-            email: user.email,
+        const refreshToken = this.jwtService.sign({
+            ...payload,
             type: 'refresh'
-        };
-        const refreshToken = this.jwtService.sign(refreshPayload, {
+        }, {
             secret: this.authConfig.getRefreshTokenSecret(),
             expiresIn: this.authConfig.getRefreshTokenExpiration()
         });
         return {
             accessToken,
-            refreshToken,
-            user: {
-                id: user.id,
-                email: user.email,
-                name: user.name ?? undefined,
-                profilePictureId: user.profilePictureId ?? null
-            },
-            companyFeatureEnabled
+            refreshToken
         };
     }
-    generateLoginResponseWithCompany(user, company, branch) {
-        const payload = {
+    generateLoginResponse(user) {
+        const { accessToken, refreshToken } = this.generateTokens({
             id: user.id,
             email: user.email,
-            type: 'access',
-            companyId: company.id,
-            branchId: branch?.id
-        };
-        const accessToken = this.jwtService.sign(payload, {
-            secret: this.authConfig.getJwtSecret(),
-            expiresIn: this.authConfig.getJwtExpiration()
+            type: 'access'
         });
-        const refreshPayload = {
+        return {
+            accessToken,
+            refreshToken,
+            user: this.toUserInfo(user)
+        };
+    }
+    generateLoginResponseWithCompany(user, company, branch) {
+        const { accessToken, refreshToken } = this.generateTokens({
             id: user.id,
             email: user.email,
-            type: 'refresh',
+            type: 'access',
             companyId: company.id,
             branchId: branch?.id
-        };
-        const refreshToken = this.jwtService.sign(refreshPayload, {
-            secret: this.authConfig.getRefreshTokenSecret(),
-            expiresIn: this.authConfig.getRefreshTokenExpiration()
         });
         return {
             accessToken,
             refreshToken,
-            user: {
-                id: user.id,
-                email: user.email,
-                name: user.name ?? undefined,
-                profilePictureId: user.profilePictureId ?? null
-            },
-            company: {
-                id: company.id,
-                name: company.name,
-                slug: company.slug,
-                logoId: company.logoId ?? null
-            },
-            branch: branch ? {
-                id: branch.id,
-                name: branch.name,
-                slug: branch.slug,
-                logoId: branch.logoId ?? null
-            } : undefined,
-            companyFeatureEnabled: true
+            user: this.toUserInfo(user),
+            company: this.toCompanyInfo(company),
+            branch: branch ? this.toBranchInfo(branch) : undefined
         };
     }
     async generateCompanySelectionResponse(user, companies, branches) {
@@ -809,55 +772,49 @@ let AuthenticationService = class AuthenticationService {
             throw new _common.BadRequestException('Session service not available');
         }
         const sessionId = await this.sessionService.createSession(user.id);
-        // Build companies with their branches
         const companiesWithBranches = companies.map((company)=>({
-                id: company.id,
-                name: company.name,
-                slug: company.slug,
+                ...this.toCompanyInfo(company),
                 isActive: company.isActive,
-                logoId: company.logoId ?? null,
                 branches: branches.filter((b)=>b.companyId === company.id).map((b)=>({
-                        id: b.id,
-                        name: b.name,
-                        slug: b.slug,
-                        isActive: b.isActive,
-                        logoId: b.logoId ?? null
+                        ...this.toBranchInfo(b),
+                        isActive: b.isActive
                     }))
             }));
         return {
             requiresSelection: true,
             sessionId,
             expiresAt: new Date(Date.now() + 5 * 60 * 1000),
-            user: {
-                id: user.id,
-                email: user.email,
-                name: user.name ?? undefined,
-                profilePictureId: user.profilePictureId ?? null
-            },
+            user: this.toUserInfo(user),
             companies: companiesWithBranches
         };
     }
+    generateRegistrationResponse(user) {
+        return {
+            ...this.generateLoginResponse(user),
+            requiresEmailVerification: false
+        };
+    }
+    generateRegistrationResponseWithCompany(user, company, branch) {
+        return {
+            ...this.generateLoginResponseWithCompany(user, company, branch),
+            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){
         _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, "injectedUserRepository", void 0);
-        _define_property(this, "injectedPermissionRepository", void 0);
-        _define_property(this, "injectedCompanyRepository", void 0);
-        _define_property(this, "injectedBranchRepository", void 0);
+        _define_property(this, "authEmailService", void 0);
         _define_property(this, "logger", void 0);
         this.jwtService = jwtService;
         this.authConfig = authConfig;
         this.cacheManager = cacheManager;
         this.dataSourceProvider = dataSourceProvider;
         this.sessionService = sessionService;
-        this.injectedUserRepository = injectedUserRepository;
-        this.injectedPermissionRepository = injectedPermissionRepository;
-        this.injectedCompanyRepository = injectedCompanyRepository;
-        this.injectedBranchRepository = injectedBranchRepository;
+        this.authEmailService = authEmailService;
         this.logger = new _common.Logger(AuthenticationService.name);
     }
 };
@@ -874,13 +831,7 @@ 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(6, (0, _common.Optional)()),
-    _ts_param(6, (0, _typeorm.InjectRepository)(_usercompanypermissionentity.UserCompanyPermission)),
-    _ts_param(7, (0, _common.Optional)()),
-    _ts_param(7, (0, _typeorm.InjectRepository)(_companyentity.Company)),
-    _ts_param(8, (0, _common.Optional)()),
-    _ts_param(8, (0, _typeorm.InjectRepository)(_companybranchentity.CompanyBranch)),
+    _ts_param(5, (0, _common.Inject)(_authemailservice.AuthEmailService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _jwt.JwtService === "undefined" ? Object : _jwt.JwtService,
@@ -888,9 +839,6 @@ 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 _typeorm1.Repository === "undefined" ? Object : _typeorm1.Repository,
-        typeof _typeorm1.Repository === "undefined" ? Object : _typeorm1.Repository,
-        typeof _typeorm1.Repository === "undefined" ? Object : _typeorm1.Repository,
-        typeof _typeorm1.Repository === "undefined" ? Object : _typeorm1.Repository
+        typeof _authemailservice.AuthEmailService === "undefined" ? Object : _authemailservice.AuthEmailService
     ])
 ], AuthenticationService);