@ackplus/nest-auth 0.1.51 → 1.1.0

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

@@ -0,0 +1,166 @@
+import { NestAuthSession } from '../entities/session.entity';
+import { SessionPayload } from '../../core/interfaces/token-payload.interface';
+import ms from 'ms';
+
+/**
+ * Session utility functions
+ */
+export class SessionUtil {
+    /**
+     * Extract session metadata (device, location, etc.)
+     */
+    static extractMetadata(session: NestAuthSession): {
+        device: string;
+        ip: string;
+        location?: string;
+        browser?: string;
+        os?: string;
+    } {
+        return {
+            device: session.deviceName || 'Unknown Device',
+            ip: session.ipAddress || 'Unknown IP',
+            // Can be extended with geo-location, browser detection, etc.
+        };
+    }
+
+    /**
+     * Calculate remaining session time
+     */
+    static getRemainingTime(session: NestAuthSession): {
+        milliseconds: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        formatted: string;
+    } {
+        if (!session.expiresAt) {
+            return {
+                milliseconds: 0,
+                seconds: 0,
+                minutes: 0,
+                hours: 0,
+                formatted: 'Never',
+            };
+        }
+
+        const now = Date.now();
+        const expiresAt = new Date(session.expiresAt).getTime();
+        const remaining = Math.max(0, expiresAt - now);
+
+        const seconds = Math.floor(remaining / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+
+        return {
+            milliseconds: remaining,
+            seconds,
+            minutes,
+            hours,
+            formatted: ms(remaining, { long: true }),
+        };
+    }
+
+    /**
+     * Check if session is about to expire (within threshold)
+     */
+    static isExpiringSoon(session: NestAuthSession, thresholdMs: number = 5 * 60 * 1000): boolean {
+        const remaining = this.getRemainingTime(session);
+        return remaining.milliseconds > 0 && remaining.milliseconds < thresholdMs;
+    }
+
+    /**
+     * Check if session is expired
+     */
+    static isExpired(session: NestAuthSession): boolean {
+        if (!session.expiresAt) return false;
+        return new Date() > new Date(session.expiresAt);
+    }
+
+    /**
+     * Check if session is active (not expired)
+     */
+    static isActive(session: NestAuthSession): boolean {
+        return !this.isExpired(session);
+    }
+
+    /**
+     * Format session for display
+     */
+    static formatForDisplay(session: NestAuthSession): {
+        id: string;
+        device: string;
+        ipAddress: string;
+        lastActive: string;
+        expiresAt: string;
+        isActive: boolean;
+        isCurrent?: boolean;
+    } {
+        return {
+            id: session.id,
+            device: session.deviceName || 'Unknown',
+            ipAddress: session.ipAddress || 'Unknown',
+            lastActive: session.lastActive
+                ? new Date(session.lastActive).toLocaleString()
+                : 'Unknown',
+            expiresAt: session.expiresAt
+                ? new Date(session.expiresAt).toLocaleString()
+                : 'Never',
+            isActive: this.isActive(session),
+        };
+    }
+
+    /**
+     * Sanitize session data (remove sensitive information)
+     */
+    static sanitize(session: NestAuthSession): Partial<NestAuthSession> {
+        const { refreshToken, data, ...sanitized } = session;
+        return sanitized;
+    }
+
+    /**
+     * Compare two sessions
+     */
+    static isSameDevice(session1: NestAuthSession, session2: NestAuthSession): boolean {
+        return (
+            session1.deviceName === session2.deviceName &&
+            session1.userAgent === session2.userAgent &&
+            session1.ipAddress === session2.ipAddress
+        );
+    }
+
+    /**
+     * Get session age
+     */
+    static getAge(session: NestAuthSession): {
+        milliseconds: number;
+        formatted: string;
+    } {
+        if (!session.createdAt) {
+            return { milliseconds: 0, formatted: 'Unknown' };
+        }
+
+        const age = Date.now() - new Date(session.createdAt).getTime();
+        return {
+            milliseconds: age,
+            formatted: ms(age, { long: true }),
+        };
+    }
+
+    /**
+     * Get idle time (time since last activity)
+     */
+    static getIdleTime(session: NestAuthSession): {
+        milliseconds: number;
+        formatted: string;
+    } {
+        if (!session.lastActive) {
+            return { milliseconds: 0, formatted: 'Unknown' };
+        }
+
+        const idle = Date.now() - new Date(session.lastActive).getTime();
+        return {
+            milliseconds: idle,
+            formatted: ms(idle, { long: true }),
+        };
+    }
+}

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

@@ -0,0 +1,40 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from "typeorm";
+
+@Entity('nest_auth_tenants')
+export class NestAuthTenant {
+    @PrimaryGeneratedColumn('uuid')
+    id: string;
+
+    @Column()
+    name: string;
+
+    /**
+     * Unique slug/identifier for the tenant
+     * Format: lowercase, letters, numbers, hyphens, underscores only
+     * Examples: 'my-app', 'acme_corp', 'tenant123'
+     */
+    @Column({ unique: true, nullable: true })
+    slug: string;
+
+    /**
+     * @deprecated Use 'slug' instead. Will be removed in v2.0.0
+     * Legacy domain field - kept for backward compatibility
+     */
+    @Column({ unique: true, nullable: true })
+    domain: string;
+
+    @Column({ nullable: true })
+    description: string;
+
+    @Column({ type: 'simple-json', nullable: true, default: '{}' })
+    metadata: Record<string, any>;
+
+    @Column({ default: true })
+    isActive: boolean;
+
+    @CreateDateColumn()
+    createdAt: Date;
+
+    @UpdateDateColumn()
+    updatedAt: Date;
+}

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

@@ -0,0 +1,9 @@
+import { NestAuthTenant } from "../entities/tenant.entity";
+
+export interface TenantCreatedEventPayload {
+    tenant: NestAuthTenant;
+}
+
+export class TenantCreatedEvent {
+    constructor(public readonly payload: TenantCreatedEventPayload) { }
+}

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

@@ -0,0 +1,11 @@
+import { NestAuthTenant } from "../entities/tenant.entity";
+
+export interface TenantDeletedEventPayload {
+    tenant: NestAuthTenant;
+}
+
+export class TenantDeletedEvent {
+    constructor(
+        public readonly payload: TenantDeletedEventPayload,
+    ) { }
+}

package/src/lib/tenant/events/{tenant-updated.event.d.ts → tenant-updated.event.ts}

@@ -1,9 +1,12 @@
 import { NestAuthTenant } from "../entities/tenant.entity";
+
 export interface TenantUpdatedEventPayload {
     tenant: NestAuthTenant;
     updatedFields: string[];
 }
-export declare class TenantUpdatedEvent {
-    readonly payload: TenantUpdatedEventPayload;
-    constructor(payload: TenantUpdatedEventPayload);
+
+export class TenantUpdatedEvent {
+    constructor(
+        public readonly payload: TenantUpdatedEventPayload,
+    ) { }
 }

package/src/lib/tenant/index.ts

@@ -0,0 +1,9 @@
+export * from './tenant.module';
+export * from './services/tenant.service';
+export * from './events/tenant-created.event';
+export * from './events/tenant-deleted.event';
+export * from './events/tenant-updated.event';
+export * from './entities/tenant.entity';
+
+// Re-export slug utilities for convenience
+export { isValidSlug, toSlug } from '../utils/slug.util';

package/src/lib/tenant/services/tenant.service.ts

@@ -0,0 +1,336 @@
+import { Injectable, NotFoundException, BadRequestException, ConflictException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { FindManyOptions, FindOneOptions, Repository } from 'typeorm';
+import { NestAuthTenant } from '../entities/tenant.entity';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { TenantCreatedEvent } from '../events/tenant-created.event';
+import { TenantUpdatedEvent } from '../events/tenant-updated.event';
+import { TenantDeletedEvent } from '../events/tenant-deleted.event';
+import { NestAuthEvents } from '../../auth.constants';
+import { AuthConfigService } from '../../core/services/auth-config.service';
+import { DebugLoggerService } from '../../core/services/debug-logger.service';
+import { isValidSlug, toSlug } from '../../utils/slug.util';
+
+@Injectable()
+export class TenantService {
+
+    private defaultTenant: NestAuthTenant | null = null;
+
+    constructor(
+        @InjectRepository(NestAuthTenant)
+        private tenantRepository: Repository<NestAuthTenant>,
+        private eventEmitter: EventEmitter2,
+        private authConfig: AuthConfigService,
+        private debugLogger: DebugLoggerService
+    ) { }
+
+    async createTenant(data: Partial<NestAuthTenant>): Promise<NestAuthTenant> {
+        // Use slug if provided, fallback to domain for backward compatibility
+        const identifier = data.slug || data.domain;
+        this.debugLogger.logTenantOperation('createTenant', undefined, { slug: data.slug, domain: data.domain, name: data.name });
+
+        // Validate slug format if provided
+        if (data.slug && !isValidSlug(data.slug)) {
+            throw new BadRequestException({
+                message: `Invalid slug format. Slug must be lowercase with only letters, numbers, hyphens (-) and underscores (_). Got: '${data.slug}'`,
+                code: 'INVALID_SLUG_FORMAT'
+            });
+        }
+
+        // Check for existing tenant with same slug or domain
+        this.debugLogger.debug('Checking for existing tenant', 'TenantService', { slug: data.slug, domain: data.domain });
+
+        let existingTenant: NestAuthTenant | null = null;
+        if (data.slug) {
+            existingTenant = await this.getTenantBySlug(data.slug);
+        } else if (data.domain) {
+            existingTenant = await this.getTenantByDomain(data.domain);
+        }
+
+        if (existingTenant) {
+            const identifier = data.slug || data.domain;
+            this.debugLogger.warn('Tenant already exists', 'TenantService', { identifier, existingTenantId: existingTenant.id });
+            throw new ConflictException({
+                message: `Tenant with ${data.slug ? 'slug' : 'domain'} '${identifier}' already exists`,
+                code: 'TENANT_ALREADY_EXISTS'
+            });
+        }
+
+        const tenant = this.tenantRepository.create(data);
+        await this.tenantRepository.save(tenant);
+
+        // Emit tenant created event
+        await this.eventEmitter.emitAsync(
+            NestAuthEvents.TENANT_CREATED,
+            new TenantCreatedEvent({
+                tenant
+            })
+        );
+
+        return tenant;
+    }
+
+    async getTenantById(id: string, options?: FindOneOptions<NestAuthTenant>): Promise<NestAuthTenant> {
+        if (!id) {
+            return null;
+        }
+
+        const tenant = await this.tenantRepository.findOne({
+            ...(options ? options : {}),
+            where: { id }
+        });
+
+        if (!tenant) {
+            return null;
+        }
+        return tenant;
+    }
+
+    /**
+     * Get tenant by slug (recommended)
+     */
+    async getTenantBySlug(slug: string, options?: FindOneOptions<NestAuthTenant>): Promise<NestAuthTenant> {
+        if (!slug) {
+            return null;
+        }
+
+        const tenant = await this.tenantRepository.findOne({
+            ...(options ? options : {}),
+            where: { slug }
+        });
+
+        return tenant;
+    }
+
+    /**
+     * @deprecated Use getTenantBySlug instead. Will be removed in v2.0.0
+     * Get tenant by domain (legacy method)
+     */
+    async getTenantByDomain(domain: string, options?: FindOneOptions<NestAuthTenant>): Promise<NestAuthTenant> {
+        if (!domain) {
+            return null;
+        }
+
+        const tenant = await this.tenantRepository.findOne({
+            ...(options ? options : {}),
+            where: { domain }
+        });
+
+        return tenant;
+    }
+
+    async getTenants(options?: FindManyOptions<NestAuthTenant>): Promise<NestAuthTenant[]> {
+        return this.tenantRepository.find(options);
+    }
+
+    async updateTenant(id: string, data: Partial<NestAuthTenant>): Promise<NestAuthTenant> {
+        const tenant = await this.getTenantById(id);
+
+        if (!tenant) {
+            throw new NotFoundException({
+                message: `Tenant with ID ${id} not found`,
+                code: 'TENANT_NOT_FOUND'
+            });
+        }
+
+        // Validate slug format if being changed
+        if (data.slug && !isValidSlug(data.slug)) {
+            throw new BadRequestException({
+                message: `Invalid slug format. Slug must be lowercase with only letters, numbers, hyphens (-) and underscores (_). Got: '${data.slug}'`,
+                code: 'INVALID_SLUG_FORMAT'
+            });
+        }
+
+        // If slug is being changed, check for conflicts
+        if (data.slug && data.slug !== tenant.slug) {
+            const existingTenant = await this.getTenantBySlug(data.slug);
+
+            if (existingTenant && existingTenant.id !== tenant.id) {
+                throw new ConflictException({
+                    message: `Tenant with slug '${data.slug}' already exists`,
+                    code: 'TENANT_ALREADY_EXISTS'
+                });
+            }
+        }
+
+        // If domain is being changed, check for conflicts (legacy support)
+        if (data.domain && data.domain !== tenant.domain) {
+            const existingTenant = await this.getTenantByDomain(data.domain);
+
+            if (existingTenant && existingTenant.id !== tenant.id) {
+                throw new ConflictException({
+                    message: `Tenant with domain '${data.domain}' already exists`,
+                    code: 'TENANT_ALREADY_EXISTS'
+                });
+            }
+        }
+
+        Object.assign(tenant, data);
+        const updatedTenant = await this.tenantRepository.save(tenant);
+
+        // Emit tenant updated event
+        await this.eventEmitter.emitAsync(
+            NestAuthEvents.TENANT_UPDATED,
+            new TenantUpdatedEvent({
+                tenant: updatedTenant,
+                updatedFields: Object.keys(data)
+            })
+        );
+
+        return updatedTenant;
+    }
+
+    async deleteTenant(id: string): Promise<void> {
+        const tenant = await this.getTenantById(id);
+
+        if (!tenant) {
+            throw new NotFoundException({
+                message: `Tenant with ID ${id} not found`,
+                code: 'TENANT_NOT_FOUND'
+            });
+        }
+
+        // Emit tenant deleted event before deletion
+        await this.eventEmitter.emitAsync(
+            NestAuthEvents.TENANT_DELETED,
+            new TenantDeletedEvent({
+                tenant
+            })
+        );
+
+        await this.tenantRepository.remove(tenant);
+    }
+
+    async updateTenantStatus(id: string, isActive: boolean): Promise<NestAuthTenant> {
+        const tenant = await this.getTenantById(id);
+
+        if (!tenant) {
+            throw new NotFoundException({
+                message: `Tenant with ID ${id} not found`,
+                code: 'TENANT_NOT_FOUND'
+            });
+        }
+
+        tenant.isActive = isActive;
+        const updatedTenant = await this.tenantRepository.save(tenant);
+        return updatedTenant;
+    }
+
+    async updateTenantMetadata(id: string, metadata: Record<string, any>): Promise<NestAuthTenant> {
+        const tenant = await this.getTenantById(id);
+
+        if (!tenant) {
+            throw new NotFoundException({
+                message: `Tenant with ID ${id} not found`,
+                code: 'TENANT_NOT_FOUND'
+            });
+        }
+
+        tenant.metadata = {
+            ...tenant.metadata,
+            ...metadata
+        };
+
+        const updatedTenant = await this.tenantRepository.save(tenant);
+        return updatedTenant;
+    }
+
+    async initializeDefaultTenant(): Promise<NestAuthTenant | null> {
+        const config = this.authConfig.getConfig();
+
+        if (!config.defaultTenant) {
+            return null;
+        }
+
+        // Support both slug and domain for backward compatibility
+        // Prefer slug over domain
+        const identifier = config.defaultTenant.slug || config.defaultTenant.domain;
+
+        if (!identifier) {
+            throw new BadRequestException({
+                message: 'defaultTenant must have either "slug" or "domain" field',
+                code: 'MISSING_TENANT_IDENTIFIER'
+            });
+        }
+
+        // Validate slug format if provided
+        if (config.defaultTenant.slug && !isValidSlug(config.defaultTenant.slug)) {
+            throw new BadRequestException({
+                message: `Invalid slug format in defaultTenant. Slug must be lowercase with only letters, numbers, hyphens (-) and underscores (_). Got: '${config.defaultTenant.slug}'`,
+                code: 'INVALID_SLUG_FORMAT'
+            });
+        }
+
+        // Check if default tenant already exists
+        let defaultTenant: NestAuthTenant | null = null;
+
+        if (config.defaultTenant.slug) {
+            defaultTenant = await this.getTenantBySlug(config.defaultTenant.slug);
+        } else if (config.defaultTenant.domain) {
+            defaultTenant = await this.getTenantByDomain(config.defaultTenant.domain);
+        }
+
+        if (!defaultTenant) {
+            // Create the default tenant
+            try {
+                defaultTenant = await this.createTenant({
+                    name: config.defaultTenant.name,
+                    slug: config.defaultTenant.slug || null,
+                    domain: config.defaultTenant.domain || null,  // Legacy support
+                    description: config.defaultTenant.description || 'Default tenant',
+                    metadata: config.defaultTenant.metadata || {},
+                    isActive: true
+                });
+            } catch (error) {
+                // If tenant already exists, try to find it
+                if (error.code === 'TENANT_ALREADY_EXISTS') {
+                    if (config.defaultTenant.slug) {
+                        defaultTenant = await this.getTenantBySlug(config.defaultTenant.slug);
+                    } else if (config.defaultTenant.domain) {
+                        defaultTenant = await this.getTenantByDomain(config.defaultTenant.domain);
+                    }
+                }
+
+                if (!defaultTenant) {
+                    throw error;
+                }
+            }
+        }
+
+        this.defaultTenant = defaultTenant;
+        return defaultTenant;
+    }
+
+    getDefaultTenant(): NestAuthTenant | null {
+        return this.defaultTenant;
+    }
+
+    getDefaultTenantId(): string | null {
+        return this.defaultTenant?.id || null;
+    }
+
+    async getOrCreateDefaultTenant(): Promise<NestAuthTenant | null> {
+        if (this.defaultTenant) {
+            return this.defaultTenant;
+        }
+
+        return await this.initializeDefaultTenant();
+    }
+
+    async resolveTenantId(providedTenantId?: string | null): Promise<string | null> {
+        this.debugLogger.logTenantOperation('resolveTenantId', providedTenantId, { providedTenantId });
+
+        // If tenant ID is explicitly provided, use it
+        if (providedTenantId) {
+            this.debugLogger.debug('Using provided tenant ID', 'TenantService', { tenantId: providedTenantId });
+            return providedTenantId;
+        }
+
+        // If no tenant ID provided, try to get default tenant
+        const defaultTenant = await this.getOrCreateDefaultTenant();
+        const resolvedTenantId = defaultTenant?.id || null;
+        this.debugLogger.debug('Resolved tenant ID', 'TenantService', { resolvedTenantId, hasDefaultTenant: !!defaultTenant });
+        return resolvedTenantId;
+    }
+
+}

package/src/lib/tenant/tenant.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { TenantService } from './services/tenant.service';
+import { NestAuthTenant } from './entities/tenant.entity';
+import { EventEmitterModule } from '@nestjs/event-emitter';
+
+@Module({
+    imports: [
+        EventEmitterModule,
+        TypeOrmModule.forFeature([NestAuthTenant]),
+    ],
+    providers: [
+        TenantService,
+    ],
+    exports: [
+        TenantService,
+    ],
+})
+export class TenantModule { }

package/src/lib/types/express.d.ts

@@ -0,0 +1,14 @@
+import { JWTTokenPayload, SessionPayload } from '../interfaces/token-payload.interface';
+
+declare global {
+    namespace Express {
+        interface Request {
+            user?: JWTTokenPayload;
+            session?: SessionPayload;
+            newTokens?: {
+                accessToken: string;
+                refreshToken: string;
+            };
+        }
+    }
+}

package/src/lib/user/dto/requests/update-user.dto.ts

@@ -0,0 +1,15 @@
+import { IsString, IsOptional } from 'class-validator';
+
+export class UpdateUserDto {
+    @IsString()
+    @IsOptional()
+    firstName?: string;
+
+    @IsString()
+    @IsOptional()
+    lastName?: string;
+
+    @IsString()
+    @IsOptional()
+    displayName?: string;
+}

package/src/lib/user/entities/access-key.entity.ts

@@ -0,0 +1,53 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    CreateDateColumn,
+    UpdateDateColumn,
+    ManyToOne,
+    BaseEntity,
+    RelationId,
+    JoinColumn
+} from "typeorm";
+import { NestAuthUser } from "./user.entity";
+
+@Entity('nest_auth_access_keys')
+export class NestAuthAccessKey extends BaseEntity {
+    @PrimaryGeneratedColumn('uuid')
+    id: string;
+
+    @Column()
+    name: string;
+
+    @Column({ unique: true })
+    publicKey: string;
+
+    @Column()
+    privateKey: string;
+
+    @Column({ nullable: true })
+    description?: string;
+
+    @Column({ default: true })
+    isActive: boolean;
+
+    @Column({ nullable: true })
+    expiresAt?: Date;
+
+    @Column({ nullable: true })
+    lastUsedAt?: Date;
+
+    @Column()
+    @RelationId((accessKey: NestAuthAccessKey) => accessKey.user)
+    userId: string;
+
+    @ManyToOne(() => NestAuthUser, { onDelete: 'CASCADE' })
+    @JoinColumn({ name: 'userId' })
+    user: NestAuthUser;
+
+    @CreateDateColumn()
+    createdAt: Date;
+
+    @UpdateDateColumn()
+    updatedAt: Date;
+}