@ackplus/nest-auth 1.1.1 → 1.1.5

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

@@ -1,103 +0,0 @@
-import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, BaseEntity, Unique, ManyToOne, RelationId, ManyToMany, JoinTable } from "typeorm";
-import { uniq } from "lodash";
-import { DEFAULT_GUARD_NAME } from "../../auth.constants";
-import { NestAuthTenant } from "../../tenant/entities/tenant.entity";
-import { BadRequestException, ConflictException } from "@nestjs/common";
-import { NestAuthUser } from "../../user/entities/user.entity";
-
-@Entity('nest_auth_roles')
-@Unique(['name', 'guard', 'tenantId'])
-export class NestAuthRole extends BaseEntity {
-    @PrimaryGeneratedColumn('uuid')
-    id: string;
-
-    @Column()
-    name: string;
-
-    @Column({ nullable: true, default: DEFAULT_GUARD_NAME })
-    guard: string;
-
-    @Column({ nullable: true })
-    @RelationId((role: NestAuthRole) => role.tenant)
-    tenantId: string;
-
-    @ManyToOne(() => NestAuthTenant, { onDelete: 'CASCADE' })
-    tenant: NestAuthTenant;
-
-    @Column({ default: false })
-    isSystem: boolean;
-
-    @Column({ default: true })
-    isActive: boolean;
-
-    @Column({
-        type: 'simple-json',
-        nullable: true,
-        default: '{}'
-    })
-    permissions: string[];
-
-    @CreateDateColumn()
-    createdAt: Date;
-
-    @UpdateDateColumn()
-    updatedAt: Date;
-
-    @ManyToMany(() => NestAuthUser, user => user.roles, { onDelete: 'CASCADE' })
-    @JoinTable({
-        name: 'nest_auth_role_nest_auth_users',
-        joinColumn: {
-            name: 'nestAuthRolesId',
-            referencedColumnName: 'id',
-        },
-        inverseJoinColumn: {
-            name: 'nestAuthUsersId',
-            referencedColumnName: 'id',
-        },
-    })
-    users: NestAuthUser[];
-
-    static async createRole(
-        name: string,
-        guard: string = DEFAULT_GUARD_NAME,
-        isSystem: boolean = false,
-        tenantId: string
-    ): Promise<NestAuthRole> {
-
-        // Check if system role with same name exists
-        const existingSystemRole = await NestAuthRole.findOne({
-            where: { name, isSystem: true }
-        });
-        if (existingSystemRole) {
-            throw new ConflictException(`Cannot create role with name '${name}' as it conflicts with a system role`);
-        }
-
-        if (!isSystem && !tenantId) {
-            throw new BadRequestException('Tenant ID is required');
-        }
-
-        const role = new NestAuthRole();
-        role.name = name;
-        role.guard = guard;
-        role.isSystem = isSystem;
-        role.tenantId = isSystem ? null : tenantId;
-        await role.save();
-        return role;
-    }
-
-    async syncPermissions(permissions: string | string[]): Promise<void> {
-        const newPermissions = Array.isArray(permissions) ? permissions : [permissions];
-        this.permissions = newPermissions;
-    }
-
-    async removePermissions(permissions: string | string[]): Promise<void> {
-        const removingPermissions = Array.isArray(permissions) ? permissions : [permissions];
-        this.permissions = this.permissions.filter(permission => !removingPermissions.includes(permission));
-    }
-
-    async attachPermissions(permissions: string | string[]): Promise<void> {
-        const existingPermissions = this.permissions;
-        const newPermissions = Array.isArray(permissions) ? permissions : [permissions];
-        this.permissions = uniq([...existingPermissions, ...newPermissions]);
-    }
-}

package/src/lib/role/role.module.ts

@@ -1,15 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { NestAuthRole } from './entities/role.entity';
-import { RoleService } from './services/role.service';
-import { TenantModule } from '../tenant/tenant.module';
-
-@Module({
-    imports: [
-        TypeOrmModule.forFeature([NestAuthRole]),
-        TenantModule,
-    ],
-    providers: [RoleService],
-    exports: [RoleService],
-})
-export class RoleModule { }

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

