@nauth-toolkit/nestjs 0.1.3

package/dist/auth.module.js

@@ -0,0 +1,718 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var AuthModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const core_2 = require("@nauth-toolkit/core");
+const internal_1 = require("@nauth-toolkit/core/internal");
+const client_info_interceptor_1 = require("./interceptors/client-info.interceptor");
+const cookie_token_interceptor_1 = require("./interceptors/cookie-token.interceptor");
+const auth_guard_1 = require("./guards/auth.guard");
+const csrf_guard_1 = require("./guards/csrf.guard");
+const csrf_service_1 = require("./services/csrf.service");
+const migrations_bootstrap_service_1 = require("./services/migrations-bootstrap.service");
+let AuthModule = AuthModule_1 = class AuthModule {
+    static forRoot(config) {
+        this.validateConfig(config);
+        const nauthLogger = new core_2.NAuthLogger(config.logger);
+        if (nauthLogger.isEnabled()) {
+            nauthLogger.log('Initializing nauth-toolkit...');
+            nauthLogger.debug(`Table prefix: ${config.tablePrefix || 'nauth_'}`);
+            nauthLogger.debug(`JWT algorithm: ${config.jwt.algorithm || 'HS256'}`);
+        }
+        const entities = config.entities || [];
+        return {
+            module: AuthModule_1,
+            imports: [
+                ...(entities.length > 0 ? [typeorm_1.TypeOrmModule.forFeature(entities)] : []),
+            ],
+            providers: [
+                migrations_bootstrap_service_1.nauthMigrationsBootstrapProvider,
+                {
+                    provide: core_1.APP_INTERCEPTOR,
+                    useClass: client_info_interceptor_1.ClientInfoInterceptor,
+                },
+                {
+                    provide: core_1.APP_INTERCEPTOR,
+                    useFactory: (config, jwtService, reflector, csrfService) => {
+                        return new cookie_token_interceptor_1.CookieTokenInterceptor(config, jwtService, reflector, csrfService);
+                    },
+                    inject: [
+                        'NAUTH_CONFIG',
+                        internal_1.JwtService,
+                        core_1.Reflector,
+                        { token: csrf_service_1.CsrfService, optional: true },
+                    ],
+                },
+                {
+                    provide: csrf_service_1.CsrfService,
+                    useFactory: (config) => {
+                        return new csrf_service_1.CsrfService(config);
+                    },
+                    inject: ['NAUTH_CONFIG'],
+                },
+                ...(config.tokenDelivery?.method === 'cookies' || config.tokenDelivery?.method === 'hybrid'
+                    ? [
+                        {
+                            provide: core_1.APP_GUARD,
+                            useClass: csrf_guard_1.CsrfGuard,
+                        },
+                    ]
+                    : []),
+                {
+                    provide: 'NAUTH_CONFIG',
+                    useValue: config,
+                },
+                {
+                    provide: 'NAUTH_LOGGER',
+                    useValue: nauthLogger,
+                },
+                {
+                    provide: 'STORAGE_ADAPTER',
+                    useFactory: async (config, logger, rateLimitRepo, storageLockRepo) => {
+                        if (config.storageAdapter) {
+                            const adapter = config.storageAdapter;
+                            if (adapter &&
+                                typeof adapter.setLogger === 'function') {
+                                adapter.setLogger(logger);
+                            }
+                            if (adapter &&
+                                typeof adapter.setRepositories === 'function') {
+                                if (rateLimitRepo && storageLockRepo) {
+                                    adapter.setRepositories(rateLimitRepo, storageLockRepo);
+                                }
+                            }
+                            await adapter.initialize();
+                            return adapter;
+                        }
+                        if (rateLimitRepo && storageLockRepo) {
+                            try {
+                                const { DatabaseStorageAdapter } = await Promise.resolve().then(() => __importStar(require('@nauth-toolkit/storage-database')));
+                                const adapter = new DatabaseStorageAdapter(null, null, logger);
+                                adapter.setRepositories(rateLimitRepo, storageLockRepo);
+                                await adapter.initialize();
+                                logger?.warn?.('WARNING: Storage adapter not provided. Using DatabaseStorageAdapter as default. ' +
+                                    'For production, explicitly configure storageAdapter in your config.');
+                                return adapter;
+                            }
+                            catch (error) {
+                                logger?.error?.('Failed to create DatabaseStorageAdapter. Please explicitly configure storageAdapter in your config.', { error });
+                            }
+                        }
+                        throw new Error('Storage adapter is REQUIRED for production deployments. ' +
+                            'MemoryStorageAdapter is NOT safe for production (data lost on restart, not shared across instances). ' +
+                            'Please configure storageAdapter in your NAuthConfig:\n\n' +
+                            'Option 1: DatabaseStorageAdapter (recommended if you have a database)\n' +
+                            '  import { DatabaseStorageAdapter } from "@nauth-toolkit/storage-database";\n' +
+                            '  storageAdapter: new DatabaseStorageAdapter()\n\n' +
+                            'Option 2: RedisStorageAdapter (for high-performance multi-server deployments)\n' +
+                            '  import { RedisStorageAdapter } from "@nauth-toolkit/storage-redis";\n' +
+                            '  storageAdapter: new RedisStorageAdapter(redisClient)\n\n' +
+                            'Make sure to include storage entities in your TypeORM configuration:\n' +
+                            '  import { getNAuthStorageEntities } from "@nauth-toolkit/database-typeorm-postgres";\n' +
+                            '  entities: [...getNAuthEntities(), ...getNAuthStorageEntities()]');
+                    },
+                    inject: ['NAUTH_CONFIG', 'NAUTH_LOGGER', 'RateLimitRepository', 'StorageLockRepository'],
+                },
+                {
+                    provide: 'RateLimitRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'RateLimit');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_rate_limits');
+                        if (metadata) {
+                            return dataSource.getRepository(metadata.target);
+                        }
+                        const metadataByName = dataSource.entityMetadatas.find((m) => typeof m.target === 'function' && m.target.name === 'RateLimit');
+                        if (metadataByName && typeof metadataByName.target === 'function') {
+                            return dataSource.getRepository(metadataByName.target);
+                        }
+                        return null;
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'StorageLockRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'StorageLock');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_storage_locks');
+                        if (metadata) {
+                            return dataSource.getRepository(metadata.target);
+                        }
+                        const metadataByName = dataSource.entityMetadatas.find((m) => typeof m.target === 'function' && m.target.name === 'StorageLock');
+                        if (metadataByName && typeof metadataByName.target === 'function') {
+                            return dataSource.getRepository(metadataByName.target);
+                        }
+                        return null;
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'UserRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'User');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_users');
+                        if (!metadata) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'User entity not found. Register entities in TypeORM.forRoot() or provide in config.entities');
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'SessionRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'Session');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_sessions');
+                        if (!metadata) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'Session entity not found. Register entities in TypeORM.forRoot() or provide in config.entities');
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'LoginAttemptRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'LoginAttempt');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_login_attempts');
+                        if (!metadata) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'LoginAttempt entity not found. Register entities in TypeORM.forRoot() or provide in config.entities');
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'VerificationTokenRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'VerificationToken');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_verification_tokens');
+                        if (!metadata) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'VerificationToken entity not found. Register entities in TypeORM.forRoot() or provide in config.entities');
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'SocialAccountRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'SocialAccount');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_social_accounts');
+                        if (!metadata) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'SocialAccount entity not found. Register entities in TypeORM.forRoot() or provide in config.entities');
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'ChallengeSessionRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'ChallengeSession');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_challenge_sessions');
+                        if (!metadata) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'ChallengeSession entity not found. Register entities in TypeORM.forRoot() or provide in config.entities');
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'MFADeviceRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'MFADevice');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_mfa_devices');
+                        if (!metadata) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'MFADevice entity not found. Register entities in TypeORM.forRoot() or provide in config.entities');
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'AuthAuditRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'AuthAudit');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_auth_audit');
+                        if (!metadata) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'AuthAudit entity not found. Register entities in TypeORM.forRoot() or provide in config.entities');
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: 'TrustedDeviceRepository',
+                    useFactory: (dataSource) => {
+                        const entityFromConfig = entities.find((e) => e.name === 'TrustedDevice');
+                        if (entityFromConfig) {
+                            return dataSource.getRepository(entityFromConfig);
+                        }
+                        const metadata = dataSource.entityMetadatas.find((m) => m.tableName === 'nauth_trusted_devices');
+                        if (!metadata) {
+                            return null;
+                        }
+                        return dataSource.getRepository(metadata.target);
+                    },
+                    inject: [typeorm_2.DataSource],
+                },
+                {
+                    provide: internal_1.PasswordService,
+                    useFactory: () => {
+                        return new internal_1.PasswordService(config.password);
+                    },
+                },
+                {
+                    provide: 'PASSWORD_SERVICE',
+                    useFactory: () => {
+                        return new internal_1.PasswordService(config.password);
+                    },
+                },
+                {
+                    provide: internal_1.JwtService,
+                    useFactory: () => {
+                        return new internal_1.JwtService(config.jwt);
+                    },
+                },
+                {
+                    provide: internal_1.SessionService,
+                    useFactory: (sessionRepository, storageAdapter, clientInfoService, nauthConfig, logger, auditService) => {
+                        return new internal_1.SessionService(sessionRepository, storageAdapter, clientInfoService, nauthConfig, logger, auditService);
+                    },
+                    inject: [
+                        'SessionRepository',
+                        'STORAGE_ADAPTER',
+                        core_2.ClientInfoService,
+                        'NAUTH_CONFIG',
+                        'NAUTH_LOGGER',
+                        { token: internal_1.AuthAuditService, optional: true },
+                    ],
+                },
+                {
+                    provide: internal_1.ChallengeService,
+                    useFactory: (challengeSessionRepository, clientInfoService, logger, auditService) => {
+                        return new internal_1.ChallengeService(challengeSessionRepository, clientInfoService, logger, auditService);
+                    },
+                    inject: [
+                        'ChallengeSessionRepository',
+                        core_2.ClientInfoService,
+                        'NAUTH_LOGGER',
+                        { token: internal_1.AuthAuditService, optional: true },
+                    ],
+                },
+                {
+                    provide: internal_1.AuthFlowContextBuilder,
+                    useFactory: (trustedDeviceService, adaptiveMFADecisionService, clientInfoService, logger) => {
+                        return new internal_1.AuthFlowContextBuilder(trustedDeviceService || undefined, adaptiveMFADecisionService, clientInfoService, logger);
+                    },
+                    inject: [
+                        { token: internal_1.TrustedDeviceService, optional: true },
+                        { token: internal_1.AdaptiveMFADecisionService, optional: true },
+                        { token: core_2.ClientInfoService, optional: true },
+                        { token: 'NAUTH_LOGGER', optional: true },
+                    ],
+                },
+                {
+                    provide: internal_1.AuthFlowStateMachineService,
+                    useFactory: (contextBuilder, logger) => {
+                        return new internal_1.AuthFlowStateMachineService(contextBuilder, logger);
+                    },
+                    inject: [internal_1.AuthFlowContextBuilder, { token: 'NAUTH_LOGGER', optional: true }],
+                },
+                {
+                    provide: internal_1.AuthChallengeHelperService,
+                    useFactory: (challengeService, jwtService, sessionService, mfaDeviceRepository, logger, stateMachine, contextBuilder, clientInfoService, emailVerificationService, phoneVerificationService) => {
+                        return new internal_1.AuthChallengeHelperService(challengeService, jwtService, sessionService, mfaDeviceRepository, logger, stateMachine, contextBuilder, clientInfoService, emailVerificationService, phoneVerificationService);
+                    },
+                    inject: [
+                        internal_1.ChallengeService,
+                        internal_1.JwtService,
+                        internal_1.SessionService,
+                        'MFADeviceRepository',
+                        'NAUTH_LOGGER',
+                        internal_1.AuthFlowStateMachineService,
+                        internal_1.AuthFlowContextBuilder,
+                        core_2.ClientInfoService,
+                        { token: core_2.EmailVerificationService, optional: true },
+                        { token: core_2.PhoneVerificationService, optional: true },
+                    ],
+                },
+                {
+                    provide: core_2.AuthService,
+                    useFactory: (userRepository, loginAttemptRepository, passwordService, jwtService, sessionService, challengeService, challengeHelper, emailVerificationService, clientInfoService, accountLockoutStorage, nauthConfig, logger, auditService, phoneVerificationService, mfaService, mfaDeviceRepository, trustedDeviceService) => {
+                        return new core_2.AuthService(userRepository, loginAttemptRepository, passwordService, jwtService, sessionService, challengeService, challengeHelper, emailVerificationService, clientInfoService, accountLockoutStorage, nauthConfig, logger, auditService, phoneVerificationService, mfaService, mfaDeviceRepository, trustedDeviceService);
+                    },
+                    inject: [
+                        'UserRepository',
+                        'LoginAttemptRepository',
+                        internal_1.PasswordService,
+                        internal_1.JwtService,
+                        internal_1.SessionService,
+                        internal_1.ChallengeService,
+                        internal_1.AuthChallengeHelperService,
+                        core_2.EmailVerificationService,
+                        core_2.ClientInfoService,
+                        core_2.AccountLockoutStorageService,
+                        'NAUTH_CONFIG',
+                        'NAUTH_LOGGER',
+                        { token: internal_1.AuthAuditService, optional: true },
+                        { token: core_2.PhoneVerificationService, optional: true },
+                        { token: core_2.MFAService, optional: true },
+                        { token: 'MFADeviceRepository', optional: true },
+                        { token: internal_1.TrustedDeviceService, optional: true },
+                    ],
+                },
+                {
+                    provide: internal_1.TrustedDeviceService,
+                    useFactory: (config, logger, trustedDeviceRepository) => {
+                        if (!trustedDeviceRepository) {
+                            return null;
+                        }
+                        return new internal_1.TrustedDeviceService(config, logger, trustedDeviceRepository);
+                    },
+                    inject: ['NAUTH_CONFIG', 'NAUTH_LOGGER', { token: 'TrustedDeviceRepository', optional: true }],
+                },
+                {
+                    provide: 'SOCIAL_AUTH_STATE_STORE',
+                    useValue: new Map(),
+                },
+                internal_1.SocialProviderRegistry,
+                {
+                    provide: core_2.MFAService,
+                    useFactory: (mfaDeviceRepository, userRepository, challengeService, nauthConfig, logger, auditService, clientInfoService) => {
+                        return new core_2.MFAService(mfaDeviceRepository, userRepository, challengeService, nauthConfig, logger, auditService, clientInfoService);
+                    },
+                    inject: [
+                        'MFADeviceRepository',
+                        'UserRepository',
+                        { token: internal_1.ChallengeService, optional: true },
+                        { token: 'NAUTH_CONFIG', optional: true },
+                        { token: 'NAUTH_LOGGER', optional: true },
+                        { token: core_2.AuthAuditService, optional: true },
+                        { token: core_2.ClientInfoService, optional: true },
+                    ],
+                },
+                {
+                    provide: core_2.SocialAuthService,
+                    useFactory: (providerRegistry, userRepository, socialAccountRepository, authService, logger, auditService) => {
+                        return new core_2.SocialAuthService(providerRegistry, userRepository, socialAccountRepository, authService, logger, auditService);
+                    },
+                    inject: [
+                        internal_1.SocialProviderRegistry,
+                        'UserRepository',
+                        'SocialAccountRepository',
+                        core_2.AuthService,
+                        'NAUTH_LOGGER',
+                        { token: internal_1.AuthAuditService, optional: true },
+                    ],
+                },
+                core_2.ClientInfoService,
+                ...(config.auditLogs?.enabled !== false
+                    ? [
+                        {
+                            provide: internal_1.AuthAuditService,
+                            useFactory: (auditRepository, userRepository, logger, clientInfoService) => {
+                                return new internal_1.AuthAuditService(auditRepository, userRepository, logger, clientInfoService);
+                            },
+                            inject: ['AuthAuditRepository', 'UserRepository', 'NAUTH_LOGGER', core_2.ClientInfoService],
+                        },
+                        {
+                            provide: core_2.AuthAuditService,
+                            useExisting: internal_1.AuthAuditService,
+                        },
+                    ]
+                    : []),
+                {
+                    provide: internal_1.RiskDetectionService,
+                    useFactory: (sessionRepository, auditRepository, config, logger, trustedDeviceService) => {
+                        return new internal_1.RiskDetectionService(sessionRepository, auditRepository, config, logger, trustedDeviceService ?? undefined);
+                    },
+                    inject: [
+                        'SessionRepository',
+                        'AuthAuditRepository',
+                        'NAUTH_CONFIG',
+                        'NAUTH_LOGGER',
+                        { token: internal_1.TrustedDeviceService, optional: true },
+                    ],
+                },
+                {
+                    provide: internal_1.RiskScoringService,
+                    useFactory: (config, logger) => {
+                        return new internal_1.RiskScoringService(config, logger);
+                    },
+                    inject: ['NAUTH_CONFIG', 'NAUTH_LOGGER'],
+                },
+                {
+                    provide: internal_1.AdaptiveMFADecisionService,
+                    useFactory: (riskDetectionService, riskScoringService, storageAdapter, clientInfoService, config, logger, auditService) => {
+                        return new internal_1.AdaptiveMFADecisionService(riskDetectionService, riskScoringService, storageAdapter, clientInfoService, config, logger, auditService);
+                    },
+                    inject: [
+                        internal_1.RiskDetectionService,
+                        internal_1.RiskScoringService,
+                        'STORAGE_ADAPTER',
+                        core_2.ClientInfoService,
+                        'NAUTH_CONFIG',
+                        'NAUTH_LOGGER',
+                        { token: internal_1.AuthAuditService, optional: true },
+                    ],
+                },
+                ...(config.geoLocation?.maxMind
+                    ? [
+                        {
+                            provide: 'MAXMIND_MODULE',
+                            useFactory: async () => {
+                                try {
+                                    const maxMindModule = await Promise.resolve().then(() => __importStar(require('@maxmind/geoip2-node')));
+                                    return maxMindModule;
+                                }
+                                catch {
+                                    return null;
+                                }
+                            },
+                        },
+                    ]
+                    : [
+                        {
+                            provide: 'MAXMIND_MODULE',
+                            useValue: null,
+                        },
+                    ]),
+                ...(config.geoLocation?.maxMind
+                    ? [
+                        {
+                            provide: internal_1.GeoLocationService,
+                            useFactory: (nauthConfig, storageAdapter, maxMindLib, logger) => {
+                                return new internal_1.GeoLocationService(nauthConfig, storageAdapter, maxMindLib, logger);
+                            },
+                            inject: ['NAUTH_CONFIG', 'STORAGE_ADAPTER', 'MAXMIND_MODULE', 'NAUTH_LOGGER'],
+                        },
+                    ]
+                    : []),
+                {
+                    provide: 'EMAIL_PROVIDER',
+                    useFactory: () => {
+                        if (!config.emailProvider) {
+                            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, 'emailProvider is required. Install and configure an email package:\n' +
+                                '  yarn add @nauth-toolkit/email-console (for dev)\n' +
+                                '  yarn add @nauth-toolkit/email-nodemailer (for production)');
+                        }
+                        const provider = config.emailProvider;
+                        if (provider && typeof provider.setLogger === 'function') {
+                            provider.setLogger(nauthLogger);
+                        }
+                        if (provider && typeof provider.setGlobalVariables === 'function' && config.email) {
+                            const globalVars = {};
+                            if (config.email.appName)
+                                globalVars.appName = config.email.appName;
+                            if (config.email.companyName)
+                                globalVars.companyName = config.email.companyName;
+                            if (config.email.logoUrl)
+                                globalVars.logoUrl = config.email.logoUrl;
+                            if (config.email.supportEmail)
+                                globalVars.supportEmail = config.email.supportEmail;
+                            if (config.email.dashboardUrl)
+                                globalVars.dashboardUrl = config.email.dashboardUrl;
+                            if (config.email.brandColor)
+                                globalVars.brandColor = config.email.brandColor;
+                            if (config.email.footerDisclaimer)
+                                globalVars.footerDisclaimer = config.email.footerDisclaimer;
+                            const mergedVars = {
+                                ...globalVars,
+                                ...(config.email.templates?.globalVariables || {}),
+                            };
+                            provider.setGlobalVariables(mergedVars);
+                        }
+                        return provider;
+                    },
+                },
+                {
+                    provide: core_2.EmailVerificationService,
+                    useFactory: (verificationTokenRepo, userRepo, emailProvider, storageAdapter, nauthConfig, clientInfoService, logger, auditService) => {
+                        return new core_2.EmailVerificationService(verificationTokenRepo, userRepo, emailProvider, storageAdapter, nauthConfig, clientInfoService, logger, auditService);
+                    },
+                    inject: [
+                        'VerificationTokenRepository',
+                        'UserRepository',
+                        'EMAIL_PROVIDER',
+                        'STORAGE_ADAPTER',
+                        'NAUTH_CONFIG',
+                        core_2.ClientInfoService,
+                        'NAUTH_LOGGER',
+                        { token: internal_1.AuthAuditService, optional: true },
+                    ],
+                },
+                ...(config.smsProvider
+                    ? [
+                        {
+                            provide: 'SMS_PROVIDER',
+                            useFactory: () => {
+                                const provider = config.smsProvider;
+                                if (provider && typeof provider.setLogger === 'function') {
+                                    provider.setLogger(nauthLogger);
+                                }
+                                return provider;
+                            },
+                        },
+                        {
+                            provide: core_2.PhoneVerificationService,
+                            useFactory: (verificationTokenRepo, userRepo, smsProvider, storageAdapter, nauthConfig, clientInfoService, logger, auditService) => {
+                                return new core_2.PhoneVerificationService(verificationTokenRepo, userRepo, smsProvider, storageAdapter, nauthConfig, clientInfoService, logger, auditService);
+                            },
+                            inject: [
+                                'VerificationTokenRepository',
+                                'UserRepository',
+                                'SMS_PROVIDER',
+                                'STORAGE_ADAPTER',
+                                'NAUTH_CONFIG',
+                                core_2.ClientInfoService,
+                                { token: internal_1.AuthAuditService, optional: true },
+                                'NAUTH_LOGGER',
+                            ],
+                        },
+                    ]
+                    : []),
+                {
+                    provide: core_2.RateLimitStorageService,
+                    useFactory: (storageAdapter) => {
+                        return new core_2.RateLimitStorageService(storageAdapter);
+                    },
+                    inject: ['STORAGE_ADAPTER'],
+                },
+                {
+                    provide: core_2.AccountLockoutStorageService,
+                    useFactory: (storageAdapter) => {
+                        return new core_2.AccountLockoutStorageService(storageAdapter);
+                    },
+                    inject: ['STORAGE_ADAPTER'],
+                },
+                auth_guard_1.AuthGuard,
+                ...(config.tokenDelivery?.method === 'cookies' || config.tokenDelivery?.method === 'hybrid' ? [csrf_guard_1.CsrfGuard] : []),
+            ],
+            exports: [
+                core_2.AuthService,
+                internal_1.PasswordService,
+                internal_1.JwtService,
+                internal_1.SessionService,
+                internal_1.ChallengeService,
+                internal_1.AuthChallengeHelperService,
+                internal_1.SocialProviderRegistry,
+                core_2.ClientInfoService,
+                ...(config.auditLogs?.enabled !== false ? [core_2.AuthAuditService, internal_1.AuthAuditService] : []),
+                auth_guard_1.AuthGuard,
+                ...(config.tokenDelivery?.method === 'cookies' || config.tokenDelivery?.method === 'hybrid'
+                    ? [csrf_guard_1.CsrfGuard, csrf_service_1.CsrfService]
+                    : []),
+                core_2.RateLimitStorageService,
+                core_2.AccountLockoutStorageService,
+                ...(config.geoLocation?.maxMind ? [internal_1.GeoLocationService] : []),
+                'EMAIL_PROVIDER',
+                core_2.EmailVerificationService,
+                ...(config.smsProvider ? ['SMS_PROVIDER', core_2.PhoneVerificationService] : []),
+                core_2.SocialAuthService,
+                core_2.MFAService,
+                'NAUTH_LOGGER',
+                'NAUTH_CONFIG',
+                'SOCIAL_AUTH_STATE_STORE',
+                'UserRepository',
+                'MFADeviceRepository',
+            ],
+        };
+    }
+    static forRootAsync(_options) {
+        throw new core_2.NAuthException(core_2.AuthErrorCode.INTERNAL_ERROR, 'forRootAsync() is deprecated in v2.0. Use forRoot() instead.\n' +
+            'The modular architecture requires entities to be provided synchronously.');
+    }
+    static validateConfig(config) {
+        const result = core_2.authConfigSchema.safeParse(config);
+        if (!result.success) {
+            const errors = result.error.errors
+                .map((err) => {
+                const path = err.path.length > 0 ? err.path.join('.') : 'root';
+                return `  - ${path}: ${err.message}`;
+            })
+                .join('\n');
+            throw new core_2.NAuthException(core_2.AuthErrorCode.VALIDATION_FAILED, `Configuration validation failed:\n\n${errors}\n\n` +
+                'Please check your auth configuration and ensure all required fields are provided.');
+        }
+    }
+};
+exports.AuthModule = AuthModule;
+exports.AuthModule = AuthModule = AuthModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], AuthModule);
+//# sourceMappingURL=auth.module.js.map