@ackplus/nest-auth 1.1.1 → 1.1.5

package/src/lib/user/entities/user.entity.ts

@@ -1,212 +0,0 @@
-import {
-    Entity,
-    PrimaryGeneratedColumn,
-    Column,
-    CreateDateColumn,
-    UpdateDateColumn,
-    ManyToOne,
-    OneToMany,
-    BaseEntity,
-    Index,
-    BeforeInsert,
-    BeforeUpdate,
-    ManyToMany,
-    In,
-} from "typeorm";
-import * as argon2 from 'argon2';
-import { NestAuthTenant } from "../../tenant/entities/tenant.entity";
-import { NestAuthIdentity } from "./identity.entity";
-import { NestAuthSession } from "../../session/entities/session.entity";
-import { chain } from "lodash";
-import { NestAuthOTP } from "../../auth/entities/otp.entity";
-import { NestAuthMFASecret } from "../../auth/entities/mfa-secret.entity";
-import { NestAuthRole } from "../../role/entities/role.entity";
-
-@Entity('nest_auth_users')
-export class NestAuthUser extends BaseEntity {
-    @PrimaryGeneratedColumn('uuid')
-    id: string;
-
-    @Column({ nullable: true })
-    @Index()
-    email: string;
-
-    @Column({ nullable: true })
-    @Index()
-    emailVerifiedAt: Date;
-
-    @Column({ nullable: true })
-    @Index()
-    phone: string;
-
-    @Column({ nullable: true })
-    @Index()
-    phoneVerifiedAt: Date;
-
-    @Column({ nullable: true })
-    passwordHash: string;
-
-    @Column({ default: false })
-    isVerified: boolean;
-
-    @Column({ default: true })
-    isActive: boolean;
-
-    @Column({ type: 'simple-json', nullable: true, default: '{}' })
-    metadata?: Record<string, any>;
-
-    @Column({ nullable: true })
-    tenantId?: string;
-
-    @Column({ default: false })
-    isMfaEnabled: boolean;
-
-    @Column({ nullable: true })
-    mfaRecoveryCode?: string;
-
-    @ManyToOne(() => NestAuthTenant, { onDelete: 'CASCADE' })
-    tenant: NestAuthTenant;
-
-    @OneToMany(() => NestAuthIdentity, identity => identity.user)
-    identities: NestAuthIdentity[];
-
-    @OneToMany(() => NestAuthMFASecret, mfaSecret => mfaSecret.user)
-    mfaSecrets: NestAuthMFASecret[];
-
-    @OneToMany(() => NestAuthSession, session => session.user)
-    sessions: NestAuthSession[];
-
-    @OneToMany(() => NestAuthOTP, otp => otp.user)
-    otps: NestAuthOTP[];
-
-    @ManyToMany(() => NestAuthRole, role => role.users, { onDelete: 'CASCADE' })
-    roles: NestAuthRole[];
-
-    @Index('IDX_USER_EMAIL_TENANT', { unique: true })
-    @Column({ nullable: true })
-    emailTenant: string;
-
-    @Index('IDX_USER_PHONE_TENANT', { unique: true })
-    @Column({ nullable: true })
-    phoneTenant: string;
-
-    @CreateDateColumn()
-    createdAt: Date;
-
-    @UpdateDateColumn()
-    updatedAt: Date;
-
-
-    @BeforeInsert()
-    @BeforeUpdate()
-    updateTenantFields() {
-        // Normalize email to lowercase for consistency
-        if (this.email) {
-            this.email = this.email.toLowerCase().trim();
-        }
-        this.emailTenant = this.email ? `${this.email}:${this.tenantId || 'global'}` : null;
-        this.phoneTenant = this.phone ? `${this.phone}:${this.tenantId || 'global'}` : null;
-    }
-
-    async getPermissions(): Promise<string[]> {
-        if (!this.roles) {
-            this.roles = await NestAuthRole.find({
-                select: {
-                    id: true,
-                    name: true,
-                    permissions: true
-                },
-                where: { users: { id: this.id }, tenantId: this.tenantId }
-            });
-        }
-        return chain(this.roles)
-            .map(role => role.permissions)
-            .flatten()
-            .uniq()
-            .value();
-    }
-
-    async getRoles(): Promise<NestAuthRole[]> {
-        if (!this.roles) {
-            this.roles = await NestAuthRole.find({
-                select: {
-                    id: true,
-                    name: true,
-                    isSystem: true,
-                    guard: true,
-                },
-                where: { users: { id: this.id }, tenantId: this.tenantId }
-            });
-        }
-        return this.roles;
-    }
-
-    async assignRoles(roles: string | string[], guard: string): Promise<void> {
-        // Find both system roles and tenant - specific roles
-        this.roles = await NestAuthRole.find({
-            where: [
-                // System roles (tenantId is null)
-                { name: In(Array.isArray(roles) ? roles : [roles]), isSystem: true, guard },
-                // Tenant-specific roles
-                { name: In(Array.isArray(roles) ? roles : [roles]), tenantId: this.tenantId, isSystem: false, guard }
-            ]
-        });
-    }
-
-    async findOrCreateIdentity(provider: string, providerId: string) {
-        const existingIdentity = await NestAuthIdentity.findOne({
-            where: { provider, providerId, userId: this.id }
-        });
-
-        if (existingIdentity) {
-            return existingIdentity;
-        }
-
-        const identity = new NestAuthIdentity();
-        identity.provider = provider;
-        identity.providerId = providerId;
-        identity.user = this;
-
-        return identity.save();
-    }
-
-    async updateOrCreateIdentity(
-        provider: string,
-        data: Partial<NestAuthIdentity>
-    ): Promise<NestAuthIdentity> {
-        let identity = {} as NestAuthIdentity;
-        if (provider) {
-            identity = await NestAuthIdentity.findOne({
-                where: { provider, userId: this.id },
-            });
-        }
-
-        identity = NestAuthIdentity.create<NestAuthIdentity>({
-            provider,
-            ...identity,
-            ...data,
-            userId: this.id,
-        });
-        return identity.save();
-    }
-
-    async validatePassword(password: string): Promise<boolean> {
-        if (!this.passwordHash) return false;
-        try {
-            return await argon2.verify(this.passwordHash, password);
-        } catch (error) {
-            // Invalid hash format or verification error
-            return false;
-        }
-    }
-
-    async setPassword(password: string): Promise<void> {
-        // Argon2id is the recommended variant (hybrid of Argon2i and Argon2d)
-        this.passwordHash = await argon2.hash(password, {
-            type: argon2.argon2id,
-            memoryCost: 65536, // 64 MiB
-            timeCost: 3,       // 3 iterations
-            parallelism: 4     // 4 parallel threads
-        });
-    }
-}

