@flusys/nestjs-auth 1.0.0-rc → 1.0.1

package/cjs/services/branch.service.js

@@ -77,11 +77,15 @@ let BranchService = class BranchService extends _classes.RequestScopedApiService
     }
     async getExtraManipulateQuery(query, filterDto, user) {
         const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        (0, _utils.applyCompanyFilter)(query, {
-            isCompanyFeatureEnabled: this.authConfig.isCompanyFeatureEnabled(),
-            entityAlias: 'company_branch',
-            columnName: 'company_id'
-        }, user);
+        // Only apply company filter if companyId is NOT explicitly provided in filter
+        // This prevents dual filtering when user selects a specific company
+        if (!filterDto?.filter?.companyId) {
+            (0, _utils.applyCompanyFilter)(query, {
+                isCompanyFeatureEnabled: this.authConfig.isCompanyFeatureEnabled(),
+                entityAlias: 'company_branch',
+                columnName: 'company_id'
+            }, user);
+        }
         return result;
     }
     constructor(cacheManager, utilsService, dataSourceProvider, authConfig){

package/cjs/services/user-permission.service.js

@@ -39,120 +39,92 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let UserPermissionService = class UserPermissionService {
-    /** Get repository lazily - initialized on first access */ async getRepository() {
+    async getRepository() {
         if (!this._repository) {
             this._repository = await this.dataSourceProvider.getRepository(_usercompanypermissionentity.UserCompanyPermission);
         }
         return this._repository;
     }
-    // Company Permissions
-    /** Find all companies a user has access to */ async findUserCompanies(userId) {
+    // Generic Permission Operations
+    /** Find all permissions of a specific type for a user */ async findUserPermissions(userId, type) {
         const repository = await this.getRepository();
         return repository.find({
             where: {
                 userId,
-                permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+                permissionType: type
             },
             relations: [
-                'company'
+                type === _usercompanypermissionentity.PermissionType.COMPANY ? 'company' : 'branch'
             ],
             order: {
                 createdAt: 'DESC'
             }
         });
     }
-    /** Assign user to a company */ async assignUserToCompany(dto) {
+    /** Assign permission to user */ async assignPermission(userId, targetId, type, metadata) {
         const repository = await this.getRepository();
-        // Check if already exists
+        const typeName = type === _usercompanypermissionentity.PermissionType.COMPANY ? 'company' : 'branch';
         const existing = await repository.findOne({
             where: {
-                userId: dto.userId,
-                targetId: dto.companyId,
-                permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+                userId,
+                targetId,
+                permissionType: type
             }
         });
         if (existing) {
-            throw new _common.BadRequestException('User already assigned to this company');
+            throw new _common.ConflictException(`User already assigned to this ${typeName}`);
         }
-        const permission = repository.create({
-            userId: dto.userId,
-            permissionType: _usercompanypermissionentity.PermissionType.COMPANY,
-            targetId: dto.companyId,
-            metadata: dto.metadata
-        });
-        await repository.save(permission);
-    }
-    /** Revoke user access to a company */ async revokeCompanyAccess(userId, companyId) {
-        const repository = await this.getRepository();
-        const permission = await repository.findOne({
-            where: {
+        try {
+            await repository.save(repository.create({
                 userId,
-                targetId: companyId,
-                permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+                permissionType: type,
+                targetId,
+                metadata
+            }));
+        } catch (error) {
+            if (error?.code === 'ER_DUP_ENTRY' || error?.message?.includes('Duplicate entry')) {
+                throw new _common.ConflictException(`User already assigned to this ${typeName}. Please refresh and try again.`);
             }
-        });
-        if (!permission) {
-            throw new _common.NotFoundException('Company permission not found');
+            throw error;
         }
-        await repository.remove(permission);
     }
-    // Branch Permissions
-    /** Find all branches a user has access to */ async findUserBranches(userId) {
-        const repository = await this.getRepository();
-        return repository.find({
-            where: {
-                userId,
-                permissionType: _usercompanypermissionentity.PermissionType.BRANCH
-            },
-            relations: [
-                'branch'
-            ],
-            order: {
-                createdAt: 'DESC'
-            }
-        });
-    }
-    /** Assign user to a branch */ async assignUserToBranch(dto) {
-        const repository = await this.getRepository();
-        // Check if already exists
-        const existing = await repository.findOne({
-            where: {
-                userId: dto.userId,
-                targetId: dto.branchId,
-                permissionType: _usercompanypermissionentity.PermissionType.BRANCH
-            }
-        });
-        if (existing) {
-            throw new _common.BadRequestException('User already assigned to this branch');
-        }
-        const permission = repository.create({
-            userId: dto.userId,
-            permissionType: _usercompanypermissionentity.PermissionType.BRANCH,
-            targetId: dto.branchId,
-            metadata: dto.metadata
-        });
-        await repository.save(permission);
-    }
-    /** Revoke user access to a branch */ async revokeBranchAccess(userId, branchId) {
+    /** Revoke permission from user */ async revokePermission(userId, targetId, type) {
         const repository = await this.getRepository();
+        const typeName = type === _usercompanypermissionentity.PermissionType.COMPANY ? 'company' : 'branch';
         const permission = await repository.findOne({
             where: {
                 userId,
-                targetId: branchId,
-                permissionType: _usercompanypermissionentity.PermissionType.BRANCH
+                targetId,
+                permissionType: type
             }
         });
         if (!permission) {
-            throw new _common.NotFoundException('Branch permission not found');
+            throw new _common.NotFoundException(`${typeName.charAt(0).toUpperCase() + typeName.slice(1)} permission not found`);
         }
         await repository.remove(permission);
     }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    /** Find user branch permissions with optional company filter */ async findUserBranches(userId, companyId) {
+        const repository = await this.getRepository();
+        const queryBuilder = repository.createQueryBuilder('permission').leftJoinAndSelect('permission.branch', 'branch').where('permission.userId = :userId', {
+            userId
+        }).andWhere('permission.permissionType = :type', {
+            type: _usercompanypermissionentity.PermissionType.BRANCH
+        }).orderBy('permission.createdAt', 'DESC');
+        if (companyId) {
+            queryBuilder.andWhere('branch.companyId = :companyId', {
+                companyId
+            });
+        }
+        return queryBuilder.getMany();
+    }
     constructor(dataSourceProvider){
         _define_property(this, "dataSourceProvider", void 0);
         _define_property(this, "_repository", void 0);
+        // Convenience Methods
+        _define_property(this, "findUserCompanies", void 0);
         this.dataSourceProvider = dataSourceProvider;
         this._repository = null;
+        this.findUserCompanies = (userId)=>this.findUserPermissions(userId, _usercompanypermissionentity.PermissionType.COMPANY);
     }
 };
 UserPermissionService = _ts_decorate([

package/cjs/services/user.service.js

@@ -111,12 +111,22 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     }
     // Custom Methods
     /**
-   * Validate that the requesting user owns the target profile.
-   * Users can only access/modify their own profile data.
-   */ validateProfileOwnership(targetUserId, requestingUser) {
-        if (targetUserId !== requestingUser.id) {
+   * Validate profile ownership, ensure repository initialized, and fetch user.
+   * Throws ForbiddenException if not owner, NotFoundException if user not found.
+   */ async getUserForProfile(userId, user) {
+        if (userId !== user.id) {
             throw new _common.ForbiddenException('Cannot access another user\'s profile');
         }
+        await this.ensureRepositoryInitialized();
+        const userEntity = await this.repository.findOne({
+            where: {
+                id: userId
+            }
+        });
+        if (!userEntity) {
+            throw new _common.NotFoundException('User not found');
+        }
+        return userEntity;
     }
     /** Verify email */ async verifyEmail(id) {
         // Ensure repository is initialized for custom method
@@ -375,16 +385,7 @@ let UserService = class UserService extends _classes.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) {
-        this.validateProfileOwnership(userId, user);
-        await this.ensureRepositoryInitialized();
-        const userEntity = await this.repository.findOne({
-            where: {
-                id: userId
-            }
-        });
-        if (!userEntity) {
-            throw new _common.NotFoundException('User not found');
-        }
+        const userEntity = await this.getUserForProfile(userId, user);
         const userData = this.convertEntityToResponseDto(userEntity, false);
         // Get extras from enricher if available
         let extras;
@@ -419,17 +420,7 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     /**
    * Get specific profile section data
    */ async getProfileSectionData(userId, sectionId, user) {
-        this.validateProfileOwnership(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');
-        }
+        await this.getUserForProfile(userId, user);
         if (this.userEnricher?.getProfileSectionData) {
             return this.userEnricher.getProfileSectionData(userId, sectionId, user);
         }
@@ -438,20 +429,10 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     /**
    * Update specific profile section
    */ async updateProfileSection(userId, sectionId, data, user) {
-        this.validateProfileOwnership(userId, user);
-        await this.ensureRepositoryInitialized();
+        const userEntity = await this.getUserForProfile(userId, user);
         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');
         }
@@ -478,17 +459,7 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     /**
    * Get profile completion percentage
    */ async getProfileCompletion(userId, user) {
-        this.validateProfileOwnership(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');
-        }
+        await this.getUserForProfile(userId, user);
         if (this.userEnricher?.calculateProfileCompletion) {
             return this.userEnricher.calculateProfileCompletion(userId, user);
         }

package/cjs/strategies/jwt.strategy.js

@@ -12,10 +12,10 @@ const _common = require("@nestjs/common");
 const _core = require("@nestjs/core");
 const _passport = require("@nestjs/passport");
 const _passportjwt = require("passport-jwt");
+const _userentity = require("../entities/user.entity");
 const _authconfigservice = require("../services/auth-config.service");
 const _authdatasourceprovider = require("../services/auth-datasource.provider");
 const _authenticationservice = require("../services/authentication.service");
-const _userentity = require("../entities/user.entity");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -38,71 +38,71 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-/**
- * Type guard to check if payload includes company context
- */ function isTokenPayloadWithCompany(payload) {
+function hasCompanyContext(payload) {
     return 'companyId' in payload && 'branchId' in payload;
 }
 let JwtStrategy = class JwtStrategy extends (0, _passport.PassportStrategy)(_passportjwt.Strategy, 'jwt') {
     async validate(_req, payload) {
-        // Resolve request-scoped services for this request
-        let userRepository = null;
-        let authService = null;
+        const userRepo = await this.resolveUserRepository();
+        await this.checkTokenRevocation(payload);
+        const user = await userRepo.findOne({
+            where: {
+                id: payload.id,
+                isActive: true
+            }
+        });
+        if (!user) {
+            throw new _common.UnauthorizedException('User not found or inactive');
+        }
+        return this.buildUserInfo(payload);
+    }
+    async resolveUserRepository() {
         try {
-            const dataSourceProvider = await this.moduleRef.resolve(_authdatasourceprovider.AuthDataSourceProvider, undefined, {
+            const provider = await this.moduleRef.resolve(_authdatasourceprovider.AuthDataSourceProvider, undefined, {
                 strict: false
             });
-            if (dataSourceProvider) {
-                userRepository = await dataSourceProvider.getRepository(_userentity.User);
+            if (provider) {
+                return provider.getRepository(_userentity.User);
             }
-            // Resolve AuthenticationService for token revocation check
-            authService = await this.moduleRef.resolve(_authenticationservice.AuthenticationService, undefined, {
-                strict: false
-            });
-        } catch (error) {
+        } catch  {
             throw new _common.UnauthorizedException('Unable to access user data');
         }
-        if (!userRepository) {
-            throw new _common.UnauthorizedException('User repository not available');
-        }
-        // Check if token is revoked (logged out)
-        if (authService && payload.iat) {
-            const isRevoked = await authService.isTokenRevoked(payload.id, payload.iat);
-            if (isRevoked) {
+        throw new _common.UnauthorizedException('User repository not available');
+    }
+    async checkTokenRevocation(payload) {
+        if (!payload.iat) return;
+        try {
+            const authService = await this.moduleRef.resolve(_authenticationservice.AuthenticationService, undefined, {
+                strict: false
+            });
+            if (authService && await authService.isTokenRevoked(payload.id, payload.iat)) {
                 throw new _common.UnauthorizedException('Token has been revoked');
             }
+        } catch (err) {
+            if (err instanceof _common.UnauthorizedException) throw err;
         }
-        // Find user and check if active
-        const user = await userRepository.findOne({
-            where: {
-                id: payload.id,
-                isActive: true
-            }
-        });
-        if (!user) {
-            throw new _common.UnauthorizedException('User not found or inactive');
-        }
-        const result = {
+    }
+    buildUserInfo(payload) {
+        const base = {
             id: payload.id,
             email: payload.email
         };
-        // Company context - use type guard for type safety
-        if (isTokenPayloadWithCompany(payload)) {
-            result.companyId = payload.companyId;
-            // Only set branchId if it's not empty string
-            if (payload.branchId) {
-                result.branchId = payload.branchId;
-            }
+        if (!hasCompanyContext(payload)) {
+            return base;
         }
-        return result;
+        return {
+            ...base,
+            companyId: payload.companyId,
+            ...payload.branchId && {
+                branchId: payload.branchId
+            }
+        };
     }
     constructor(authConfig, moduleRef){
         super({
             jwtFromRequest: _passportjwt.ExtractJwt.fromAuthHeaderAsBearerToken(),
             ignoreExpiration: false,
-            // Use secretOrKeyProvider instead of secretOrKey to defer secret lookup
-            // This ensures AuthConfigService is fully initialized when using forRootAsync
-            secretOrKeyProvider: (_request, _rawJwtToken, done)=>{
+            secretOrKeyProvider: (_req, _token, done)=>{
                 done(null, this.authConfig.getJwtSecret());
             },
             passReqToCallback: true

package/controllers/authentication.controller.d.ts

@@ -1,7 +1,7 @@
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { Request } from 'express';
-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 { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
 import { AuthConfigService } from '../services/auth-config.service';
 import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
@@ -11,7 +11,9 @@ export declare class AuthenticationController {
     private readonly authEmailService?;
     constructor(authService: AuthenticationService, authConfig?: AuthConfigService, authEmailService?: AuthEmailService);
     private buildAuthUrl;
-    login(loginDto: LoginDto): Promise<LoginResponseDto | CompanySelectionResponseDto>;
+    private get emailService();
+    private get isEmailEnabled();
+    login(loginDto: LoginDto): Promise<LoginResponseDto | CompanySelectionResponseDto | LoginResponseRequiresEmailVerificationDto>;
     register(req: Request, registrationDto: RegistrationDto): Promise<RegistrationResponseDto>;
     refreshToken(req: Request, refreshTokenDto: RefreshTokenDto): Promise<{
         accessToken: string;

package/controllers/user-permission.controller.d.ts

@@ -1,8 +1,8 @@
-import { AssignUserCompanyDto, AssignUserBranchDto, UserCompaniesResponseDto, UserBranchesResponseDto } from '../dtos/user-permission.dto';
+import { AssignUserBranchDto, AssignUserCompanyDto, UserBranchesResponseDto, UserCompaniesResponseDto } from '../dtos/user-permission.dto';
 import { UserPermissionService } from '../services/user-permission.service';
 export declare class UserPermissionController {
-    private readonly userPermissionService;
-    constructor(userPermissionService: UserPermissionService);
+    private readonly permissionService;
+    constructor(permissionService: UserPermissionService);
     assignUserCompany(dto: AssignUserCompanyDto): Promise<{
         success: boolean;
         message: string;
@@ -12,5 +12,6 @@ export declare class UserPermissionController {
         success: boolean;
         message: string;
     }>;
-    getUserBranches(userId: string): Promise<UserBranchesResponseDto>;
+    getUserBranches(userId: string, companyId?: string): Promise<UserBranchesResponseDto>;
+    private processBatchPermissions;
 }

package/dtos/authentication.dto.d.ts

@@ -51,14 +51,12 @@ export declare class BranchSelectionInfoDto {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
 }
 export declare class CompanyWithBranchesDto {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
     branches: BranchSelectionInfoDto[];
 }
@@ -68,7 +66,6 @@ export declare class LoginResponseDto {
     user: UserInfoDto;
     company?: CompanyInfoDto;
     branch?: BranchInfoDto;
-    companyFeatureEnabled?: boolean;
 }
 export declare class RegistrationResponseDto {
     accessToken?: string;
@@ -76,7 +73,6 @@ export declare class RegistrationResponseDto {
     user: UserInfoDto;
     company?: CompanyInfoDto;
     branch?: BranchInfoDto;
-    companyFeatureEnabled?: boolean;
     requiresEmailVerification?: boolean;
 }
 export declare class MeResponseDto {

package/dtos/index.d.ts

@@ -1,6 +1,5 @@
 export * from './authentication.dto';
 export * from './company-branch.dto';
 export * from './company.dto';
-export * from './user-company-permission.dto';
 export * from './user.dto';
 export * from './user-permission.dto';

package/entities/index.d.ts

@@ -10,7 +10,7 @@ import { PendingRegistration } from './pending-registration.entity';
 import { UserCompanyPermission } from './user-company-permission.entity';
 import { User } from './user.entity';
 import { UserToken } from './user-token.entity';
-export declare const CoreEntities: (typeof PendingRegistration | typeof User | typeof UserToken)[];
+export declare const CoreEntities: (typeof PendingRegistration | typeof UserToken | typeof User)[];
 export declare const CompanyEntities: (typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];
-export declare const AllEntities: (typeof Company | typeof CompanyBranch | typeof PendingRegistration | typeof User | typeof UserCompanyPermission | typeof UserToken)[];
-export declare function getEntitiesByConfig(enableCompanyFeature: boolean): (typeof Company | typeof CompanyBranch | typeof PendingRegistration | typeof User | typeof UserCompanyPermission | typeof UserToken)[];
+export declare const AllEntities: (typeof PendingRegistration | typeof UserToken | typeof User | typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];
+export declare function getEntitiesByConfig(enableCompanyFeature: boolean): (typeof PendingRegistration | typeof UserToken | typeof User | typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];

package/entities/user-company-permission.entity.d.ts

@@ -7,7 +7,7 @@ export declare class UserCompanyPermission {
     id: string;
     userId: string;
     user?: User;
-    permissionType: PermissionType;
+    permissionType: string;
     targetId: string;
     metadata?: Record<string, any>;
     isActive: boolean;