@flusys/nestjs-auth 2.0.0 → 3.0.0

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

@@ -25,6 +25,7 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
+import { envConfig } from '@flusys/nestjs-core/config';
 import { Inject, Injectable, InternalServerErrorException, Logger, Optional } from '@nestjs/common';
 import { AUTH_MODULE_OPTIONS } from '../config/auth.constants';
 import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
@@ -40,21 +41,24 @@ export 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 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 (envConfig.isProduction()) {
             throw new 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) {
@@ -63,14 +67,14 @@ export 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/fesm/services/auth-datasource.provider.js

@@ -32,8 +32,7 @@ import { Request } from 'express';
 import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
 import { AUTH_MODULE_OPTIONS } from '../config/auth.constants';
 export class AuthDataSourceProvider extends 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;
@@ -57,18 +56,15 @@ export class AuthDataSourceProvider extends MultiTenantDataSourceService {
         }
         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);
@@ -80,8 +76,7 @@ export class AuthDataSourceProvider extends MultiTenantDataSourceService {
             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,
@@ -89,35 +84,28 @@ export class AuthDataSourceProvider extends MultiTenantDataSourceService {
             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 import('../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 import('../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 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/fesm/services/auth-email.service.js

@@ -39,9 +39,6 @@ export class AuthEmailService {
     isEmailEnabled() {
         return !!this.emailProvider;
     }
-    // ============================================
-    // Private Helpers
-    // ============================================
     async getRepository(entity) {
         if (!this.dataSourceProvider) {
             throw new InternalServerErrorException(`${String(entity)} repository not available`);
@@ -51,7 +48,7 @@ export class AuthEmailService {
     generateToken() {
         return crypto.randomBytes(32).toString('hex');
     }
-    /** Hash token for secure storage - prevents token theft if database is compromised */ hashToken(token) {
+    hashToken(token) {
         return crypto.createHash('sha256').update(token).digest('hex');
     }
     getErrorMessage(error) {
@@ -79,9 +76,6 @@ export class AuthEmailService {
             throw new BadRequestException(usedMessage);
         }
     }
-    // ============================================
-    // Pending Registration (New Users)
-    // ============================================
     async hasPendingRegistration(email) {
         if (!this.isEmailEnabled()) return false;
         const pendingRepository = await this.getRepository(PendingRegistration);
@@ -121,7 +115,8 @@ export class AuthEmailService {
             passwordHash,
             token: tokenHash,
             expiresAt,
-            companyData: data.companyData ?? null
+            companyData: data.companyData ?? null,
+            additionalFields: data.additionalFields ?? null
         });
         await pendingRepository.save(pending);
         // Send verification email with raw token (user receives this)
@@ -132,12 +127,7 @@ export class AuthEmailService {
             message: 'Please check your email to verify your registration.'
         };
     }
-    // ============================================
-    // Password Reset (Existing Users)
-    // ============================================
-    /**
-   * Request password reset - sends reset email
-   */ async forgotPassword(email, resetUrlBase) {
+    async forgotPassword(email, resetUrlBase) {
         this.assertEmailEnabled();
         const userRepository = await this.getRepository(User);
         const tokenRepository = await this.getRepository(UserToken);
@@ -183,9 +173,7 @@ export class AuthEmailService {
             message: 'If the email exists, a password reset link has been sent.'
         };
     }
-    /**
-   * Reset password using token
-   */ async resetPassword(token, newPassword) {
+    async resetPassword(token, newPassword) {
         const userRepository = await this.getRepository(User);
         const tokenRepository = await this.getRepository(UserToken);
         // Hash the incoming token to compare with stored hash
@@ -220,13 +208,7 @@ export class AuthEmailService {
             message: 'Password has been reset successfully.'
         };
     }
-    // ============================================
-    // Email Verification
-    // ============================================
-    /**
-   * Verify email using token
-   * Handles both pending registration and existing user verification
-   */ async verifyEmail(token) {
+    async verifyEmail(token) {
         const pendingRepository = await this.getRepository(PendingRegistration);
         const userRepository = await this.getRepository(User);
         const tokenRepository = await this.getRepository(UserToken);
@@ -296,9 +278,7 @@ export class AuthEmailService {
             message: 'Email has been verified successfully.'
         };
     }
-    /**
-   * Resend verification email - handles both pending registrations and existing users
-   */ async resendVerificationEmail(email, verifyUrlBase) {
+    async resendVerificationEmail(email, verifyUrlBase) {
         this.assertEmailEnabled();
         const pendingRepository = await this.getRepository(PendingRegistration);
         const userRepository = await this.getRepository(User);
@@ -353,12 +333,7 @@ export class AuthEmailService {
             message: 'If the email requires verification, a link has been sent.'
         };
     }
-    // ============================================
-    // Cleanup
-    // ============================================
-    /**
-   * Clean up expired tokens and pending registrations
-   */ async cleanupExpired() {
+    async cleanupExpired() {
         const tokenRepository = await this.getRepository(UserToken);
         const pendingRepository = await this.getRepository(PendingRegistration);
         const now = new Date();