@flusys/nestjs-auth 1.0.1 → 1.1.0

package/cjs/modules/auth.module.js

@@ -46,9 +46,9 @@ let AuthModule = class AuthModule {
             ...options.providers ?? []
         ], options.imports);
     }
-    /** Build the dynamic module with shared logic */ static buildModule(options, providers, externalImports = []) {
+    static buildModule(options, providers, externalImports = []) {
         const { global = false, includeController = true, bootstrapAppConfig } = options;
-        const enableCompanyFeature = bootstrapAppConfig?.enableCompanyFeature ?? false;
+        const featureFlags = this.getFeatureFlags(bootstrapAppConfig);
         return {
             module: AuthModule,
             global,
@@ -56,15 +56,21 @@ let AuthModule = class AuthModule {
                 ...externalImports,
                 ...this.buildImports()
             ],
-            controllers: this.buildControllers(includeController, enableCompanyFeature),
+            controllers: this.buildControllers(includeController, featureFlags),
             providers: [
                 ...providers,
-                ...this.buildProviders(enableCompanyFeature)
+                ...this.buildProviders(featureFlags)
             ],
-            exports: this.buildExports(enableCompanyFeature)
+            exports: this.buildExports(featureFlags)
         };
     }
-    /** Common module imports */ static buildImports() {
+    static getFeatureFlags(bootstrapAppConfig) {
+        return {
+            enableCompanyFeature: bootstrapAppConfig?.enableCompanyFeature ?? false,
+            enableEmailVerification: bootstrapAppConfig?.enableEmailVerification ?? true
+        };
+    }
+    static buildImports() {
         return [
             _passport.PassportModule.register({
                 defaultStrategy: 'jwt'
@@ -74,35 +80,40 @@ let AuthModule = class AuthModule {
             _modules.UtilsModule
         ];
     }
-    /** Build controllers based on feature flags */ static buildControllers(includeController, enableCompanyFeature) {
+    static buildControllers(includeController, flags) {
         if (!includeController) return [];
         const controllers = [
             _controllers.AuthenticationController,
             _controllers.UserController
         ];
-        if (enableCompanyFeature) {
+        if (flags.enableEmailVerification) {
+            controllers.push(_controllers.EmailVerificationController);
+        }
+        if (flags.enableCompanyFeature) {
             controllers.push(_controllers.CompanySelectionController, _controllers.CompanyController, _controllers.BranchController, _controllers.UserPermissionController);
         }
         return controllers;
     }
-    /** Core providers (without AUTH_MODULE_OPTIONS - that's added separately) */ static buildProviders(enableCompanyFeature) {
+    static buildProviders(flags) {
         const providers = [
             _authconfigservice.AuthConfigService,
             _authdatasourceprovider.AuthDataSourceProvider,
             _jwtstrategy.JwtStrategy,
             _guards.JwtAuthGuard,
             _services.AuthenticationService,
-            _services.AuthEmailService,
             _settokeninterceptor.SetToken,
             _cleartokeninterceptor.ClearToken,
             _services.UserService
         ];
-        if (enableCompanyFeature) {
+        if (flags.enableEmailVerification) {
+            providers.push(_services.AuthEmailService);
+        }
+        if (flags.enableCompanyFeature) {
             providers.push(_services.CompanySelectionSessionService, _services.CompanyService, _services.BranchService, _services.UserPermissionService);
         }
         return providers;
     }
-    /** Build module exports */ static buildExports(enableCompanyFeature) {
+    static buildExports(flags) {
         const exports1 = [
             _passport.PassportModule,
             _authconstants.AUTH_MODULE_OPTIONS,
@@ -111,15 +122,17 @@ let AuthModule = class AuthModule {
             _jwtstrategy.JwtStrategy,
             _guards.JwtAuthGuard,
             _services.AuthenticationService,
-            _services.AuthEmailService,
             _services.UserService
         ];
-        if (enableCompanyFeature) {
+        if (flags.enableEmailVerification) {
+            exports1.push(_services.AuthEmailService);
+        }
+        if (flags.enableCompanyFeature) {
             exports1.push(_services.CompanySelectionSessionService, _services.CompanyService, _services.BranchService, _services.UserPermissionService);
         }
         return exports1;
     }
-    /** Create async providers for forRootAsync */ static createAsyncProviders(options) {
+    static createAsyncProviders(options) {
         const staticOptions = {
             global: options.global,
             includeController: options.includeController,
@@ -176,15 +189,11 @@ let AuthModule = class AuthModule {
             }
         ];
     }
-    /** Get auth entities based on feature flags */ static getEntities(enableCompanyFeature = false) {
-        return enableCompanyFeature ? [
-            _entities.User,
-            _entities.Company,
-            _entities.CompanyBranch,
-            _entities.UserCompanyPermission
-        ] : [
-            _entities.User
-        ];
+    static getEntities(config) {
+        return (0, _entities.getEntitiesByConfig)({
+            enableCompanyFeature: config.enableCompanyFeature ?? false,
+            enableEmailVerification: config.enableEmailVerification ?? true
+        });
     }
 };
 AuthModule = _ts_decorate([

package/cjs/services/auth-config.service.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "AuthConfigService", {
         return AuthConfigService;
     }
 });
+const _config = require("@flusys/nestjs-core/config");
 const _common = require("@nestjs/common");
 const _authconstants = require("../config/auth.constants");
 const _authmoduleoptionsinterface = require("../interfaces/auth-module-options.interface");
@@ -50,21 +51,24 @@ let AuthConfigService = class AuthConfigService {
     isCompanyFeatureEnabled() {
         return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
     }
+    isEmailVerificationEnabled() {
+        return this.options.bootstrapAppConfig?.enableEmailVerification ?? true;
+    }
     // JWT Configuration
-    /** Get JWT secret key */ getJwtSecret() {
+    getJwtSecret() {
         if (!this.config.jwtSecret) {
             throw new _common.InternalServerErrorException('[AuthModule] JWT_SECRET is required - set via environment or module config');
         }
         return this.config.jwtSecret;
     }
-    /** Get JWT expiration time */ getJwtExpiration() {
+    getJwtExpiration() {
         return this.config.jwtExpiration ?? '1h';
     }
-    /** Get refresh token secret key */ getRefreshTokenSecret() {
+    getRefreshTokenSecret() {
         if (this.config.refreshTokenSecret) {
             return this.config.refreshTokenSecret;
         }
-        if (process.env.NODE_ENV === 'production') {
+        if (_config.envConfig.isProduction()) {
             throw new _common.InternalServerErrorException('[AuthModule] REFRESH_TOKEN_SECRET is required in production - ' + 'using the same secret for access and refresh tokens is a security risk');
         }
         if (!this.refreshTokenSecretWarned) {
@@ -73,14 +77,14 @@ let AuthConfigService = class AuthConfigService {
         }
         return this.getJwtSecret();
     }
-    /** Get refresh token expiration time */ getRefreshTokenExpiration() {
+    getRefreshTokenExpiration() {
         return this.config.refreshTokenExpiration ?? '7d';
     }
-    /** Get refresh token cookie name */ getRefreshTokenCookieName() {
+    getRefreshTokenCookieName() {
         return this.config.refreshTokenCookieName ?? 'fsn_refresh_token';
     }
     // Frontend Configuration
-    /** Get frontend URL for email links */ getFrontendUrl() {
+    getFrontendUrl() {
         return this.config.frontendUrl;
     }
     constructor(injectedOptions){

package/cjs/services/auth-datasource.provider.js

@@ -83,8 +83,7 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let AuthDataSourceProvider = class AuthDataSourceProvider extends _modules.MultiTenantDataSourceService {
-    // Override Static Cache Access Methods
-    /** Override to access Auth-specific static properties */ async getSingleDataSource() {
+    async getSingleDataSource() {
         if (!AuthDataSourceProvider.singleDataSource) {
             if (AuthDataSourceProvider.singleConnectionLock) {
                 return AuthDataSourceProvider.singleConnectionLock;
@@ -108,18 +107,15 @@ let AuthDataSourceProvider = class AuthDataSourceProvider extends _modules.Multi
         }
         return AuthDataSourceProvider.singleDataSource;
     }
-    /** Override to use Auth-specific static cache for tenant connections */ async getOrCreateTenantConnection(tenant) {
-        // Return existing initialized connection from Auth-specific cache
+    async getOrCreateTenantConnection(tenant) {
         const existing = AuthDataSourceProvider.tenantConnections.get(tenant.id);
         if (existing?.isInitialized) {
             return existing;
         }
-        // If another request is creating this tenant's connection, wait for it
         const pendingConnection = AuthDataSourceProvider.connectionLocks.get(tenant.id);
         if (pendingConnection) {
             return pendingConnection;
         }
-        // Create connection with lock to prevent race conditions
         const config = this.buildTenantDatabaseConfig(tenant);
         const connectionPromise = this.createDataSourceFromConfig(config);
         AuthDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
@@ -131,8 +127,7 @@ let AuthDataSourceProvider = class AuthDataSourceProvider extends _modules.Multi
             AuthDataSourceProvider.connectionLocks.delete(tenant.id);
         }
     }
-    // Factory Methods
-    /** Build parent options from AuthModuleOptions */ static buildParentOptions(options) {
+    static buildParentOptions(options) {
         return {
             bootstrapAppConfig: options.bootstrapAppConfig,
             defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
@@ -140,35 +135,28 @@ let AuthDataSourceProvider = class AuthDataSourceProvider extends _modules.Multi
             tenants: options.config?.tenants
         };
     }
-    // Feature Flags
-    /** Check if company feature is enabled (tenant-specific or global fallback) */ isCompanyFeatureEnabled(tenant) {
+    isCompanyFeatureEnabled(tenant) {
         const effectiveTenant = tenant ?? this.getCurrentTenant();
         return effectiveTenant?.enableCompanyFeature ?? this.authOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
     }
-    // Entity Management
-    /** Get auth entities based on company feature flag */ async getAuthEntities() {
-        const { Company, CompanyBranch, User, UserCompanyPermission, UserToken, PendingRegistration } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
-        const coreEntities = [
-            User,
-            UserToken,
-            PendingRegistration
-        ];
-        return this.isCompanyFeatureEnabled() ? [
-            ...coreEntities,
-            Company,
-            CompanyBranch,
-            UserCompanyPermission
-        ] : coreEntities;
+    isEmailVerificationEnabled(tenant) {
+        const effectiveTenant = tenant ?? this.getCurrentTenant();
+        return effectiveTenant?.enableEmailVerification ?? this.authOptions.bootstrapAppConfig?.enableEmailVerification ?? true;
+    }
+    async getAuthEntities() {
+        const { getEntitiesByConfig } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
+        return getEntitiesByConfig({
+            enableCompanyFeature: this.isCompanyFeatureEnabled(),
+            enableEmailVerification: this.isEmailVerificationEnabled()
+        });
     }
-    // Overrides
-    /** Override to dynamically set entities based on tenant config */ async createDataSourceFromConfig(config) {
+    async createDataSourceFromConfig(config) {
         return super.createDataSourceFromConfig(config, await this.getAuthEntities());
     }
     constructor(authOptions, request){
         super(AuthDataSourceProvider.buildParentOptions(authOptions), request), _define_property(this, "authOptions", void 0), _define_property(this, "logger", void 0), this.authOptions = authOptions, this.logger = new _common.Logger(AuthDataSourceProvider.name);
     }
 };
-// Override parent's static properties to have Auth-specific cache (isolated from IAM/Storage)
 _define_property(AuthDataSourceProvider, "tenantConnections", new Map());
 _define_property(AuthDataSourceProvider, "singleDataSource", null);
 _define_property(AuthDataSourceProvider, "tenantsRegistry", new Map());

package/cjs/services/authentication.service.js

@@ -93,9 +93,14 @@ function _ts_param(paramIndex, decorator) {
 }
 let AuthenticationService = class AuthenticationService {
     // Feature Flags
-    /** Check if company feature is enabled (tenant-aware with global fallback) */ isCompanyFeatureEnabled() {
+    isCompanyFeatureEnabled() {
         return this.dataSourceProvider?.isCompanyFeatureEnabled() ?? this.authConfig.isCompanyFeatureEnabled();
     }
+    isEmailVerificationEnabled() {
+        const featureEnabled = this.dataSourceProvider?.isEmailVerificationEnabled() ?? this.authConfig.isEmailVerificationEnabled();
+        const providerAvailable = this.authEmailService?.isEmailEnabled() ?? false;
+        return featureEnabled && providerAvailable;
+    }
     // Repository Getters
     async getUserRepository() {
         if (!this.dataSourceProvider) {
@@ -118,7 +123,7 @@ let AuthenticationService = class AuthenticationService {
     // Login
     async login(email, password) {
         // Check for pending registration first (user registered but hasn't verified email yet)
-        if (await this.authEmailService?.hasPendingRegistration(email)) {
+        if (this.isEmailVerificationEnabled() && await this.authEmailService.hasPendingRegistration(email)) {
             return {
                 requiresEmailVerification: true,
                 email,
@@ -129,7 +134,7 @@ let AuthenticationService = class AuthenticationService {
         if (!user.isActive) {
             throw new _common.UnauthorizedException('User account is deactivated');
         }
-        if (this.authEmailService?.isEmailEnabled() && !user.emailVerified) {
+        if (this.isEmailVerificationEnabled() && !user.emailVerified) {
             return {
                 requiresEmailVerification: true,
                 email: user.email,
@@ -141,7 +146,7 @@ let AuthenticationService = class AuthenticationService {
         }
         return this.handleCompanyBasedLogin(user);
     }
-    /** Handle login when company feature is enabled */ async handleCompanyBasedLogin(user) {
+    async handleCompanyBasedLogin(user) {
         const permissionRepository = await this.getPermissionRepository();
         const branchRepository = await this.getBranchRepository();
         if (!permissionRepository || !branchRepository) {
@@ -192,7 +197,7 @@ let AuthenticationService = class AuthenticationService {
         return await this.generateCompanySelectionResponse(user, companies, branches);
     }
     // Registration
-    /** Register a new user. If email enabled, creates pending registration. Otherwise creates user directly. */ async register(dto, verifyUrlBase) {
+    async register(dto, verifyUrlBase) {
         const userRepository = await this.getUserRepository();
         const existingUser = await userRepository.findOne({
             where: {
@@ -208,7 +213,7 @@ let AuthenticationService = class AuthenticationService {
             throw new _common.BadRequestException('Registration failed due to email exists. Please try again or contact support.');
         }
         // If email verification is enabled, create pending registration instead of user
-        if (this.authEmailService?.isEmailEnabled() && verifyUrlBase) {
+        if (this.isEmailVerificationEnabled() && verifyUrlBase) {
             const companyData = this.isCompanyFeatureEnabled() ? {
                 companySlug: dto.companySlug,
                 branchSlug: dto.branchSlug,
@@ -232,7 +237,7 @@ let AuthenticationService = class AuthenticationService {
         // No email verification - create user directly
         return this.createUserDirectly(dto);
     }
-    /** Handle registration for existing user when company feature is enabled */ async handleExistingUserCompanyRegistration(existingUser, dto) {
+    async handleExistingUserCompanyRegistration(existingUser, dto) {
         if (!dto.companySlug && !dto.newCompanyName) {
             throw new _common.BadRequestException('Email already registered. Please login or provide a company to join/create.');
         }
@@ -264,7 +269,7 @@ let AuthenticationService = class AuthenticationService {
         }
         return this.processCompanyRegistration(existingUser, dto, true);
     }
-    /** Create user directly (no email verification) */ async createUserDirectly(dto) {
+    async createUserDirectly(dto) {
         const userRepository = await this.getUserRepository();
         const hashedPassword = await _bcrypt.hash(dto.password, _config.BCRYPT_SALT_ROUNDS);
         const user = userRepository.create({
@@ -282,7 +287,7 @@ let AuthenticationService = class AuthenticationService {
         }
         return this.processCompanyRegistration(user, dto);
     }
-    /** Create user from pending registration (after email verification) */ async createUserFromPendingRegistration(pending) {
+    async createUserFromPendingRegistration(pending) {
         const userRepository = await this.getUserRepository();
         const existingUser = await userRepository.findOne({
             where: {
@@ -307,7 +312,7 @@ let AuthenticationService = class AuthenticationService {
         }
         return this.generateRegistrationResponse(user);
     }
-    /** Process company registration (join existing or create new) */ async processCompanyRegistration(user, data, throwOnUnavailable = false) {
+    async processCompanyRegistration(user, data, throwOnUnavailable = false) {
         const companyRepository = await this.getCompanyRepository();
         const branchRepository = await this.getBranchRepository();
         const permissionRepository = await this.getPermissionRepository();
@@ -322,7 +327,7 @@ let AuthenticationService = class AuthenticationService {
         }
         return this.generateRegistrationResponse(user);
     }
-    /** Find existing company/branch or create new ones */ async findOrCreateCompanyAndBranch(data, companyRepo, branchRepo) {
+    async findOrCreateCompanyAndBranch(data, companyRepo, branchRepo) {
         if (data.companySlug) {
             const company = await companyRepo.findOne({
                 where: {
@@ -386,7 +391,7 @@ let AuthenticationService = class AuthenticationService {
             branch: null
         };
     }
-    /** Assign user to company and optionally branch */ async assignUserPermissions(userId, companyId, branchId, permissionRepo) {
+    async assignUserPermissions(userId, companyId, branchId, permissionRepo) {
         await permissionRepo.save(permissionRepo.create({
             userId,
             permissionType: _enums.PermissionType.COMPANY,
@@ -401,7 +406,7 @@ let AuthenticationService = class AuthenticationService {
         }
     }
     // Company/Branch Selection
-    /** Select company and branch (step 2 of login). Frontend receives all options and user selects both. */ async select(sessionId, companyId, branchId) {
+    async select(sessionId, companyId, branchId) {
         this.ensureCompanyFeatureEnabled();
         if (!this.sessionService) {
             throw new _common.BadRequestException('Session service not available');
@@ -412,11 +417,11 @@ let AuthenticationService = class AuthenticationService {
         }
         return this.validateAndLoginWithCompany(session.userId, companyId, branchId);
     }
-    /** Switch company/branch after login */ async switchCompany(userId, companyId, branchId) {
+    async switchCompany(userId, companyId, branchId) {
         this.ensureCompanyFeatureEnabled();
         return this.validateAndLoginWithCompany(userId, companyId, branchId);
     }
-    /** Shared: Validate user access to company/branch and generate login response */ async validateAndLoginWithCompany(userId, companyId, branchId) {
+    async validateAndLoginWithCompany(userId, companyId, branchId) {
         const userRepository = await this.getUserRepository();
         const user = await userRepository.findOne({
             where: {
@@ -476,7 +481,7 @@ let AuthenticationService = class AuthenticationService {
         return this.generateLoginResponseWithCompany(user, company, branch);
     }
     // Token Management
-    /** Refresh access token (with token rotation). Returns new access token and new refresh token. */ async refreshToken(refreshToken) {
+    async refreshToken(refreshToken) {
         try {
             const payload = this.jwtService.verify(refreshToken, {
                 secret: this.authConfig.getRefreshTokenSecret()
@@ -510,7 +515,7 @@ let AuthenticationService = class AuthenticationService {
             throw new _common.UnauthorizedException('Invalid or expired refresh token');
         }
     }
-    /** Change password */ async changePassword(userId, currentPassword, newPassword) {
+    async changePassword(userId, currentPassword, newPassword) {
         const userRepository = await this.getUserRepository();
         const user = await userRepository.findOne({
             where: {
@@ -524,7 +529,7 @@ let AuthenticationService = class AuthenticationService {
         user.password = await _bcrypt.hash(newPassword, _config.BCRYPT_SALT_ROUNDS);
         await userRepository.save(user);
     }
-    /** Logout - Revokes all tokens. Stores revocation timestamp in cache. */ async logout(userId) {
+    async logout(userId) {
         if (!this.cacheManager) {
             // Cache is required for secure logout - tokens cannot be revoked without it
             this.logger.error(`SECURITY: Cache not available for logout (userId: ${userId}). ` + 'Token revocation failed - tokens will remain valid until expiry. ' + 'Configure cache (Redis) to enable proper token revocation.');
@@ -538,7 +543,7 @@ let AuthenticationService = class AuthenticationService {
         await this.cacheManager.set(cacheKey, revokedAt, ttlMs);
         this.logger.log(`User ${userId} logged out - all tokens revoked`);
     }
-    /** Check if a token is revoked (issued before user's revocation timestamp) */ async isTokenRevoked(userId, tokenIssuedAt) {
+    async isTokenRevoked(userId, tokenIssuedAt) {
         if (!this.cacheManager || !tokenIssuedAt) {
             return false;
         }
@@ -550,7 +555,7 @@ let AuthenticationService = class AuthenticationService {
         // Token is revoked if it was issued before the revocation timestamp
         return tokenIssuedAt < revokedAt;
     }
-    /** Parse JWT expiry string to milliseconds */ parseExpiryToMs(expiry) {
+    parseExpiryToMs(expiry) {
         const match = expiry.match(/^(\d+)([smhd])$/);
         if (!match) return 7 * 24 * 60 * 60 * 1000; // Default 7 days
         const value = parseInt(match[1], 10);
@@ -569,7 +574,7 @@ let AuthenticationService = class AuthenticationService {
         }
     }
     // Query Methods
-    /** Get user's companies */ async getUserCompanies(userId) {
+    async getUserCompanies(userId) {
         this.ensureCompanyFeatureEnabled();
         const permissionRepository = await this.getPermissionRepository();
         const companyRepository = await this.getCompanyRepository();
@@ -590,7 +595,7 @@ let AuthenticationService = class AuthenticationService {
             active: true
         }).orderBy('c.name', 'ASC').getMany();
     }
-    /** Get branches for a company that user has access to */ async getUserBranches(userId, companyId) {
+    async getUserBranches(userId, companyId) {
         this.ensureCompanyFeatureEnabled();
         const permissionRepository = await this.getPermissionRepository();
         const branchRepository = await this.getBranchRepository();
@@ -625,7 +630,7 @@ let AuthenticationService = class AuthenticationService {
             active: true
         }).orderBy('b.serial', 'ASC').addOrderBy('b.name', 'ASC').getMany();
     }
-    /** Get company by ID */ async getCompanyById(companyId) {
+    async getCompanyById(companyId) {
         const companyRepository = await this.getCompanyRepository();
         if (!companyRepository) {
             return null;
@@ -636,7 +641,7 @@ let AuthenticationService = class AuthenticationService {
             }
         });
     }
-    /** Get branch by ID */ async getBranchById(branchId) {
+    async getBranchById(branchId) {
         const branchRepository = await this.getBranchRepository();
         if (!branchRepository) {
             return null;
@@ -647,7 +652,7 @@ let AuthenticationService = class AuthenticationService {
             }
         });
     }
-    /** Get user info for /auth/me endpoint. Returns user, company, and branch info (no tokens). */ async getUserInfo(userId, companyId, branchId) {
+    async getUserInfo(userId, companyId, branchId) {
         const userRepository = await this.getUserRepository();
         const user = await userRepository.findOne({
             where: {
@@ -694,7 +699,7 @@ let AuthenticationService = class AuthenticationService {
         return user;
     }
     // Response Generators
-    /** Create user info object */ toUserInfo(user) {
+    toUserInfo(user) {
         return {
             id: user.id,
             email: user.email,
@@ -703,7 +708,7 @@ let AuthenticationService = class AuthenticationService {
             profilePictureId: user.profilePictureId ?? null
         };
     }
-    /** Create company info object */ toCompanyInfo(company) {
+    toCompanyInfo(company) {
         return {
             id: company.id,
             name: company.name,
@@ -711,7 +716,7 @@ let AuthenticationService = class AuthenticationService {
             logoId: company.logoId ?? null
         };
     }
-    /** Create branch info object */ toBranchInfo(branch) {
+    toBranchInfo(branch) {
         return {
             id: branch.id,
             name: branch.name,
@@ -719,7 +724,7 @@ let AuthenticationService = class AuthenticationService {
             logoId: branch.logoId ?? null
         };
     }
-    /** Generate JWT tokens */ generateTokens(payload) {
+    generateTokens(payload) {
         const accessToken = this.jwtService.sign({
             ...payload,
             type: 'access'

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/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[];