@@ -1,54 +0,0 @@
-import {
-    Entity,
-    Column,
-    PrimaryGeneratedColumn,
-    CreateDateColumn,
-    UpdateDateColumn,
-    ManyToOne,
-    JoinColumn,
-    BaseEntity,
-    RelationId
-} from 'typeorm';
-import { NestAuthUser } from '../../user/entities/user.entity';
-
-
-@Entity('nest_auth_sessions')
-export class NestAuthSession extends BaseEntity {
-    @PrimaryGeneratedColumn('uuid')
-    id: string;
-
-    @Column({ nullable: true })
-    @RelationId((session: NestAuthSession) => session.user)
-    userId: string;
-
-    @ManyToOne(() => NestAuthUser, { onDelete: 'CASCADE' })
-    @JoinColumn({ name: 'userId' })
-    user: NestAuthUser;
-
-    @Column('simple-json', { nullable: true, default: '{}' })
-    data?: any;
-
-    @Column({ nullable: true })
-    refreshToken: string;
-
-    @Column({ nullable: true })
-    expiresAt: Date;
-
-    @Column({ nullable: true })
-    userAgent?: string;
-
-    @Column({ nullable: true })
-    deviceName?: string;
-
-    @Column({ nullable: true })
-    ipAddress?: string;
-
-    @Column({ nullable: true })
-    lastActive: Date;
-
-    @CreateDateColumn()
-    createdAt?: Date;
-
-    @UpdateDateColumn()
-    updatedAt?: Date;
-}

package/src/lib/session/repositories/typeorm-session.repository.ts

@@ -1,86 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, MoreThan, LessThan } from 'typeorm';
-import { BaseSessionRepository } from './base-session.repository';
-import { NestAuthSession } from '../entities/session.entity';
-import { SessionPayload } from '../../core/interfaces/token-payload.interface';
-import { v4 as uuidv4 } from 'uuid';
-
-/**
- * TypeORM implementation of session repository
- * Stores sessions in PostgreSQL/MySQL database
- */
-@Injectable()
-export class TypeORMSessionRepository extends BaseSessionRepository {
-    constructor(
-        @InjectRepository(NestAuthSession)
-        private readonly repository: Repository<NestAuthSession>,
-    ) {
-        super();
-    }
-
-    async create(session: SessionPayload): Promise<NestAuthSession> {
-        const sessionEntity = this.repository.create(session);
-
-        return await this.repository.save(sessionEntity);
-    }
-
-    async findById(sessionId: string): Promise<NestAuthSession | null> {
-        return await this.repository.findOne({
-            where: { id: sessionId },
-            relations: ['user'],
-        });
-    }
-
-    async findByUserId(userId: string): Promise<NestAuthSession[]> {
-        return await this.repository.find({
-            where: { userId },
-            order: { createdAt: 'DESC' },
-        });
-    }
-
-    async findActiveByUserId(userId: string): Promise<NestAuthSession[]> {
-        return await this.repository.find({
-            where: {
-                userId,
-                expiresAt: MoreThan(new Date()),
-            },
-            order: { lastActive: 'DESC' },
-        });
-    }
-
-    async update(sessionId: string, updates: Partial<NestAuthSession>): Promise<NestAuthSession> {
-        await this.repository.update(sessionId, updates);
-        return await this.findById(sessionId);
-    }
-
-    async delete(sessionId: string): Promise<void> {
-        await this.repository.delete(sessionId);
-    }
-
-    async deleteByUserId(userId: string): Promise<void> {
-        await this.repository.delete({ userId });
-    }
-
-    async deleteExpired(): Promise<number> {
-        const result = await this.repository.delete({
-            expiresAt: LessThan(new Date()),
-        });
-        return result.affected || 0;
-    }
-
-    async countActiveByUserId(userId: string): Promise<number> {
-        return await this.repository.count({
-            where: {
-                userId,
-                expiresAt: MoreThan(new Date()),
-            },
-        });
-    }
-
-    async updateLastActive(sessionId: string): Promise<void> {
-        await this.repository.update(sessionId, {
-            lastActive: new Date(),
-        });
-    }
-}

package/src/lib/session/session.module.ts