package/src/lib/user/events/user-created.event.ts

@@ -1,10 +0,0 @@
-import { NestAuthUser } from '../entities/user.entity';
-
-export interface UserCreatedEventPayload {
-    user: NestAuthUser;
-    tenantId?: string;
-}
-
-export class UserCreatedEvent {
-    constructor(public readonly payload: UserCreatedEventPayload) { }
-}

package/src/lib/user/events/user-deleted.event.ts

@@ -1,12 +0,0 @@
-import { NestAuthUser } from "../entities/user.entity";
-
-export interface UserDeletedEventPayload {
-    user: NestAuthUser;
-    tenantId?: string;
-}
-
-export class UserDeletedEvent {
-    constructor(
-        public readonly payload: UserDeletedEventPayload,
-    ) { }
-}

package/src/lib/user/events/user-updated.event.ts

@@ -1,13 +0,0 @@
-import { NestAuthUser } from "../entities/user.entity";
-
-export interface UserUpdatedEventPayload {
-    user: NestAuthUser;
-    tenantId?: string;
-    updatedFields: string[];
-}
-
-export class UserUpdatedEvent {
-    constructor(
-        public readonly payload: UserUpdatedEventPayload,
-    ) { }
-}

package/src/lib/user/services/access-key.service.ts

@@ -1,145 +0,0 @@
-import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { NestAuthAccessKey } from '../entities/access-key.entity';
-import { NestAuthUser } from '../entities/user.entity';
-import { EventEmitter2 } from '@nestjs/event-emitter';
-import { randomBytes, createHash } from 'crypto';
-import { NestAuthEvents } from '../../auth.constants';
-
-@Injectable()
-export class AccessKeyService {
-    constructor(
-        @InjectRepository(NestAuthAccessKey)
-        private accessKeyRepository: Repository<NestAuthAccessKey>,
-
-        @InjectRepository(NestAuthUser)
-        private userRepository: Repository<NestAuthUser>,
-        private eventEmitter: EventEmitter2
-    ) { }
-
-    private generateKeyPair(): { publicKey: string; privateKey: string } {
-        const privateKey = randomBytes(32).toString('hex');
-        const publicKey = createHash('sha256').update(privateKey).digest('hex');
-        return { publicKey, privateKey };
-    }
-
-    async createAccessKey(userId: string, name: string): Promise<NestAuthAccessKey> {
-        const user = await this.userRepository.findOne({ where: { id: userId } });
-        if (!user) {
-            throw new NotFoundException({
-                message: `User with ID ${userId} not found`,
-                code: 'USER_NOT_FOUND'
-            });
-        }
-
-        const { publicKey, privateKey } = this.generateKeyPair();
-
-        const accessKey = this.accessKeyRepository.create({
-            name,
-            publicKey,
-            privateKey,
-            userId,
-        });
-
-        const savedKey = await this.accessKeyRepository.save(accessKey);
-
-        // Emit access key created event
-        await this.eventEmitter.emitAsync(
-            NestAuthEvents.ACCESS_KEY_CREATED,
-            {
-                accessKey: savedKey,
-                userId
-            }
-        );
-
-        return savedKey;
-    }
-
-    async getAccessKey(publicKey: string): Promise<NestAuthAccessKey> {
-        const accessKey = await this.accessKeyRepository.findOne({
-            where: { publicKey },
-            relations: ['user']
-        });
-
-        if (!accessKey) {
-            throw new NotFoundException({
-                message: 'Invalid access key',
-                code: 'INVALID_ACCESS_KEY'
-            });
-        }
-
-        if (!accessKey.isActive) {
-            throw new BadRequestException({
-                message: 'Access key is inactive',
-                code: 'INACTIVE_ACCESS_KEY'
-            });
-        }
-
-        if (accessKey.expiresAt && accessKey.expiresAt < new Date()) {
-            throw new BadRequestException({
-                message: 'Access key has expired',
-                code: 'EXPIRED_ACCESS_KEY'
-            });
-        }
-
-        return accessKey;
-    }
-
-    async validateAccessKey(publicKey: string, privateKey: string): Promise<boolean> {
-        const accessKey = await this.getAccessKey(publicKey);
-        return accessKey.privateKey === privateKey;
-    }
-
-    async getUserAccessKeys(userId: string): Promise<NestAuthAccessKey[]> {
-        return this.accessKeyRepository.find({
-            where: { userId },
-            order: { createdAt: 'DESC' }
-        });
-    }
-
-    async deactivateAccessKey(publicKey: string): Promise<NestAuthAccessKey> {
-        const accessKey = await this.getAccessKey(publicKey);
-        accessKey.isActive = false;
-
-        const updatedKey = await this.accessKeyRepository.save(accessKey);
-
-        // Emit access key deactivated event
-        await this.eventEmitter.emitAsync(
-            NestAuthEvents.ACCESS_KEY_DEACTIVATED,
-            {
-                accessKey: updatedKey,
-                userId: updatedKey.userId
-            }
-        );
-
-        return updatedKey;
-    }
-
-    async updateAccessKeyLastUsed(publicKey: string): Promise<void> {
-        const accessKey = await this.getAccessKey(publicKey);
-        accessKey.lastUsedAt = new Date();
-        await this.accessKeyRepository.save(accessKey);
-    }
-
-    async setAccessKeyExpiry(publicKey: string, expiresAt: Date): Promise<NestAuthAccessKey> {
-        const accessKey = await this.getAccessKey(publicKey);
-        accessKey.expiresAt = expiresAt;
-        return this.accessKeyRepository.save(accessKey);
-    }
-
-    async deleteAccessKey(publicKey: string): Promise<void> {
-        const accessKey = await this.getAccessKey(publicKey);
-
-        // Emit access key deleted event before deletion
-        await this.eventEmitter.emitAsync(
-            NestAuthEvents.ACCESS_KEY_DELETED,
-            {
-                accessKey,
-                userId: accessKey.userId
-            }
-        );
-
-        await this.accessKeyRepository.remove(accessKey);
-    }
-}

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

