@flusys/nestjs-auth 1.1.0-beta → 2.0.0

package/fesm/services/branch.service.js

@@ -27,6 +27,7 @@ function _ts_param(paramIndex, decorator) {
 }
 import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
 import { Inject, Injectable, Scope } from '@nestjs/common';
 import { CompanyBranch } from '../entities/company-branch.entity';
 import { AuthConfigService } from './auth-config.service';
@@ -66,10 +67,14 @@ export class BranchService extends RequestScopedApiService {
     }
     async getExtraManipulateQuery(query, filterDto, user) {
         const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        if (this.authConfig.isCompanyFeatureEnabled() && user?.companyId) {
-            query.andWhere('company_branch.company_id = :companyId', {
-                companyId: user.companyId
-            });
+        // 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) {
+            applyCompanyFilter(query, {
+                isCompanyFeatureEnabled: this.authConfig.isCompanyFeatureEnabled(),
+                entityAlias: 'company_branch',
+                columnName: 'company_id'
+            }, user);
         }
         return result;
     }

package/fesm/services/company-selection-session.service.js

@@ -33,7 +33,7 @@ const SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 export class CompanySelectionSessionService {
     /**
    * Create a new session for company/branch selection
-   */ async createSession(userId, companyId) {
+   */ async createSession(userId) {
         const sessionId = randomUUID();
         const now = new Date();
         const expiresAt = new Date(now.getTime() + SESSION_TTL_MS);

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

@@ -25,126 +25,96 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { BadRequestException, Inject, Injectable, Logger, NotFoundException, Scope } from '@nestjs/common';
+import { ConflictException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
 import { PermissionType, UserCompanyPermission } from '../entities/user-company-permission.entity';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
 export class UserPermissionService {
-    /** Get repository lazily - initialized on first access */ async getRepository() {
+    async getRepository() {
         if (!this._repository) {
             this._repository = await this.dataSourceProvider.getRepository(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: PermissionType.COMPANY
+                permissionType: type
             },
             relations: [
-                'company'
+                type === 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 === PermissionType.COMPANY ? 'company' : 'branch';
         const existing = await repository.findOne({
             where: {
-                userId: dto.userId,
-                targetId: dto.companyId,
-                permissionType: PermissionType.COMPANY
+                userId,
+                targetId,
+                permissionType: type
             }
         });
         if (existing) {
-            throw new BadRequestException('User already assigned to this company');
+            throw new ConflictException(`User already assigned to this ${typeName}`);
         }
-        const permission = repository.create({
-            userId: dto.userId,
-            permissionType: 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: PermissionType.COMPANY
+                permissionType: type,
+                targetId,
+                metadata
+            }));
+        } catch (error) {
+            if (error?.code === 'ER_DUP_ENTRY' || error?.message?.includes('Duplicate entry')) {
+                throw new ConflictException(`User already assigned to this ${typeName}. Please refresh and try again.`);
             }
-        });
-        if (!permission) {
-            throw new 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: 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: PermissionType.BRANCH
-            }
-        });
-        if (existing) {
-            throw new BadRequestException('User already assigned to this branch');
-        }
-        const permission = repository.create({
-            userId: dto.userId,
-            permissionType: 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 === PermissionType.COMPANY ? 'company' : 'branch';
         const permission = await repository.findOne({
             where: {
                 userId,
-                targetId: branchId,
-                permissionType: PermissionType.BRANCH
+                targetId,
+                permissionType: type
             }
         });
         if (!permission) {
-            throw new NotFoundException('Branch permission not found');
+            throw new 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: 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, "logger", void 0);
         _define_property(this, "_repository", void 0);
+        // Convenience Methods
+        _define_property(this, "findUserCompanies", void 0);
         this.dataSourceProvider = dataSourceProvider;
-        this.logger = new Logger(UserPermissionService.name);
         this._repository = null;
+        this.findUserCompanies = (userId)=>this.findUserPermissions(userId, PermissionType.COMPANY);
     }
 }
 UserPermissionService = _ts_decorate([

package/fesm/services/user.service.js

@@ -28,7 +28,7 @@ function _ts_param(paramIndex, decorator) {
 import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { ErrorHandler } from '@flusys/nestjs-shared/utils';
-import { BadRequestException, Inject, Injectable, NotFoundException, Optional, Scope } from '@nestjs/common';
+import { BadRequestException, ForbiddenException, Inject, Injectable, NotFoundException, Optional, Scope } from '@nestjs/common';
 import * as bcrypt from 'bcrypt';
 import { AuthConfigService } from './auth-config.service';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
@@ -59,6 +59,24 @@ export class UserService extends RequestScopedApiService {
         }
     }
     // Custom Methods
+    /**
+   * 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 ForbiddenException('Cannot access another user\'s profile');
+        }
+        await this.ensureRepositoryInitialized();
+        const userEntity = await this.repository.findOne({
+            where: {
+                id: userId
+            }
+        });
+        if (!userEntity) {
+            throw new NotFoundException('User not found');
+        }
+        return userEntity;
+    }
     /** Verify email */ async verifyEmail(id) {
         // Ensure repository is initialized for custom method
         await this.ensureRepositoryInitialized();
@@ -127,26 +145,51 @@ export class UserService extends RequestScopedApiService {
         return entity;
     }
     /** Convert entity to response DTO (removes password). In raw mode with company feature, isActive comes from permission table. */ convertEntityToResponseDto(entity, isRaw) {
+        if (isRaw) {
+            return this.convertRawToResponseDto(entity);
+        }
+        return this.convertEntityToDto(entity);
+    }
+    /** Convert raw query result to response DTO */ convertRawToResponseDto(raw) {
         // When raw mode is used with company feature, isActive comes from computed field
-        // Raw mode uses snake_case column names (due to SnakeNamingStrategy)
-        const isActive = isRaw && entity.user_companyIsActive !== undefined ? Boolean(entity.user_companyIsActive) : isRaw ? entity.user_is_active : entity.isActive;
+        const isActive = raw.user_companyIsActive !== undefined ? Boolean(raw.user_companyIsActive) : raw.user_is_active;
         return {
-            id: isRaw ? entity.user_id : entity.id,
-            name: isRaw ? entity.user_name : entity.name,
-            phone: isRaw ? entity.user_phone : entity.phone,
-            email: isRaw ? entity.user_email : entity.email,
-            profilePictureId: isRaw ? entity.user_profile_picture_id : entity.profilePictureId,
+            id: raw.user_id,
+            name: raw.user_name,
+            phone: raw.user_phone,
+            email: raw.user_email,
+            profilePictureId: raw.user_profile_picture_id,
             isActive,
-            emailVerified: isRaw ? entity.user_email_verified : entity.emailVerified,
-            phoneVerified: isRaw ? entity.user_phone_verified : entity.phoneVerified,
-            lastLoginAt: isRaw ? entity.user_last_login_at : entity.lastLoginAt,
-            additionalFields: isRaw ? entity.user_additional_fields : entity.additionalFields,
-            createdAt: isRaw ? entity.user_created_at : entity.createdAt,
-            updatedAt: isRaw ? entity.user_updated_at : entity.updatedAt,
-            deletedAt: isRaw ? entity.user_deleted_at : entity.deletedAt,
-            createdById: isRaw ? entity.user_created_by_id : entity.createdById,
-            updatedById: isRaw ? entity.user_updated_by_id : entity.updatedById,
-            deletedById: isRaw ? entity.user_deleted_by_id : entity.deletedById
+            emailVerified: raw.user_email_verified,
+            phoneVerified: raw.user_phone_verified,
+            lastLoginAt: raw.user_last_login_at,
+            additionalFields: raw.user_additional_fields,
+            createdAt: raw.user_created_at,
+            updatedAt: raw.user_updated_at,
+            deletedAt: raw.user_deleted_at,
+            createdById: raw.user_created_by_id,
+            updatedById: raw.user_updated_by_id,
+            deletedById: raw.user_deleted_by_id
+        };
+    }
+    /** Convert entity to response DTO */ convertEntityToDto(entity) {
+        return {
+            id: entity.id,
+            name: entity.name,
+            phone: entity.phone,
+            email: entity.email,
+            profilePictureId: entity.profilePictureId,
+            isActive: entity.isActive,
+            emailVerified: entity.emailVerified,
+            phoneVerified: entity.phoneVerified,
+            lastLoginAt: entity.lastLoginAt,
+            additionalFields: entity.additionalFields,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            deletedAt: entity.deletedAt,
+            createdById: entity.createdById,
+            updatedById: entity.updatedById,
+            deletedById: entity.deletedById
         };
     }
     /** Convert entity list to response DTO list */ convertEntityListToResponseListDto(entities, isRaw) {
@@ -291,15 +334,7 @@ export class UserService extends 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 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;
@@ -334,16 +369,7 @@ export class UserService extends RequestScopedApiService {
     /**
    * 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 NotFoundException('User not found');
-        }
+        await this.getUserForProfile(userId, user);
         if (this.userEnricher?.getProfileSectionData) {
             return this.userEnricher.getProfileSectionData(userId, sectionId, user);
         }
@@ -352,19 +378,10 @@ export class UserService extends RequestScopedApiService {
     /**
    * Update specific profile section
    */ async updateProfileSection(userId, sectionId, data, user) {
-        await this.ensureRepositoryInitialized();
+        const userEntity = await this.getUserForProfile(userId, user);
         if (!this.dataSource) {
             throw new BadRequestException('DataSource not available');
         }
-        // Verify user exists
-        const userEntity = await this.repository.findOne({
-            where: {
-                id: userId
-            }
-        });
-        if (!userEntity) {
-            throw new NotFoundException('User not found');
-        }
         if (!this.userEnricher?.updateProfileSection) {
             throw new BadRequestException('Profile sections not supported');
         }
@@ -391,16 +408,7 @@ export class UserService extends RequestScopedApiService {
     /**
    * 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 NotFoundException('User not found');
-        }
+        await this.getUserForProfile(userId, user);
         if (this.userEnricher?.calculateProfileCompletion) {
             return this.userEnricher.calculateProfileCompletion(userId, user);
         }
@@ -431,16 +439,22 @@ export class UserService extends RequestScopedApiService {
             }
             // Handle password update
             if (dto.password) {
-                // If updating own profile, require old password
-                if (!dto.id || dto.id === user.id) {
-                // This would need oldPassword in DTO - for now, skip if not provided
-                // In real implementation, add oldPassword to UpdateUserDto
+                // If updating own profile, require old password verification
+                const isOwnProfile = !dto.id || dto.id === user.id;
+                if (isOwnProfile) {
+                    if (!dto.oldPassword) {
+                        throw new BadRequestException('Current password is required to change your password');
+                    }
+                    const isPasswordValid = await bcrypt.compare(dto.oldPassword, findUser.password);
+                    if (!isPasswordValid) {
+                        throw new BadRequestException('Current password is incorrect');
+                    }
                 }
-                const salt = await bcrypt.genSalt();
-                findUser.password = await bcrypt.hash(dto.password, salt);
+                findUser.password = await bcrypt.hash(dto.password, BCRYPT_SALT_ROUNDS);
             }
-            // Merge other fields (excluding password and extras)
-            const { password, extras, ...restDto } = dto;
+            // Merge other fields (excluding password, oldPassword, extras, and sensitive flags)
+            // Users cannot self-modify emailVerified, phoneVerified, or isActive via profile update
+            const { password, oldPassword, extras, emailVerified, phoneVerified, isActive, ...restDto } = dto;
             Object.assign(findUser, restDto);
             await queryRunner.manager.save(this.repository.target, findUser);
             // Handle extras update via enricher

package/fesm/strategies/jwt.strategy.js

@@ -24,75 +24,75 @@ import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
 import { PassportStrategy } from '@nestjs/passport';
 import { ExtractJwt, Strategy } from 'passport-jwt';
+import { User } from '../entities/user.entity';
 import { AuthConfigService } from '../services/auth-config.service';
 import { AuthDataSourceProvider } from '../services/auth-datasource.provider';
 import { AuthenticationService } from '../services/authentication.service';
-import { User } from '../entities/user.entity';
-/**
- * Type guard to check if payload includes company context
- */ function isTokenPayloadWithCompany(payload) {
+function hasCompanyContext(payload) {
     return 'companyId' in payload && 'branchId' in payload;
 }
 export class JwtStrategy extends PassportStrategy(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 UnauthorizedException('User not found or inactive');
+        }
+        return this.buildUserInfo(payload);
+    }
+    async resolveUserRepository() {
         try {
-            const dataSourceProvider = await this.moduleRef.resolve(AuthDataSourceProvider, undefined, {
+            const provider = await this.moduleRef.resolve(AuthDataSourceProvider, undefined, {
                 strict: false
             });
-            if (dataSourceProvider) {
-                userRepository = await dataSourceProvider.getRepository(User);
+            if (provider) {
+                return provider.getRepository(User);
             }
-            // Resolve AuthenticationService for token revocation check
-            authService = await this.moduleRef.resolve(AuthenticationService, undefined, {
-                strict: false
-            });
-        } catch (error) {
+        } catch  {
             throw new UnauthorizedException('Unable to access user data');
         }
-        if (!userRepository) {
-            throw new 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 UnauthorizedException('User repository not available');
+    }
+    async checkTokenRevocation(payload) {
+        if (!payload.iat) return;
+        try {
+            const authService = await this.moduleRef.resolve(AuthenticationService, undefined, {
+                strict: false
+            });
+            if (authService && await authService.isTokenRevoked(payload.id, payload.iat)) {
                 throw new UnauthorizedException('Token has been revoked');
             }
+        } catch (err) {
+            if (err instanceof UnauthorizedException) throw err;
         }
-        // Find user and check if active
-        const user = await userRepository.findOne({
-            where: {
-                id: payload.id,
-                isActive: true
-            }
-        });
-        if (!user) {
-            throw new 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: 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/fesm/validators/password.validator.js

@@ -0,0 +1,48 @@
+import { registerDecorator } from 'class-validator';
+/**
+ * Strong password validation decorator.
+ * Validates that passwords meet complexity requirements to prevent weak passwords.
+ *
+ * @example
+ * ```typescript
+ * @IsStrongPassword()
+ * password!: string;
+ *
+ * // With custom options
+ * @IsStrongPassword({ minLength: 12, requireSpecialChar: false })
+ * password!: string;
+ * ```
+ */ export function IsStrongPassword(options = {}, validationOptions) {
+    const { minLength = 8, maxLength = 128, requireUppercase = true, requireLowercase = true, requireNumber = true, requireSpecialChar = true } = options;
+    return function(object, propertyName) {
+        registerDecorator({
+            name: 'isStrongPassword',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate (value) {
+                    if (typeof value !== 'string') return false;
+                    const checks = [
+                        value.length >= minLength,
+                        value.length <= maxLength,
+                        !requireUppercase || /[A-Z]/.test(value),
+                        !requireLowercase || /[a-z]/.test(value),
+                        !requireNumber || /[0-9]/.test(value),
+                        !requireSpecialChar || /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~`]/.test(value)
+                    ];
+                    return checks.every(Boolean);
+                },
+                defaultMessage (args) {
+                    const requirements = [];
+                    if (minLength > 0) requirements.push(`at least ${minLength} characters`);
+                    if (requireUppercase) requirements.push('one uppercase letter');
+                    if (requireLowercase) requirements.push('one lowercase letter');
+                    if (requireNumber) requirements.push('one number');
+                    if (requireSpecialChar) requirements.push('one special character (!@#$%^&*...)');
+                    return `Password must contain ${requirements.join(', ')}`;
+                }
+            }
+        });
+    };
+}

package/interceptors/clear-token.interceptor.d.ts

@@ -6,5 +6,4 @@ export declare class ClearToken implements NestInterceptor {
     constructor(authConfig?: AuthConfigService);
     private get cookieName();
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
-    private clearRefreshTokenCookie;
 }

package/interceptors/set-token.interceptor.d.ts

@@ -5,7 +5,7 @@ export declare class SetToken implements NestInterceptor {
     private readonly authConfig?;
     constructor(authConfig?: AuthConfigService);
     private get cookieName();
+    private get maxAgeMs();
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
-    private isBrowserRequest;
     private setRefreshTokenCookie;
 }

package/interfaces/authentication.interface.d.ts

@@ -22,7 +22,6 @@ export interface LoginResponse {
     user: IUserMini;
     company?: ICompanyMini;
     branch?: ICompanyBranchMini;
-    companyFeatureEnabled?: boolean;
 }
 export interface MeResponse {
     user: IUserMini;
@@ -33,14 +32,12 @@ export interface BranchForSelection {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
 }
 export interface CompanyWithBranches {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
     branches: BranchForSelection[];
 }
@@ -57,7 +54,6 @@ export interface RegistrationResponse {
     user: IUserMini;
     company?: ICompanyMini;
     branch?: ICompanyBranchMini;
-    companyFeatureEnabled?: boolean;
     requiresEmailVerification?: boolean;
 }
 export interface LoginResponseRequiresEmailVerification {

package/interfaces/user-enricher.interface.d.ts

@@ -29,7 +29,6 @@ export interface IProfileExtras {
     actions?: IProfileAction[];
     sections?: IProfileSectionData[];
     completionPercentage?: number;
-    [key: string]: any;
 }
 export interface IProfileRole {
     id: string;
@@ -42,9 +41,7 @@ export interface IProfileAction {
     code: string;
     description?: string | null;
 }
-export interface IEnrichedUser extends IUser {
-    [key: string]: any;
-}
+export type IEnrichedUser = IUser & IProfileExtras;
 export interface IUserEnricher {
     enrichListQuery?(query: SelectQueryBuilder<User>, user: ILoggedUserInfo | null): Promise<{
         extraFields: string[];