@@ -1,102 +0,0 @@
-import { Module, forwardRef } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { NestAuthSession } from './entities/session.entity';
-import { SessionManagerService, SESSION_REPOSITORY } from './services/session-manager.service';
-import { TypeORMSessionRepository } from './repositories/typeorm-session.repository';
-import { MemorySessionRepository } from './repositories/memory-session.repository';
-import { CoreModule } from '../core/core.module';
-import { SessionStorageType } from '../core/interfaces/session-options.interface';
-import { AuthConfigService } from '../core/services/auth-config.service';
-
-/**
- * Session Module
- *
- * DEFAULT: Uses TypeORM (Database) for session storage
- * OPTIONAL: Can use Redis if configured (requires ioredis packages)
- */
-@Module({
-    imports: [
-        TypeOrmModule.forFeature([NestAuthSession]),
-        forwardRef(() => CoreModule),
-    ],
-    providers: [
-        // Repository implementations
-        TypeORMSessionRepository,
-        MemorySessionRepository,
-
-        // Session Repository Provider (dynamically chooses storage)
-        {
-            provide: SESSION_REPOSITORY,
-            useFactory: (typeormRepo: TypeORMSessionRepository) => {
-                const config = AuthConfigService.getOptions();
-                const storageType = config.session?.storageType || SessionStorageType.DATABASE;
-
-                // Handle Redis storage
-                if (storageType === SessionStorageType.REDIS) {
-                    return SessionModule.createRedisRepository(config.session?.redisUrl);
-                }
-
-                if (storageType === SessionStorageType.MEMORY) {
-                    return new MemorySessionRepository();
-                }
-
-                // Default to database storage
-                return typeormRepo;
-            },
-            inject: [TypeORMSessionRepository],
-        },
-
-        // Session Manager
-        SessionManagerService,
-    ],
-    exports: [
-        SESSION_REPOSITORY,
-        SessionManagerService,
-        TypeORMSessionRepository,
-        MemorySessionRepository,
-    ],
-})
-export class SessionModule {
-    /**
-     * Create Redis repository instance
-     * Only called if Redis storage is configured
-     */
-    private static createRedisRepository(redisUrl?: string): any {
-        let RedisSessionRepository: any;
-        let ioredisModule: any;
-        let redisClient: any;
-
-        // Try to load Redis modules
-        try {
-            // Lazy load Redis repository
-            RedisSessionRepository = require('./repositories/redis-session.repository').RedisSessionRepository;
-            ioredisModule = require('@nestjs-modules/ioredis');
-            const Redis = require('ioredis').default || require('ioredis');
-
-            // Create Redis client
-            if (redisUrl) {
-                redisClient = new Redis(redisUrl);
-            } else {
-                redisClient = new Redis(); // Uses default localhost:6379
-            }
-
-            // Return repository instance
-            return new RedisSessionRepository(redisClient);
-        } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-
-            if (errorMessage.includes('Cannot find module')) {
-                throw new Error(
-                    '❌ Redis session storage is configured but packages are not installed.\n' +
-                    '   Install them with: npm install ioredis @nestjs-modules/ioredis\n' +
-                    '   Or change session.storageType to SessionStorageType.DATABASE'
-                );
-            }
-
-            throw new Error(
-                `❌ Failed to initialize Redis session storage: ${errorMessage}\n` +
-                '   Make sure Redis server is running and accessible.'
-            );
-        }
-    }
-}

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

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

@@ -1,11 +0,0 @@
-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.ts

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

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

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

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

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

@@ -1,53 +0,0 @@
-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;
-}

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

@@ -1,31 +0,0 @@
-import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, ManyToOne, RelationId, JoinColumn, BaseEntity } from "typeorm";
-import { NestAuthUser } from "./user.entity";
-
-@Entity('nest_auth_identities')
-export class NestAuthIdentity extends BaseEntity {
-    @PrimaryGeneratedColumn('uuid')
-    id: string;
-
-    @Column()
-    provider: string;
-
-    @Column({ nullable: true })
-    providerId: string;
-
-    @Column({ type: 'simple-json', nullable: true, default: '{}' })
-    metadata: Record<string, any>;
-
-    @CreateDateColumn()
-    createdAt: Date;
-
-    @UpdateDateColumn()
-    updatedAt: Date;
-
-    @Column({ nullable: true })
-    @RelationId((identity: NestAuthIdentity) => identity.user)
-    userId: string;
-
-    @ManyToOne(() => NestAuthUser, { onDelete: 'CASCADE' })
-    @JoinColumn({ name: 'userId' })
-    user: NestAuthUser;
-}