@@ -1,26 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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/device.util.ts

@@ -1,111 +0,0 @@
-/**
- * Device and user-agent utilities
- */
-export class DeviceUtil {
-    /**
-     * Parse user agent string
-     */
-    static parseUserAgent(userAgent: string): {
-        browser: string;
-        version: string;
-        os: string;
-        device: string;
-        isMobile: boolean;
-        isTablet: boolean;
-        isDesktop: boolean;
-    } {
-        const ua = userAgent.toLowerCase();
-
-        return {
-            browser: this.detectBrowser(ua),
-            version: this.detectBrowserVersion(ua),
-            os: this.detectOS(ua),
-            device: this.detectDevice(ua),
-            isMobile: this.isMobile(ua),
-            isTablet: this.isTablet(ua),
-            isDesktop: this.isDesktop(ua),
-        };
-    }
-
-    /**
-     * Detect browser from user agent
-     */
-    private static detectBrowser(ua: string): string {
-        if (ua.includes('edg/')) return 'Edge';
-        if (ua.includes('chrome/')) return 'Chrome';
-        if (ua.includes('firefox/')) return 'Firefox';
-        if (ua.includes('safari/') && !ua.includes('chrome')) return 'Safari';
-        if (ua.includes('opera') || ua.includes('opr/')) return 'Opera';
-        return 'Unknown';
-    }
-
-    /**
-     * Detect browser version
-     */
-    private static detectBrowserVersion(ua: string): string {
-        const match = ua.match(/(chrome|firefox|safari|edg|opr)\/(\d+)/);
-        return match ? match[2] : 'Unknown';
-    }
-
-    /**
-     * Detect operating system
-     */
-    private static detectOS(ua: string): string {
-        if (ua.includes('windows nt')) return 'Windows';
-        if (ua.includes('mac os x')) return 'macOS';
-        if (ua.includes('linux')) return 'Linux';
-        if (ua.includes('android')) return 'Android';
-        if (ua.includes('iphone') || ua.includes('ipad')) return 'iOS';
-        return 'Unknown';
-    }
-
-    /**
-     * Detect device type
-     */
-    private static detectDevice(ua: string): string {
-        if (ua.includes('iphone')) return 'iPhone';
-        if (ua.includes('ipad')) return 'iPad';
-        if (ua.includes('android')) return 'Android';
-        if (ua.includes('windows phone')) return 'Windows Phone';
-        if (ua.includes('macintosh')) return 'Mac';
-        if (ua.includes('windows')) return 'Windows PC';
-        if (ua.includes('linux')) return 'Linux PC';
-        return 'Unknown';
-    }
-
-    /**
-     * Check if mobile device
-     */
-    private static isMobile(ua: string): boolean {
-        return /mobile|android|iphone|ipod|blackberry|windows phone/i.test(ua);
-    }
-
-    /**
-     * Check if tablet
-     */
-    private static isTablet(ua: string): boolean {
-        return /ipad|android(?!.*mobile)|tablet/i.test(ua);
-    }
-
-    /**
-     * Check if desktop
-     */
-    private static isDesktop(ua: string): boolean {
-        return !this.isMobile(ua) && !this.isTablet(ua);
-    }
-
-    /**
-     * Generate friendly device name
-     */
-    static getDeviceName(userAgent: string): string {
-        const parsed = this.parseUserAgent(userAgent);
-
-        if (parsed.isMobile) {
-            return `${parsed.device} (${parsed.browser})`;
-        }
-        if (parsed.isTablet) {
-            return `${parsed.device} Tablet (${parsed.browser})`;
-        }
-        return `${parsed.os} (${parsed.browser})`;
-    }
-}

package/src/lib/utils/otp.ts

@@ -1,3 +0,0 @@
-export function generateOtp(length: number = 6): string {
-    return Math.floor(10 ** (length - 1) + Math.random() * (10 ** length - 10 ** (length - 1) - 1)).toString();
-}

package/src/types/ms.d.ts

@@ -1 +0,0 @@
-declare module 'ms';