@flusys/nestjs-auth 3.0.0-rc → 3.0.1

package/cjs/services/user.service.js

@@ -97,23 +97,17 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     }
     async ensureRepositoryInitialized() {
         await super.ensureRepositoryInitialized();
-        // Initialize permission repository if company feature is enabled
         const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
         if (isCompanyFeatureEnabled && !this.permissionRepository) {
             [this.permissionRepository] = await this.initializeAdditionalRepositories([
                 _usercompanypermissionentity.UserCompanyPermission
             ]);
         }
-        // Initialize DataSource for transaction support
         if (!this.dataSource) {
             this.dataSource = await this.getDataSourceForService();
         }
     }
-    // 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) {
+    async getUserForProfile(userId, user) {
         if (userId !== user.id) {
             throw new _common.ForbiddenException('Cannot access another user\'s profile');
         }
@@ -128,38 +122,32 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
         }
         return userEntity;
     }
-    /** Verify email */ async verifyEmail(id) {
-        // Ensure repository is initialized for custom method
+    async verifyEmail(id) {
         await this.ensureRepositoryInitialized();
         await this.repository.update(id, {
             emailVerified: true
         });
-        // Clear cache for this user
         await this.clearCacheForId([
             {
                 id
             }
         ]);
     }
-    /** Verify phone */ async verifyPhone(id) {
-        // Ensure repository is initialized for custom method
+    async verifyPhone(id) {
         await this.ensureRepositoryInitialized();
         await this.repository.update(id, {
             phoneVerified: true
         });
-        // Clear cache for this user
         await this.clearCacheForId([
             {
                 id
             }
         ]);
     }
-    /** Update user status. When company feature enabled, updates permission isActive for logged user's company. */ async updateStatus(id, isActive, user) {
-        // Ensure repository is initialized for custom method
+    async updateStatus(id, isActive, user) {
         await this.ensureRepositoryInitialized();
         const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
         if (isCompanyFeatureEnabled && user?.companyId && this.permissionRepository) {
-            // Company feature enabled - update permission isActive
             const permission = await this.permissionRepository.findOne({
                 where: {
                     userId: id,
@@ -173,36 +161,30 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             permission.isActive = isActive;
             await this.permissionRepository.save(permission);
         } else {
-            // Company feature disabled - update User.isActive directly
             await this.repository.update(id, {
                 isActive
             });
         }
-        // Clear cache for this user
         await this.clearCacheForId([
             {
                 id
             }
         ]);
     }
-    // ApiService Overrides
-    /** Convert DTO to entity (hash password before saving) */ async convertSingleDtoToEntity(dto, user) {
-        // Repository initialization is handled automatically by RequestScopedApiService
+    async convertSingleDtoToEntity(dto, user) {
         const entity = await super.convertSingleDtoToEntity(dto, user);
-        // Hash password if provided (CreateUserDto has password field)
         if ('password' in dto && dto.password) {
             entity.password = await _bcrypt.hash(dto.password, _config.BCRYPT_SALT_ROUNDS);
         }
         return entity;
     }
-    /** Convert entity to response DTO (removes password). In raw mode with company feature, isActive comes from permission table. */ convertEntityToResponseDto(entity, isRaw) {
+    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
+    convertRawToResponseDto(raw) {
         const isActive = raw.user_companyIsActive !== undefined ? Boolean(raw.user_companyIsActive) : raw.user_is_active;
         return {
             id: raw.user_id,
@@ -223,7 +205,7 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             deletedById: raw.user_deleted_by_id
         };
     }
-    /** Convert entity to response DTO */ convertEntityToDto(entity) {
+    convertEntityToDto(entity) {
         return {
             id: entity.id,
             name: entity.name,
@@ -243,10 +225,10 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             deletedById: entity.deletedById
         };
     }
-    /** Convert entity list to response DTO list */ convertEntityListToResponseListDto(entities, isRaw) {
+    convertEntityListToResponseListDto(entities, isRaw) {
         return entities.map((entity)=>this.convertEntityToResponseDto(entity, isRaw));
     }
-    /** Global search - search by name, email, or phone */ async getGlobalSearchQuery(query, search, _user) {
+    async getGlobalSearchQuery(query, search, _user) {
         query.andWhere('(user.name LIKE :search OR user.email LIKE :search OR user.phone LIKE :search)', {
             search: `%${search}%`
         });
@@ -255,26 +237,16 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             isRaw: false
         };
     }
-    /** Add company permission-based isActive check when company feature enabled. Returns isRaw: true for computed fields. */ async getExtraManipulateQuery(query, filterAndPaginationDto, user) {
-        // Repository initialization is handled automatically by RequestScopedApiService
+    async getExtraManipulateQuery(query, filterAndPaginationDto, user) {
         let result = await super.getExtraManipulateQuery(query, filterAndPaginationDto, user);
-        // Apply user enricher query modifications if available
         if (this.userEnricher?.enrichListQuery) {
             await this.userEnricher.enrichListQuery(query, user);
         }
-        // Only apply company filtering if:
-        // 1. Company feature is enabled at bootstrap
-        // 2. User has company context
-        // 3. Permission repository is available
         const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
         if (!isCompanyFeatureEnabled) {
-            // Company feature disabled - return without any company-related modifications
-            // isActive will come from User entity directly
             return result;
         }
-        // Company feature is enabled - apply company-based filtering
         if (user?.companyId && this.permissionRepository) {
-            // Add computed isActive field from permission table
             query.addSelect(`(SELECT perm.is_active FROM user_company_permissions perm
           WHERE perm.user_id = user.id
           AND perm.permission_type = :permissionType
@@ -282,7 +254,6 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
           LIMIT 1)`, 'user_companyIsActive');
             query.setParameter('permissionType', _enums.PermissionType.COMPANY);
             query.setParameter('companyId', user.companyId);
-            // Add filter for isActive if provided (filters by permission isActive)
             if (filterAndPaginationDto.filter?.isActive !== undefined) {
                 query.andWhere(`EXISTS (
             SELECT 1 FROM user_company_permissions perm
@@ -296,7 +267,6 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
                     isActiveValue: filterAndPaginationDto.filter.isActive
                 });
             }
-            // Filter users to only show those with company permission
             query.andWhere(`EXISTS (
           SELECT 1 FROM user_company_permissions perm
           WHERE perm.user_id = user.id
@@ -306,7 +276,6 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
                 permissionType: _enums.PermissionType.COMPANY,
                 companyId: user.companyId
             });
-            // Return with isRaw: true to get the computed field
             return {
                 query,
                 isRaw: true
@@ -314,11 +283,8 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
         }
         return result;
     }
-    /** Insert user. Creates company permission when company feature is enabled. */ async insert(dto, user) {
-        // Repository initialization is handled automatically by RequestScopedApiService
-        // Check if company feature is enabled
+    async insert(dto, user) {
         const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
-        // If company feature is disabled OR missing dependencies, use parent implementation
         if (!isCompanyFeatureEnabled || !this.dataSource || !user?.companyId || !this.permissionRepository) {
             return super.insert(dto, user);
         }
@@ -326,11 +292,8 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
         await queryRunner.connect();
         await queryRunner.startTransaction();
         try {
-            // First, insert the user using parent method logic
             const userEntity = await this.convertSingleDtoToEntity(dto, user);
             const savedUser = await queryRunner.manager.save(this.repository.target, userEntity);
-            // Create company permission (repository is guaranteed to exist due to check above)
-            // Check if permission already exists
             const existingPermission = await queryRunner.manager.findOne(this.permissionRepository.target, {
                 where: {
                     userId: savedUser.id,
@@ -347,7 +310,6 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
                 });
                 await queryRunner.manager.save(this.permissionRepository.target, permission);
             }
-            // Also create branch permission if user has branch context
             if (user.branchId) {
                 const existingBranchPermission = await queryRunner.manager.findOne(this.permissionRepository.target, {
                     where: {
@@ -381,13 +343,9 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             await queryRunner.release();
         }
     }
-    /**
-   * 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) {
+    async getProfileWithExtras(userId, user) {
         const userEntity = await this.getUserForProfile(userId, user);
         const userData = this.convertEntityToResponseDto(userEntity, false);
-        // Get extras from enricher if available
         let extras;
         if (this.userEnricher?.getProfileExtras) {
             extras = await this.userEnricher.getProfileExtras(userId, user);
@@ -397,38 +355,34 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             extras
         };
     }
-    /**
-   * Get enriched user list
-   * Applies enricher transformations after query execution
-   */ async getEnrichedList(users, user) {
+    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;
     }
-    // ============================================
-    // Multi-Step Profile Methods (via Enricher)
-    // ============================================
-    /**
-   * Get profile section definitions from enricher
-   */ async getProfileSections() {
+    async getProfileSections() {
         if (this.userEnricher?.getProfileSections) {
             return this.userEnricher.getProfileSections();
         }
         return [];
     }
-    /**
-   * Get specific profile section data
-   */ async getProfileSectionData(userId, sectionId, user) {
+    async getProfileSectionData(userId, sectionId, user) {
         await this.getUserForProfile(userId, user);
         if (this.userEnricher?.getProfileSectionData) {
             return this.userEnricher.getProfileSectionData(userId, sectionId, user);
         }
         return null;
     }
-    /**
-   * Update specific profile section
-   */ async updateProfileSection(userId, sectionId, data, user) {
+    async updateProfileSection(userId, sectionId, data, user) {
         const userEntity = await this.getUserForProfile(userId, user);
         if (!this.dataSource) {
             throw new _common.BadRequestException('DataSource not available');
@@ -456,23 +410,19 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             await queryRunner.release();
         }
     }
-    /**
-   * Get profile completion percentage
-   */ async getProfileCompletion(userId, user) {
+    async getProfileCompletion(userId, user) {
         await this.getUserForProfile(userId, user);
         if (this.userEnricher?.calculateProfileCompletion) {
             return this.userEnricher.calculateProfileCompletion(userId, user);
         }
-        return 100; // Default to 100% if no enricher
+        return 100;
     }
-    /** Update user profile with password handling and extras */ async profile(dto, user) {
-        // Ensure repository and dataSource are initialized
+    async profile(dto, user) {
         await this.ensureRepositoryInitialized();
         if (!this.dataSource) {
             throw new _common.BadRequestException('DataSource not available');
         }
         const userId = dto.id ?? user.id;
-        // Validate extras if enricher provides validation
         if (dto.extras && this.userEnricher?.validateProfileExtras) {
             await this.userEnricher.validateProfileExtras(userId, dto.extras, user);
         }
@@ -488,9 +438,7 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             if (!findUser) {
                 throw new _common.NotFoundException('User not found');
             }
-            // Handle password update
             if (dto.password) {
-                // If updating own profile, require old password verification
                 const isOwnProfile = !dto.id || dto.id === user.id;
                 if (isOwnProfile) {
                     if (!dto.oldPassword) {
@@ -503,12 +451,9 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
                 }
                 findUser.password = await _bcrypt.hash(dto.password, _config.BCRYPT_SALT_ROUNDS);
             }
-            // 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
             if (extras && this.userEnricher?.updateProfileExtras) {
                 await this.userEnricher.updateProfileExtras(userId, extras, queryRunner);
             }

package/controllers/authentication.controller.d.ts

@@ -1,18 +1,14 @@
 import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { Request } from 'express';
-import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
+import { ChangePasswordDto, CompanySelectionResponseDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto } from '../dtos/authentication.dto';
 import { AuthConfigService } from '../services/auth-config.service';
-import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
 export declare class AuthenticationController {
     private readonly authService;
     private readonly authConfig?;
-    private readonly authEmailService?;
-    constructor(authService: AuthenticationService, authConfig?: AuthConfigService, authEmailService?: AuthEmailService);
+    constructor(authService: AuthenticationService, authConfig?: AuthConfigService);
     private buildAuthUrl;
-    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<{
@@ -21,8 +17,4 @@ export declare class AuthenticationController {
     getCurrentUser(user: ILoggedUserInfo): Promise<MeResponseDto>;
     logout(userId: string): Promise<MessageResponseDto>;
     changePassword(userId: string, dto: ChangePasswordDto): Promise<MessageResponseDto>;
-    forgotPassword(req: Request, dto: ForgotPasswordDto): Promise<MessageResponseDto>;
-    resetPassword(dto: ResetPasswordDto): Promise<MessageResponseDto>;
-    resendVerification(req: Request, dto: ResendVerificationDto): Promise<MessageResponseDto>;
-    verifyEmail(dto: VerifyEmailDto): Promise<MessageResponseDto | RegistrationResponseDto>;
 }

package/controllers/email-verification.controller.d.ts

@@ -0,0 +1,20 @@
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
+import { Request } from 'express';
+import { ForgotPasswordDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
+import { AuthConfigService } from '../services/auth-config.service';
+import { AuthDataSourceProvider } from '../services/auth-datasource.provider';
+import { AuthEmailService } from '../services/auth-email.service';
+import { AuthenticationService } from '../services/authentication.service';
+export declare class EmailVerificationController {
+    private readonly authService;
+    private readonly authEmailService;
+    private readonly authConfig;
+    private readonly dataSourceProvider;
+    constructor(authService: AuthenticationService, authEmailService: AuthEmailService, authConfig: AuthConfigService, dataSourceProvider: AuthDataSourceProvider);
+    private ensureEmailVerificationEnabled;
+    private buildAuthUrl;
+    forgotPassword(req: Request, dto: ForgotPasswordDto): Promise<MessageResponseDto>;
+    resetPassword(dto: ResetPasswordDto): Promise<MessageResponseDto>;
+    resendVerification(req: Request, dto: ResendVerificationDto): Promise<MessageResponseDto>;
+    verifyEmail(dto: VerifyEmailDto): Promise<MessageResponseDto | RegistrationResponseDto>;
+}

package/controllers/index.d.ts

@@ -1,5 +1,6 @@
 export * from './authentication.controller';
 export * from './company-selection.controller';
+export * from './email-verification.controller';
 export * from './user.controller';
 export * from './company.controller';
 export * from './branch.controller';

package/dtos/authentication.dto.d.ts

@@ -12,6 +12,7 @@ export declare class RegistrationDto {
     newCompanyName?: string;
     newCompanyPhone?: string;
     newCompanyAddress?: string;
+    additionalFields?: Record<string, any>;
 }
 export declare class RefreshTokenDto {
     refreshToken?: string;

package/entities/index.d.ts

@@ -4,13 +4,8 @@ export * from './pending-registration.entity';
 export { PermissionType, UserCompanyPermission } from './user-company-permission.entity';
 export * from './user.entity';
 export * from './user-token.entity';
-import { CompanyBranch } from './company-branch.entity';
-import { Company } from './company.entity';
-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 UserToken | typeof User)[];
-export declare const CompanyEntities: (typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];
-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)[];
+export interface IAuthEntitiesConfig {
+    enableCompanyFeature?: boolean;
+    enableEmailVerification?: boolean;
+}
+export declare function getEntitiesByConfig(config: IAuthEntitiesConfig): any[];

package/entities/pending-registration.entity.d.ts

@@ -13,5 +13,6 @@ export declare class PendingRegistration {
         newCompanyPhone?: string;
         newCompanyAddress?: string;
     } | null;
+    additionalFields: Record<string, any> | null;
     createdAt: Date;
 }

package/fesm/controllers/authentication.controller.js

@@ -34,26 +34,16 @@ import { ApiBearerAuth, ApiBody, ApiExtraModels, ApiHeader, ApiOperation, ApiRes
 import { SkipThrottle, Throttle } from '@nestjs/throttler';
 import { Request } from 'express';
 import { DEFAULT_COOKIE_NAME } from '../config';
-import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
+import { ChangePasswordDto, CompanySelectionResponseDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto } from '../dtos/authentication.dto';
 import { ClearToken } from '../interceptors/clear-token.interceptor';
 import { SetToken } from '../interceptors/set-token.interceptor';
 import { AuthConfigService } from '../services/auth-config.service';
-import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
 export class AuthenticationController {
     buildAuthUrl(req, path) {
         const frontendUrl = this.authConfig?.getFrontendUrl();
         return frontendUrl ? `${frontendUrl}${path}` : `${req.protocol}://${req.get('host')}${path}`;
     }
-    get emailService() {
-        if (!this.authEmailService) {
-            throw new Error('Email service is not configured');
-        }
-        return this.authEmailService;
-    }
-    get isEmailEnabled() {
-        return !!this.authEmailService;
-    }
     async login(loginDto) {
         const result = await this.authService.login(loginDto.email, loginDto.password);
         if ('requiresEmailVerification' in result) {
@@ -99,56 +89,11 @@ export class AuthenticationController {
             message: 'Password changed successfully'
         };
     }
-    async forgotPassword(req, dto) {
-        if (!this.isEmailEnabled) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.emailService.forgotPassword(dto.email, this.buildAuthUrl(req, '/auth/reset-password'));
-    }
-    async resetPassword(dto) {
-        if (!this.isEmailEnabled) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.emailService.resetPassword(dto.token, dto.newPassword);
-    }
-    async resendVerification(req, dto) {
-        if (!this.isEmailEnabled) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.emailService.resendVerificationEmail(dto.email, this.buildAuthUrl(req, '/auth/verify-email'));
-    }
-    /** Verify email - Verify email using token. Handles both pending registration and existing user verification. */ async verifyEmail(dto) {
-        if (!this.isEmailEnabled) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        const result = await this.emailService.verifyEmail(dto.token);
-        if (result.type === 'pending') {
-            return this.authService.createUserFromPendingRegistration(result.pending);
-        }
-        return {
-            success: true,
-            message: result.message
-        };
-    }
-    constructor(authService, authConfig, authEmailService){
+    constructor(authService, authConfig){
         _define_property(this, "authService", void 0);
         _define_property(this, "authConfig", void 0);
-        _define_property(this, "authEmailService", void 0);
         this.authService = authService;
         this.authConfig = authConfig;
-        this.authEmailService = authEmailService;
     }
 }
 _ts_decorate([
@@ -427,131 +372,15 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], AuthenticationController.prototype, "changePassword", null);
-_ts_decorate([
-    Post('forgot-password'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 3,
-            ttl: 300000
-        }
-    }),
-    ApiOperation({
-        summary: 'Request password reset email'
-    }),
-    ApiBody({
-        type: ForgotPasswordDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Req()),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Request === "undefined" ? Object : Request,
-        typeof ForgotPasswordDto === "undefined" ? Object : ForgotPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "forgotPassword", null);
-_ts_decorate([
-    Post('reset-password'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 5,
-            ttl: 900000
-        }
-    }),
-    ApiOperation({
-        summary: 'Reset password using token'
-    }),
-    ApiBody({
-        type: ResetPasswordDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ResetPasswordDto === "undefined" ? Object : ResetPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "resetPassword", null);
-_ts_decorate([
-    Post('resend-verification'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 3,
-            ttl: 300000
-        }
-    }),
-    ApiOperation({
-        summary: 'Resend email verification link'
-    }),
-    ApiBody({
-        type: ResendVerificationDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Req()),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Request === "undefined" ? Object : Request,
-        typeof ResendVerificationDto === "undefined" ? Object : ResendVerificationDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "resendVerification", null);
-_ts_decorate([
-    Post('verify-email'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 10,
-            ttl: 60000
-        }
-    }),
-    UseInterceptors(SetToken),
-    ApiOperation({
-        summary: 'Verify email using token'
-    }),
-    ApiBody({
-        type: VerifyEmailDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: RegistrationResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof VerifyEmailDto === "undefined" ? Object : VerifyEmailDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "verifyEmail", null);
 AuthenticationController = _ts_decorate([
     ApiTags('Authentication'),
     Controller('auth'),
     _ts_param(0, Inject(AuthenticationService)),
     _ts_param(1, Optional()),
     _ts_param(1, Inject(AuthConfigService)),
-    _ts_param(2, Optional()),
-    _ts_param(2, Inject(AuthEmailService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof AuthenticationService === "undefined" ? Object : AuthenticationService,
-        typeof AuthConfigService === "undefined" ? Object : AuthConfigService,
-        typeof AuthEmailService === "undefined" ? Object : AuthEmailService
+        typeof AuthConfigService === "undefined" ? Object : AuthConfigService
     ])
 ], AuthenticationController);