@flusys/nestjs-auth 3.0.0-rc → 3.0.1

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/auth-email.service.js

@@ -90,9 +90,6 @@ let AuthEmailService = class AuthEmailService {
     isEmailEnabled() {
         return !!this.emailProvider;
     }
-    // ============================================
-    // Private Helpers
-    // ============================================
     async getRepository(entity) {
         if (!this.dataSourceProvider) {
             throw new _common.InternalServerErrorException(`${String(entity)} repository not available`);
@@ -102,7 +99,7 @@ let AuthEmailService = 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) {
@@ -130,9 +127,6 @@ let AuthEmailService = class AuthEmailService {
             throw new _common.BadRequestException(usedMessage);
         }
     }
-    // ============================================
-    // Pending Registration (New Users)
-    // ============================================
     async hasPendingRegistration(email) {
         if (!this.isEmailEnabled()) return false;
         const pendingRepository = await this.getRepository(_pendingregistrationentity.PendingRegistration);
@@ -172,7 +166,8 @@ let AuthEmailService = 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)
@@ -183,12 +178,7 @@ let AuthEmailService = 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(_userentity.User);
         const tokenRepository = await this.getRepository(_usertokenentity.UserToken);
@@ -234,9 +224,7 @@ let AuthEmailService = 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(_userentity.User);
         const tokenRepository = await this.getRepository(_usertokenentity.UserToken);
         // Hash the incoming token to compare with stored hash
@@ -271,13 +259,7 @@ let AuthEmailService = 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(_pendingregistrationentity.PendingRegistration);
         const userRepository = await this.getRepository(_userentity.User);
         const tokenRepository = await this.getRepository(_usertokenentity.UserToken);
@@ -347,9 +329,7 @@ let AuthEmailService = 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(_pendingregistrationentity.PendingRegistration);
         const userRepository = await this.getRepository(_userentity.User);
@@ -404,12 +384,7 @@ let AuthEmailService = 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(_usertokenentity.UserToken);
         const pendingRepository = await this.getRepository(_pendingregistrationentity.PendingRegistration);
         const now = new Date();