@ackplus/nest-auth 0.1.51 → 1.1.0

package/src/lib/user/services/{user.service.js → user.service.ts}

@@ -1,151 +1,196 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserService = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const typeorm_1 = require("@nestjs/typeorm");
-const typeorm_2 = require("typeorm");
-const user_entity_1 = require("../entities/user.entity");
-const event_emitter_1 = require("@nestjs/event-emitter");
-const auth_constants_1 = require("../../auth.constants");
-const user_updated_event_1 = require("../events/user-updated.event");
-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");
-let UserService = class UserService {
-    constructor(userRepository, eventEmitter, tenantService, debugLogger) {
-        this.userRepository = userRepository;
-        this.eventEmitter = eventEmitter;
-        this.tenantService = tenantService;
-        this.debugLogger = debugLogger;
-    }
-    async createUser(data) {
-        this.debugLogger.logFunctionEntry('createUser', 'UserService', { email: data.email, phone: data.phone, hasPassword: !!data.password });
+import { Injectable, NotFoundException, BadRequestException, ConflictException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { FindManyOptions, FindOneOptions, IsNull, Not, Repository } from 'typeorm';
+import { NestAuthUser } from '../entities/user.entity';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { EMAIL_AUTH_PROVIDER, NestAuthEvents, PHONE_AUTH_PROVIDER } from '../../auth.constants';
+import { UserUpdatedEvent } from '../events/user-updated.event';
+import { UserDeletedEvent } from '../events/user-deleted.event';
+import { UserCreatedEvent } from '../events/user-created.event';
+import { TenantService } from '../../tenant';
+import { DebugLoggerService } from '../../core/services/debug-logger.service';
+
+@Injectable()
+export class UserService {
+    constructor(
+        @InjectRepository(NestAuthUser)
+        private userRepository: Repository<NestAuthUser>,
+        private eventEmitter: EventEmitter2,
+        private tenantService: TenantService,
+        private debugLogger: DebugLoggerService
+    ) { }
+
+    async createUser(data: Partial<NestAuthUser>): Promise<NestAuthUser> {
+        this.debugLogger.logFunctionEntry('createUser', 'UserService', { email: data.email, phone: data.phone, hasPassword: !!(data as any).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');
+                throw new 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');
+                throw new BadRequestException('Either email or phone must be provided');
             }
+
+            // 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 }
                 });
             }
-            if (!existingUser && email) {
+
+            if (!existingUser && normalizedEmail) {
                 existingUser = await this.userRepository.findOne({
-                    where: { email, tenantId }
+                    where: { email: normalizedEmail, tenantId }
                 });
             }
+
             if (existingUser) {
                 this.debugLogger.warn('User already exists', 'UserService', { email: !!email, phone: !!phone, tenantId, existingUserId: existingUser.id });
-                throw new common_1.ConflictException({
+                throw new 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', 'UserService', { email: !!email, phone: !!phone, tenantId });
-            const user = this.userRepository.create({ ...data, 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 });
-            if (email) {
+
+            // Create authentication identity for login
+            if (normalizedEmail) {
                 this.debugLogger.debug('Creating email identity', 'UserService', { userId: user.id });
-                await user.findOrCreateIdentity(auth_constants_1.EMAIL_AUTH_PROVIDER, email);
+                await user.findOrCreateIdentity(EMAIL_AUTH_PROVIDER, normalizedEmail);
             }
             if (phone) {
                 this.debugLogger.debug('Creating phone identity', 'UserService', { userId: user.id });
-                await user.findOrCreateIdentity(auth_constants_1.PHONE_AUTH_PROVIDER, phone);
+                await user.findOrCreateIdentity(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
-            }));
+            await this.eventEmitter.emitAsync(
+                NestAuthEvents.USER_CREATED,
+                new UserCreatedEvent({
+                    user
+                })
+            );
+
             this.debugLogger.logFunctionExit('createUser', 'UserService', { userId: user.id });
             return user;
-        }
-        catch (error) {
+
+        } catch (error) {
             this.debugLogger.logError(error, 'createUser', { email: data.email, phone: data.phone });
             throw error;
         }
     }
-    async getUserById(id, options) {
+
+    async getUserById(id: string, options?: FindOneOptions<NestAuthUser>): Promise<NestAuthUser> {
         this.debugLogger.debug('Getting user by ID', 'UserService', { userId: id });
+
         if (!id) {
             this.debugLogger.warn('No user ID provided', 'UserService');
             return null;
         }
+
         const user = await this.userRepository.findOne({
             ...(options ? options : {}),
             where: { id }
         });
+
         if (!user) {
             this.debugLogger.warn('User not found', 'UserService', { userId: id });
             return null;
         }
+
         this.debugLogger.debug('User found', 'UserService', { userId: user.id });
         return user;
     }
-    async getUserByEmail(email, tenantId, options) {
+
+    async getUserByEmail(email: string, tenantId?: string, options?: FindOneOptions<NestAuthUser>): Promise<NestAuthUser> {
         this.debugLogger.debug('Getting user by email', 'UserService', { email: !!email, tenantId });
+
         tenantId = await this.tenantService.resolveTenantId(tenantId || null);
         if (!email) {
             this.debugLogger.warn('No email provided for user lookup', 'UserService');
             return null;
         }
+
+        // Normalize email to lowercase for case-insensitive matching
+        const normalizedEmail = email.toLowerCase().trim();
+
         const user = await this.userRepository.findOne({
             ...(options ? options : {}),
             where: {
-                email,
-                tenantId: tenantId || (0, typeorm_2.IsNull)()
+                email: normalizedEmail,
+                tenantId: tenantId || IsNull()
             }
         });
+
         if (user) {
             this.debugLogger.debug('User found by email', 'UserService', { userId: user.id, tenantId });
-        }
-        else {
+        } else {
             this.debugLogger.debug('No user found with email', 'UserService', { tenantId });
         }
+
         return user;
     }
-    async getUserByPhone(phone, tenantId, options) {
+
+    async getUserByPhone(phone: string, tenantId?: string, options?: FindOneOptions<NestAuthUser>): Promise<NestAuthUser> {
         this.debugLogger.debug('Getting user by phone', 'UserService', { phone: !!phone, tenantId });
+
         tenantId = await this.tenantService.resolveTenantId(tenantId || null);
         if (!phone) {
             this.debugLogger.warn('No phone provided for user lookup', 'UserService');
             return null;
         }
+
         const user = await this.userRepository.findOne({
             ...(options ? options : {}),
             where: {
                 phone,
-                tenantId: tenantId || (0, typeorm_2.IsNull)()
+                tenantId: tenantId || IsNull()
             }
         });
+
         if (user) {
             this.debugLogger.debug('User found by phone', 'UserService', { userId: user.id, tenantId });
-        }
-        else {
+        } else {
             this.debugLogger.debug('No user found with phone', 'UserService', { tenantId });
         }
+
         return user;
     }
-    async getUsers(options) {
+
+    async getUsers(options?: FindManyOptions<NestAuthUser>): Promise<NestAuthUser[]> {
         return this.userRepository.find(options);
     }
-    async getUsersByTenant(tenantId, options) {
+
+    async getUsersByTenant(tenantId: string, options?: FindManyOptions<NestAuthUser>): Promise<NestAuthUser[]> {
         tenantId = await this.tenantService.resolveTenantId(tenantId || null);
         if (!tenantId) {
             return [];
         }
+
         return this.userRepository.find({
             ...(options ? options : {}),
             where: {
@@ -154,159 +199,218 @@ let UserService = class UserService {
             }
         });
     }
-    async updateUser(id, data) {
+
+    async updateUser(id: string, data: Partial<NestAuthUser>): Promise<NestAuthUser> {
         this.debugLogger.logFunctionEntry('updateUser', 'UserService', { userId: id, fields: Object.keys(data) });
+
         try {
             const user = await this.getUserById(id);
+
             if (!user) {
                 this.debugLogger.error('User not found for update', 'UserService', { userId: id });
-                throw new common_1.NotFoundException({
+                throw new NotFoundException({
                     message: `User with ID ${id} not found`,
                     code: 'USER_NOT_FOUND'
                 });
             }
+
+            // If email or phone is being changed, check for conflicts
             if (data.email || data.phone) {
                 this.debugLogger.debug('Checking for conflicts during user update', 'UserService', { userId: id, email: !!data.email, phone: !!data.phone });
+
                 let existingUser = null;
+
                 if (data.phone) {
                     existingUser = await this.userRepository.findOne({
-                        where: { phone: data.phone, tenantId: user.tenantId, id: (0, typeorm_2.Not)(user.id) }
+                        where: { phone: data.phone, tenantId: user.tenantId, id: Not(user.id) }
                     });
                 }
+
                 if (!existingUser && data.email) {
                     existingUser = await this.userRepository.findOne({
-                        where: { email: data.email, tenantId: user.tenantId, id: (0, typeorm_2.Not)(user.id) }
+                        where: { email: data.email, tenantId: user.tenantId, id: Not(user.id) }
                     });
                 }
+
                 if (existingUser) {
                     this.debugLogger.warn('Conflict detected during user update', 'UserService', { userId: id, conflictingUserId: existingUser.id });
-                    throw new common_1.ConflictException({
+                    throw new ConflictException({
                         message: `User with ${data.email ? `email ${data.email}` : ''}${data.email && data.phone ? ' or ' : ''}${data.phone ? `phone ${data.phone}` : ''} already exists.`,
                         code: 'USER_ALREADY_EXISTS'
                     });
                 }
             }
+
+            // Prevent changing tenant
             delete data.tenantId;
+
             this.debugLogger.debug('Updating user data', 'UserService', { userId: id, fields: Object.keys(data) });
             Object.assign(user, data);
             const updatedUser = await this.userRepository.save(user);
             this.debugLogger.info('User updated successfully', 'UserService', { userId: updatedUser.id });
+
             if (data.email) {
                 this.debugLogger.debug('Updating email identity', 'UserService', { userId: id });
-                await user.updateOrCreateIdentity(auth_constants_1.EMAIL_AUTH_PROVIDER, { providerId: data.email });
+                await user.updateOrCreateIdentity(EMAIL_AUTH_PROVIDER, { providerId: data.email });
             }
+
             if (data.phone) {
                 this.debugLogger.debug('Updating phone identity', 'UserService', { userId: id });
-                await user.updateOrCreateIdentity(auth_constants_1.PHONE_AUTH_PROVIDER, { providerId: data.phone });
+                await user.updateOrCreateIdentity(PHONE_AUTH_PROVIDER, { providerId: data.phone });
             }
+
+            // Emit user updated event
             this.debugLogger.debug('Emitting user updated event', 'UserService', { userId: updatedUser.id });
-            await this.eventEmitter.emitAsync(auth_constants_1.NestAuthEvents.USER_UPDATED, new user_updated_event_1.UserUpdatedEvent({
-                user: updatedUser,
-                tenantId: updatedUser.tenantId,
-                updatedFields: Object.keys(data)
-            }));
+            await this.eventEmitter.emitAsync(
+                NestAuthEvents.USER_UPDATED,
+                new UserUpdatedEvent({
+                    user: updatedUser,
+                    tenantId: updatedUser.tenantId,
+                    updatedFields: Object.keys(data)
+                })
+            );
+
             this.debugLogger.logFunctionExit('updateUser', 'UserService', { userId: updatedUser.id });
             return updatedUser;
-        }
-        catch (error) {
+
+        } catch (error) {
             this.debugLogger.logError(error, 'updateUser', { userId: id, fields: Object.keys(data) });
             throw error;
         }
     }
-    async deleteUser(id) {
+
+    async deleteUser(id: string): Promise<void> {
         this.debugLogger.logFunctionEntry('deleteUser', 'UserService', { userId: id });
+
         try {
             const user = await this.getUserById(id);
+
             if (!user) {
                 this.debugLogger.error('User not found for deletion', 'UserService', { userId: id });
-                throw new common_1.NotFoundException({
+                throw new NotFoundException({
                     message: `User with ID ${id} not found`,
                     code: 'USER_NOT_FOUND'
                 });
             }
+
+            // Emit user deleted event before deletion
             this.debugLogger.debug('Emitting user deleted event', 'UserService', { userId: id });
-            await this.eventEmitter.emitAsync(auth_constants_1.NestAuthEvents.USER_DELETED, new user_deleted_event_1.UserDeletedEvent({
-                user,
-                tenantId: user.tenantId
-            }));
+            await this.eventEmitter.emitAsync(
+                NestAuthEvents.USER_DELETED,
+                new UserDeletedEvent({
+                    user,
+                    tenantId: user.tenantId
+                })
+            );
+
             this.debugLogger.debug('Deleting user from database', 'UserService', { userId: id });
             await this.userRepository.remove(user);
             this.debugLogger.info('User deleted successfully', 'UserService', { userId: id });
+
             this.debugLogger.logFunctionExit('deleteUser', 'UserService', { userId: id });
-        }
-        catch (error) {
+
+        } catch (error) {
             this.debugLogger.logError(error, 'deleteUser', { userId: id });
             throw error;
         }
     }
-    async verifyUser(id, verificationType) {
+
+    async verifyUser(id: string, verificationType?: 'email' | 'phone' | 'none'): Promise<NestAuthUser> {
         const user = await this.getUserById(id);
+
         if (!user) {
-            throw new common_1.NotFoundException({
+            throw new NotFoundException({
                 message: `User with ID ${id} not found`,
                 code: 'USER_NOT_FOUND'
             });
         }
+
         if (verificationType === 'email') {
             user.emailVerifiedAt = new Date();
-        }
-        else if (verificationType === 'phone') {
+        } else if (verificationType === 'phone') {
             user.phoneVerifiedAt = new Date();
         }
+
         user.isVerified = true;
+
         return this.userRepository.save(user);
     }
-    async unverifyUser(id, verificationType) {
+
+    async unverifyUser(id: string, verificationType?: 'email' | 'phone' | 'none'): Promise<NestAuthUser> {
         const user = await this.getUserById(id);
+
         if (!user) {
-            throw new common_1.NotFoundException({
+            throw new NotFoundException({
                 message: `User with ID ${id} not found`,
                 code: 'USER_NOT_FOUND'
             });
         }
+
         if (verificationType === 'email') {
             user.emailVerifiedAt = null;
-        }
-        else if (verificationType === 'phone') {
+        } else if (verificationType === 'phone') {
             user.phoneVerifiedAt = null;
         }
+
         user.isVerified = false;
+
+        // Update isVerified flag based on remaining verification status
         user.isVerified = Boolean(user.emailVerifiedAt || user.phoneVerifiedAt);
+
         return this.userRepository.save(user);
     }
-    async updateUserStatus(id, isActive) {
+
+    async updateUserStatus(id: string, isActive: boolean): Promise<NestAuthUser> {
         const user = await this.getUserById(id);
+
         if (!user) {
-            throw new common_1.NotFoundException({
+            throw new NotFoundException({
                 message: `User with ID ${id} not found`,
                 code: 'USER_NOT_FOUND'
             });
         }
+
         user.isActive = isActive;
         return this.userRepository.save(user);
     }
-    async updateUserMetadata(id, metadata) {
+
+    async updateUserMetadata(id: string, metadata: Record<string, any>): Promise<NestAuthUser> {
         const user = await this.getUserById(id);
+
         if (!user) {
-            throw new common_1.NotFoundException({
+            throw new NotFoundException({
                 message: `User with ID ${id} not found`,
                 code: 'USER_NOT_FOUND'
             });
         }
+
         user.metadata = {
             ...user.metadata,
             ...metadata
         };
+
         return this.userRepository.save(user);
     }
-};
-exports.UserService = UserService;
-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,
-        debug_logger_service_1.DebugLoggerService])
-], UserService);
-//# sourceMappingURL=user.service.js.map
+
+    async countUsers(options?: FindManyOptions<NestAuthUser>): Promise<number> {
+        return this.userRepository.count(options);
+    }
+
+    async getUsersAndCount(options?: FindManyOptions<NestAuthUser>): Promise<[NestAuthUser[], number]> {
+        return this.userRepository.findAndCount(options);
+    }
+
+    async getUsersByRole(roleName: string, guard: string): Promise<NestAuthUser[]> {
+        this.debugLogger.debug('Getting users by role', 'UserService', { roleName, guard });
+
+        const users = await this.userRepository
+            .createQueryBuilder('user')
+            .leftJoinAndSelect('user.roles', 'role')
+            .where('role.name = :roleName', { roleName })
+            .andWhere('role.guard = :guard', { guard })
+            .getMany();
+
+        this.debugLogger.debug('Found users with role', 'UserService', { roleName, count: users.length });
+        return users;
+    }
+}

package/src/lib/user/user.module.ts

@@ -0,0 +1,26 @@
+import { forwardRef, Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { NestAuthUser } from './entities/user.entity';
+import { UserService } from './services/user.service';
+import { AccessKeyService } from './services/access-key.service';
+import { AuthModule } from '../auth/auth.module';
+import { NestAuthAccessKey } from './entities/access-key.entity';
+import { NestAuthIdentity } from './entities/identity.entity';
+import { TenantModule } from '../tenant/tenant.module';
+
+@Module({
+    imports: [
+        TypeOrmModule.forFeature([NestAuthUser, NestAuthAccessKey, NestAuthIdentity]),
+        forwardRef(() => AuthModule),
+        forwardRef(() => TenantModule),
+    ],
+    providers: [
+        UserService,
+        AccessKeyService,
+    ],
+    exports: [
+        UserService,
+        AccessKeyService,
+    ],
+})
+export class UserModule { }

package/src/lib/utils/database.utils.ts

@@ -0,0 +1,6 @@
+import { DataSource } from 'typeorm';
+
+export function getJsonColumnType(dataSource: DataSource): string {
+    const driver = dataSource.driver;
+    return driver.options.type === 'sqlite' ? 'simple-json' : 'jsonb';
+}

package/src/lib/utils/date.util.ts

@@ -0,0 +1,106 @@
+import ms from 'ms';
+
+/**
+ * Date and time utilities
+ */
+export class DateUtil {
+    /**
+     * Parse duration string to milliseconds
+     */
+    static parseDuration(duration: string | number): number {
+        if (typeof duration === 'number') {
+            return duration;
+        }
+        return ms(duration);
+    }
+
+    /**
+     * Add duration to date
+     */
+    static addDuration(date: Date, duration: string | number): Date {
+        const milliseconds = this.parseDuration(duration);
+        return new Date(date.getTime() + milliseconds);
+    }
+
+    /**
+     * Check if date is in the past
+     */
+    static isPast(date: Date): boolean {
+        return date < new Date();
+    }
+
+    /**
+     * Check if date is in the future
+     */
+    static isFuture(date: Date): boolean {
+        return date > new Date();
+    }
+
+    /**
+     * Get time remaining until date
+     */
+    static getTimeUntil(date: Date): {
+        milliseconds: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        days: number;
+        formatted: string;
+    } {
+        const remaining = Math.max(0, date.getTime() - Date.now());
+        const seconds = Math.floor(remaining / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+
+        return {
+            milliseconds: remaining,
+            seconds,
+            minutes,
+            hours,
+            days,
+            formatted: ms(remaining, { long: true }),
+        };
+    }
+
+    /**
+     * Format date for display
+     */
+    static format(date: Date, format: 'short' | 'long' | 'iso' = 'short'): string {
+        switch (format) {
+            case 'long':
+                return date.toLocaleString();
+            case 'iso':
+                return date.toISOString();
+            case 'short':
+            default:
+                return date.toLocaleDateString();
+        }
+    }
+
+    /**
+     * Get relative time (e.g., "2 hours ago")
+     */
+    static getRelativeTime(date: Date): string {
+        const diff = Date.now() - date.getTime();
+
+        if (diff < 0) {
+            return 'in the future';
+        }
+
+        const seconds = Math.floor(diff / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        const months = Math.floor(days / 30);
+        const years = Math.floor(days / 365);
+
+        if (years > 0) return `${years} year${years > 1 ? 's' : ''} ago`;
+        if (months > 0) return `${months} month${months > 1 ? 's' : ''} ago`;
+        if (days > 0) return `${days} day${days > 1 ? 's' : ''} ago`;
+        if (hours > 0) return `${hours} hour${hours > 1 ? 's' : ''} ago`;
+        if (minutes > 0) return `${minutes} minute${minutes > 1 ? 's' : ''} ago`;
+        if (seconds > 10) return `${seconds} seconds ago`;
+        return 'just now';
+    }
+}