@ackplus/nest-auth 1.1.18 → 1.1.20

package/src/lib/user/services/user.service.js

@@ -13,71 +13,75 @@ const user_deleted_event_1 = require("../events/user-deleted.event");
 const user_created_event_1 = require("../events/user-created.event");
 const tenant_1 = require("../../tenant");
 const debug_logger_service_1 = require("../../core/services/debug-logger.service");
+const auth_config_service_1 = require("../../core/services/auth-config.service");
 let UserService = class UserService {
-    constructor(userRepository, eventEmitter, tenantService, debugLogger) {
+    constructor(userRepository, tenantService, eventEmitter, authConfigService, debugLogger) {
         this.userRepository = userRepository;
-        this.eventEmitter = eventEmitter;
         this.tenantService = tenantService;
+        this.eventEmitter = eventEmitter;
+        this.authConfigService = authConfigService;
         this.debugLogger = debugLogger;
     }
-    async createUser(data) {
+    async createUser(data, context) {
         this.debugLogger.logFunctionEntry('createUser', 'UserService', { email: data.email, phone: data.phone, hasPassword: !!data.password });
         try {
             const { email, phone } = data;
-            const tenantId = await this.tenantService.resolveTenantId(data?.tenantId || null);
-            this.debugLogger.logUserOperation('createUser', undefined, { email: !!email, phone: !!phone, resolvedTenantId: tenantId });
-            if (!tenantId) {
-                this.debugLogger.error('Tenant ID is required for user creation', 'UserService', { email: !!email, phone: !!phone });
-                throw new common_1.BadRequestException('Tenant ID is required');
-            }
-            if (!email && !phone) {
-                this.debugLogger.error('Neither email nor phone provided for user creation', 'UserService');
-                throw new common_1.BadRequestException('Either email or phone must be provided');
+            let { tenantId = null } = data;
+            // Resolve tenant ID
+            tenantId = await this.tenantService.resolveTenantId(tenantId);
+            data.tenantId = tenantId;
+            // Check if user already exists
+            if (email) {
+                const existingUser = await this.getUserByEmail(email, tenantId);
+                if (existingUser) {
+                    this.debugLogger.warn('User with email already exists', 'UserService', { email, tenantId });
+                    throw new common_1.ConflictException({
+                        message: 'User with this email already exists',
+                        code: 'USER_ALREADY_EXISTS'
+                    });
+                }
             }
-            // Check for existing user with same email or phone in the same tenant
-            this.debugLogger.debug('Checking for existing user', 'UserService', { email: !!email, phone: !!phone, tenantId });
-            let existingUser = null;
-            // Normalize email to lowercase for case-insensitive matching
-            const normalizedEmail = email ? email.toLowerCase().trim() : email;
             if (phone) {
-                existingUser = await this.userRepository.findOne({
-                    where: { phone, tenantId }
-                });
+                const existingUser = await this.getUserByPhone(phone, tenantId);
+                if (existingUser) {
+                    this.debugLogger.warn('User with phone already exists', 'UserService', { phone, tenantId });
+                    throw new common_1.ConflictException({
+                        message: 'User with this phone number already exists',
+                        code: 'USER_ALREADY_EXISTS'
+                    });
+                }
             }
-            if (!existingUser && normalizedEmail) {
-                existingUser = await this.userRepository.findOne({
-                    where: { email: normalizedEmail, tenantId }
-                });
+            // Apply user.beforeCreate hook if configured
+            const config = this.authConfigService.getConfig();
+            if (config.user?.beforeCreate) {
+                this.debugLogger.debug('Applying user.beforeCreate hook', 'UserService');
+                data = await config.user.beforeCreate(data, context);
             }
-            if (existingUser) {
-                this.debugLogger.warn('User already exists', 'UserService', { email: !!email, phone: !!phone, tenantId, existingUserId: existingUser.id });
-                throw new common_1.ConflictException({
-                    message: `User with ${email ? `email ${email}` : ''}${email && phone ? ' or ' : ''}${phone ? `phone ${phone}` : ''} already exists.`,
-                    code: 'USER_ALREADY_EXISTS'
-                });
+            this.debugLogger.debug('Creating new user entity', 'UserService');
+            const user = this.userRepository.create(data);
+            // Handle password if provided in data (even though it's not a column)
+            if (data.password) {
+                await user.setPassword(data.password);
             }
-            this.debugLogger.debug('Creating new user', 'UserService', { email: !!email, phone: !!phone, tenantId });
-            const user = this.userRepository.create({
-                ...data,
-                email: normalizedEmail || data.email,
-                tenantId
-            });
             await this.userRepository.save(user);
-            this.debugLogger.info('User created successfully', 'UserService', { userId: user.id, tenantId });
-            // Create authentication identity for login
-            if (normalizedEmail) {
-                this.debugLogger.debug('Creating email identity', 'UserService', { userId: user.id });
+            this.debugLogger.info('User created successfully', 'UserService', { userId: user.id });
+            // Create identities
+            const normalizedEmail = email?.toLowerCase().trim();
+            if (normalizedEmail)
                 await user.findOrCreateIdentity(auth_constants_1.EMAIL_AUTH_PROVIDER, normalizedEmail);
-            }
-            if (phone) {
-                this.debugLogger.debug('Creating phone identity', 'UserService', { userId: user.id });
+            if (phone)
                 await user.findOrCreateIdentity(auth_constants_1.PHONE_AUTH_PROVIDER, phone);
-            }
             // Emit user created event
             this.debugLogger.debug('Emitting user created event', 'UserService', { userId: user.id });
             await this.eventEmitter.emitAsync(auth_constants_1.NestAuthEvents.USER_CREATED, new user_created_event_1.UserCreatedEvent({
-                user
+                user,
+                tenantId: user.tenantId
             }));
+            // Apply user.afterCreate hook if configured
+            if (config.user?.afterCreate) {
+                this.debugLogger.debug('Applying user.afterCreate hook', 'UserService', { userId: user.id });
+                await config.user.afterCreate(user);
+            }
             this.debugLogger.logFunctionExit('createUser', 'UserService', { userId: user.id });
             return user;
         }
@@ -338,7 +342,8 @@ exports.UserService = UserService = tslib_1.__decorate([
     (0, common_1.Injectable)(),
     tslib_1.__param(0, (0, typeorm_1.InjectRepository)(user_entity_1.NestAuthUser)),
     tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
-        event_emitter_1.EventEmitter2,
         tenant_1.TenantService,
+        event_emitter_1.EventEmitter2,
+        auth_config_service_1.AuthConfigService,
         debug_logger_service_1.DebugLoggerService])
 ], UserService);