@flusys/nestjs-auth 7.0.2 → 8.0.0-beta.1

package/fesm/services/user.service.js

@@ -1,620 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { LogAction } from '@flusys/nestjs-shared';
-import { createModuleLogger, HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
-import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { BadRequestException, ForbiddenException, Inject, Injectable, NotFoundException, Optional, Scope } from '@nestjs/common';
-import * as bcrypt from 'bcrypt';
-import { AUTH_EVENT_ENTITIES, AUTH_EVENT_MODULE, AUTH_MESSAGES, BCRYPT_SALT_ROUNDS, USER_ENRICHER, USER_MESSAGES, USER_PERMISSION_MESSAGES } from '../config';
-import { CreateUserDto } from '../dtos/user.dto';
-import { AppUser } from '../entities/app-user.entity';
-import { UserCompanyPermission } from '../entities/user-company-permission.entity';
-import { PermissionType } from '../enums';
-import { IUserEnricher } from '../interfaces/user-enricher.interface';
-import { AuthConfigService } from './auth-config.service';
-import { AuthDataSourceProvider } from './auth-datasource.provider';
-export class UserService extends ApiService {
-    async ensureDataSourceRepository() {
-        await super.ensureDataSourceRepository();
-        const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
-        if (isCompanyFeatureEnabled && !this.permissionRepository) {
-            [this.permissionRepository] = await this.resolveRepositories([
-                UserCompanyPermission
-            ]);
-        }
-        if (!this.dataSource) {
-            this.dataSource = await this.getDataSourceProvider().getDataSource();
-        }
-    }
-    async getUserForProfile(userId, user) {
-        if (userId !== user.id) {
-            throw new ForbiddenException({
-                message: "Cannot access another user's profile",
-                messageKey: AUTH_MESSAGES.PROFILE_ACCESS_DENIED
-            });
-        }
-        await this.ensureDataSourceRepository();
-        const userEntity = await this.repository.findOne({
-            where: {
-                id: userId
-            }
-        });
-        if (!userEntity) {
-            throw new NotFoundException({
-                message: 'User not found',
-                messageKey: USER_MESSAGES.NOT_FOUND
-            });
-        }
-        return userEntity;
-    }
-    async verifyEmail(id) {
-        await this.ensureDataSourceRepository();
-        await this.repository.update(id, {
-            emailVerified: true
-        });
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                {
-                    id
-                }
-            ])
-        ]);
-    }
-    async verifyPhone(id) {
-        await this.ensureDataSourceRepository();
-        await this.repository.update(id, {
-            phoneVerified: true
-        });
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                {
-                    id
-                }
-            ])
-        ]);
-    }
-    async updateStatus(id, isActive, user) {
-        await this.ensureDataSourceRepository();
-        const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
-        if (isCompanyFeatureEnabled && user?.companyId && this.permissionRepository) {
-            const permission = await this.permissionRepository.findOne({
-                where: {
-                    userId: id,
-                    permissionType: PermissionType.COMPANY,
-                    targetId: user.companyId
-                }
-            });
-            if (!permission) {
-                throw new NotFoundException({
-                    message: 'User company permission not found',
-                    messageKey: USER_PERMISSION_MESSAGES.PERMISSION_NOT_FOUND,
-                    messageVariables: {
-                        type: 'User company'
-                    }
-                });
-            }
-            permission.isActive = isActive;
-            await this.permissionRepository.save(permission);
-        } else {
-            await this.repository.update(id, {
-                isActive
-            });
-        }
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                {
-                    id
-                }
-            ])
-        ]);
-    }
-    async convertSingleDtoToEntity(dto, user) {
-        const entity = await super.convertSingleDtoToEntity(dto, user);
-        if ('password' in dto && dto.password) {
-            entity.password = await bcrypt.hash(dto.password, BCRYPT_SALT_ROUNDS);
-        }
-        return entity;
-    }
-    convertEntityToResponseDto(entity, isRaw) {
-        if (isRaw) {
-            return this.convertRawToResponseDto(entity);
-        }
-        return this.convertEntityToDto(entity);
-    }
-    convertRawToResponseDto(raw) {
-        const isActive = raw.appuser_companyIsActive !== undefined ? Boolean(raw.appuser_companyIsActive) : raw.appuser_is_active;
-        return {
-            id: raw.appuser_id,
-            name: raw.appuser_name,
-            phone: raw.appuser_phone,
-            email: raw.appuser_email,
-            profilePictureId: raw.appuser_profile_picture_id,
-            isActive,
-            emailVerified: raw.appuser_email_verified,
-            phoneVerified: raw.appuser_phone_verified,
-            lastLoginAt: raw.appuser_last_login_at,
-            additionalFields: raw.appuser_additional_fields,
-            createdAt: raw.appuser_created_at,
-            updatedAt: raw.appuser_updated_at,
-            deletedAt: raw.appuser_deleted_at,
-            createdById: raw.appuser_created_by_id,
-            updatedById: raw.appuser_updated_by_id,
-            deletedById: raw.appuser_deleted_by_id
-        };
-    }
-    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
-        };
-    }
-    convertEntityListToResponseListDto(entities, isRaw) {
-        return entities.map((entity)=>this.convertEntityToResponseDto(entity, isRaw));
-    }
-    async getFilterQuery(query, filter, _user) {
-        for (const [key, value] of Object.entries(filter)){
-            if (key === 'actionCode' || key === 'isActive') {
-                continue; // real continue
-            }
-            query.andWhere(`${this.entityName}.${key} = :value`, {
-                value
-            });
-        }
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getGlobalSearchQuery(query, search, _user) {
-        query.andWhere('(appuser.name LIKE :search OR appuser.email LIKE :search OR appuser.phone LIKE :search)', {
-            search: `%${search}%`
-        });
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getExtraManipulateQuery(query, filterAndPaginationDto, user) {
-        const superQuery = await super.getExtraManipulateQuery(query, filterAndPaginationDto, user);
-        const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
-        const filter = filterAndPaginationDto?.filter;
-        // --- Action code filter (applies regardless of company feature) ---
-        if (filter?.actionCode) {
-            const actionCode = filter.actionCode;
-            const companyId = isCompanyFeatureEnabled ? user?.companyId : undefined;
-            if (isCompanyFeatureEnabled && !companyId) {
-                // Company feature is on but no companyId — no results should match
-                query.andWhere('1 = 0');
-                return {
-                    query,
-                    isRaw: true
-                };
-            }
-            const isPermissionModeFound = this.authConfig.isPermissionModeFound();
-            if (!isPermissionModeFound) {
-                // Optionally log a warning so the caller knows the filter was ignored
-                this.logAdapter.warn(`actionCode filter was requested but permission mode is not set to 'found' — filter ignored`);
-            } else {
-                query.andWhere(`EXISTS (
-        SELECT 1 FROM user_iam_permission perm
-        WHERE perm.permission_type = 'user_role'
-          AND perm.source_id = appuser.id
-          AND perm.target_id IN (
-            SELECT source_id FROM user_iam_permission
-            WHERE permission_type = 'role_action'
-              AND target_id = (SELECT id FROM action WHERE code = :actionCode)
-              ${isCompanyFeatureEnabled ? 'AND company_id = :actionCompanyId' : ''}
-          )
-      ) OR EXISTS (
-        SELECT 1 FROM user_iam_permission perm
-        WHERE perm.permission_type = 'user_action'
-          AND perm.source_id = appuser.id
-          AND perm.target_id = (SELECT id FROM action WHERE code = :actionCode)
-          ${isCompanyFeatureEnabled ? 'AND company_id = :actionCompanyId' : ''}
-      )`, {
-                    actionCode,
-                    ...isCompanyFeatureEnabled && {
-                        actionCompanyId: companyId
-                    }
-                });
-            }
-        }
-        // --- Non-company path ---
-        if (!isCompanyFeatureEnabled) {
-            if (filter?.isActive !== undefined) {
-                query.andWhere(`${this.entityName}.isActive = :value`, {
-                    value: filter.isActive
-                });
-            }
-            return superQuery;
-        }
-        // --- Company feature path ---
-        if (!user?.companyId || !this.permissionRepository) {
-            return superQuery;
-        }
-        // Add companyIsActive as a selected column
-        query.addSelect(`(SELECT perm.is_active FROM user_company_permissions perm
-      WHERE perm.user_id = appuser.id
-        AND perm.permission_type = :permissionType
-        AND perm.target_id = :companyId
-      LIMIT 1)`, 'user_companyIsActive');
-        query.setParameter('permissionType', PermissionType.COMPANY);
-        query.setParameter('companyId', user.companyId);
-        // Filter by isActive within the company if requested
-        if (filter?.isActive !== undefined) {
-            query.andWhere(`EXISTS (
-        SELECT 1 FROM user_company_permissions perm
-        WHERE perm.user_id = appuser.id
-          AND perm.permission_type = :permissionType
-          AND perm.target_id = :companyId
-          AND perm.is_active = :isActiveValue
-      )`, {
-                permissionType: PermissionType.COMPANY,
-                companyId: user.companyId,
-                isActiveValue: filter.isActive
-            });
-        }
-        // Always restrict to users belonging to this company
-        query.andWhere(`EXISTS (
-      SELECT 1 FROM user_company_permissions perm
-      WHERE perm.user_id = appuser.id
-        AND perm.permission_type = :permissionType
-        AND perm.target_id = :companyId
-    )`, {
-            permissionType: PermissionType.COMPANY,
-            companyId: user.companyId
-        });
-        return {
-            query,
-            isRaw: true
-        };
-    }
-    async insert(dto, user) {
-        const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
-        if (!isCompanyFeatureEnabled || !this.dataSource || !user?.companyId || !this.permissionRepository) {
-            return await super.insert(dto, user);
-        }
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-        try {
-            const userEntity = await this.convertSingleDtoToEntity(dto, user);
-            const savedUser = await queryRunner.manager.save(this.repository.target, userEntity);
-            const existingPermission = await queryRunner.manager.findOne(this.permissionRepository.target, {
-                where: {
-                    userId: savedUser.id,
-                    permissionType: PermissionType.COMPANY,
-                    targetId: user.companyId
-                }
-            });
-            if (!existingPermission) {
-                const permission = queryRunner.manager.create(this.permissionRepository.target, {
-                    userId: savedUser.id,
-                    permissionType: PermissionType.COMPANY,
-                    targetId: user.companyId,
-                    isActive: dto.isActive ?? true
-                });
-                await queryRunner.manager.save(this.permissionRepository.target, permission);
-            }
-            if (user.branchId) {
-                const existingBranchPermission = await queryRunner.manager.findOne(this.permissionRepository.target, {
-                    where: {
-                        userId: savedUser.id,
-                        permissionType: PermissionType.BRANCH,
-                        targetId: user.branchId
-                    }
-                });
-                if (!existingBranchPermission) {
-                    const branchPermission = queryRunner.manager.create(this.permissionRepository.target, {
-                        userId: savedUser.id,
-                        permissionType: PermissionType.BRANCH,
-                        targetId: user.branchId,
-                        isActive: dto.isActive ?? true
-                    });
-                    await queryRunner.manager.save(this.permissionRepository.target, branchPermission);
-                }
-            }
-            await queryRunner.commitTransaction();
-            await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId([
-                    savedUser
-                ])
-            ]);
-            return this.convertEntityToResponseDto(savedUser, false);
-        } catch (error) {
-            await queryRunner.rollbackTransaction();
-            throw error;
-        } finally{
-            await queryRunner.release();
-        }
-    }
-    async getProfileWithExtras(userId, user) {
-        const userEntity = await this.getUserForProfile(userId, user);
-        const userData = this.convertEntityToResponseDto(userEntity, false);
-        let extras;
-        if (this.userEnricher?.getProfileExtras) {
-            extras = await this.userEnricher.getProfileExtras(userId, user);
-        }
-        return {
-            user: userData,
-            extras
-        };
-    }
-    async getAll(search, filterAndPaginationDto, user) {
-        const result = await super.getAll(search, filterAndPaginationDto, user);
-        const enrichedData = await this.getEnrichedList(result.data, user);
-        return {
-            data: enrichedData,
-            total: result.total
-        };
-    }
-    async getEnrichedList(users, user) {
-        if (this.userEnricher?.enrichListItems) {
-            return this.userEnricher.enrichListItems(users, user);
-        }
-        return users;
-    }
-    async getProfileSections() {
-        if (this.userEnricher?.getProfileSections) {
-            return this.userEnricher.getProfileSections();
-        }
-        return [];
-    }
-    async getProfileSectionData(userId, sectionId, user) {
-        await this.getUserForProfile(userId, user);
-        if (this.userEnricher?.getProfileSectionData) {
-            return this.userEnricher.getProfileSectionData(userId, sectionId, user);
-        }
-        return null;
-    }
-    async updateProfileSection(userId, sectionId, data, user) {
-        const userEntity = await this.getUserForProfile(userId, user);
-        if (!this.dataSource) {
-            throw new BadRequestException({
-                message: 'DataSource not available',
-                messageKey: SYSTEM_MESSAGES.DATASOURCE_NOT_AVAILABLE
-            });
-        }
-        if (!this.userEnricher?.updateProfileSection) {
-            throw new BadRequestException({
-                message: 'Profile sections not supported',
-                messageKey: AUTH_MESSAGES.PROFILE_SECTIONS_NOT_SUPPORTED
-            });
-        }
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-        try {
-            await this.userEnricher.updateProfileSection(userId, sectionId, data, queryRunner);
-            await queryRunner.commitTransaction();
-            await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId([
-                    userEntity
-                ])
-            ]);
-        } catch (error) {
-            await queryRunner.rollbackTransaction();
-            throw error;
-        } finally{
-            await queryRunner.release();
-        }
-    }
-    async getProfileCompletion(userId, user) {
-        await this.getUserForProfile(userId, user);
-        if (this.userEnricher?.calculateProfileCompletion) {
-            return this.userEnricher.calculateProfileCompletion(userId, user);
-        }
-        return 100;
-    }
-    async profile(dto, user) {
-        await this.ensureDataSourceRepository();
-        if (!this.dataSource) {
-            throw new BadRequestException({
-                message: 'DataSource not available',
-                messageKey: SYSTEM_MESSAGES.DATASOURCE_NOT_AVAILABLE
-            });
-        }
-        const userId = dto.id ?? user.id;
-        if (dto.extras && this.userEnricher?.validateProfileExtras) {
-            await this.userEnricher.validateProfileExtras(userId, dto.extras, user);
-        }
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-        try {
-            const findUser = await queryRunner.manager.findOne(this.repository.target, {
-                where: {
-                    id: userId
-                }
-            });
-            if (!findUser) {
-                throw new NotFoundException({
-                    message: 'User not found',
-                    messageKey: USER_MESSAGES.NOT_FOUND
-                });
-            }
-            if (dto.password) {
-                const isOwnProfile = !dto.id || dto.id === user.id;
-                if (isOwnProfile) {
-                    if (!dto.oldPassword) {
-                        throw new BadRequestException({
-                            message: 'Current password is required to change your password',
-                            messageKey: AUTH_MESSAGES.PASSWORD_CHANGE_CURRENT_REQUIRED
-                        });
-                    }
-                    const isPasswordValid = await bcrypt.compare(dto.oldPassword, findUser.password);
-                    if (!isPasswordValid) {
-                        throw new BadRequestException({
-                            message: 'Current password is incorrect',
-                            messageKey: AUTH_MESSAGES.PASSWORD_CHANGE_INVALID_CURRENT
-                        });
-                    }
-                }
-                findUser.password = await bcrypt.hash(dto.password, BCRYPT_SALT_ROUNDS);
-            }
-            const { password, oldPassword, extras, emailVerified, phoneVerified, isActive, ...restDto } = dto;
-            Object.assign(findUser, restDto);
-            await queryRunner.manager.save(this.repository.target, findUser);
-            if (extras && this.userEnricher?.updateProfileExtras) {
-                await this.userEnricher.updateProfileExtras(userId, extras, queryRunner);
-            }
-            await queryRunner.commitTransaction();
-            await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId([
-                    findUser
-                ])
-            ]);
-            return findUser.id;
-        } catch (error) {
-            await queryRunner.rollbackTransaction();
-            throw error;
-        } finally{
-            await queryRunner.release();
-        }
-    }
-    constructor(cacheManager, utilsService, dataSourceProvider, authConfig, userEnricher){
-        super(AUTH_EVENT_ENTITIES.USER, cacheManager, utilsService, UserService.name, true, AUTH_EVENT_MODULE, dataSourceProvider, AppUser), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "authConfig", void 0), _define_property(this, "userEnricher", void 0), _define_property(this, "permissionRepository", void 0), _define_property(this, "dataSource", void 0), _define_property(this, "logAdapter", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.authConfig = authConfig, this.userEnricher = userEnricher, this.logAdapter = createModuleLogger(this.constructor.name);
-    }
-}
-_ts_decorate([
-    LogAction({
-        action: 'user.verifyEmail',
-        module: 'auth'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserService.prototype, "verifyEmail", null);
-_ts_decorate([
-    LogAction({
-        action: 'user.verifyPhone',
-        module: 'auth'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserService.prototype, "verifyPhone", null);
-_ts_decorate([
-    LogAction({
-        action: 'user.updateStatus',
-        module: 'auth'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        Boolean,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserService.prototype, "updateStatus", null);
-_ts_decorate([
-    LogAction({
-        action: 'user.create',
-        module: 'auth',
-        includeParams: false
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof CreateUserDto === "undefined" ? Object : CreateUserDto,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserService.prototype, "insert", null);
-_ts_decorate([
-    LogAction({
-        action: 'user.updateProfileSection',
-        module: 'auth',
-        includeParams: false
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String,
-        typeof Record === "undefined" ? Object : Record,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserService.prototype, "updateProfileSection", null);
-_ts_decorate([
-    LogAction({
-        action: 'user.updateProfile',
-        module: 'auth',
-        includeParams: false
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserService.prototype, "profile", null);
-UserService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(AuthDataSourceProvider)),
-    _ts_param(3, Inject(AuthConfigService)),
-    _ts_param(4, Optional()),
-    _ts_param(4, Inject(USER_ENRICHER)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider,
-        typeof AuthConfigService === "undefined" ? Object : AuthConfigService,
-        typeof IUserEnricher === "undefined" ? Object : IUserEnricher
-    ])
-], UserService);