@ackplus/nest-auth 0.1.50 → 1.1.0

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

@@ -1,43 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoleService = 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 role_entity_1 = require("../entities/role.entity");
-const tenant_1 = require("../../tenant");
-let RoleService = class RoleService {
-    constructor(roleRepository, tenantService) {
-        this.roleRepository = roleRepository;
-        this.tenantService = tenantService;
-    }
-    async createRole(name, guard, tenantId = null, isSystem = false, permissionIds) {
+import { Injectable, NotFoundException, BadRequestException, ConflictException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { FindManyOptions, FindOneOptions, IsNull, Repository } from 'typeorm';
+import { NestAuthRole } from '../entities/role.entity';
+import { TenantService } from '../../tenant';
+
+@Injectable()
+export class RoleService {
+    constructor(
+        @InjectRepository(NestAuthRole)
+        private roleRepository: Repository<NestAuthRole>,
+        private tenantService: TenantService,
+    ) { }
+
+    async createRole(
+        name: string,
+        guard: string,
+        tenantId: string = null,
+        isSystem: boolean = false,
+        permissionIds?: string | string[],
+    ): Promise<NestAuthRole> {
+
         tenantId = await this.tenantService.resolveTenantId(tenantId);
+
+        // Check for existing role with same name in the same guard and tenant
         const existingRole = await this.roleRepository.findOne({
             where: {
                 name,
                 guard,
-                tenantId: tenantId || (0, typeorm_2.IsNull)()
+                tenantId: tenantId || IsNull()
             },
         });
+
         if (existingRole) {
-            throw new common_1.ConflictException({
+            throw new ConflictException({
                 message: `Role with name '${name}' already exists in guard '${guard}'${tenantId ? ` for tenant '${tenantId}'` : ''}`,
                 code: 'ROLE_ALREADY_EXISTS'
             });
         }
-        const role = await role_entity_1.NestAuthRole.createRole(name, guard, isSystem, tenantId);
+
+        const role = await NestAuthRole.createRole(name, guard, isSystem, tenantId);
+
         if (permissionIds) {
             await role.syncPermissions(permissionIds);
         }
+
         await this.roleRepository.save(role);
         return role;
+
     }
-    async getRoleById(id, options) {
+
+    async getRoleById(id: string, options?: FindOneOptions<NestAuthRole>): Promise<NestAuthRole> {
         if (!id) {
             return null;
         }
+
         const role = await this.roleRepository.findOne({
             ...(options ? options : {}),
             where: { id }
@@ -47,7 +63,14 @@ let RoleService = class RoleService {
         }
         return role;
     }
-    async getRoleByName(name, guard, tenantId, options) {
+
+    async getRoleByName(
+        name: string,
+        guard?: string,
+        tenantId?: string,
+        options?: FindOneOptions<NestAuthRole>
+    ): Promise<NestAuthRole> {
+        // First check for system roles with this name
         const systemRole = await this.roleRepository.findOne({
             ...(options ? options : {}),
             where: {
@@ -56,25 +79,30 @@ let RoleService = class RoleService {
                 isSystem: true
             }
         });
+
         if (systemRole) {
             return systemRole;
         }
+
+        // Then check for tenant-specific roles
         const role = await this.roleRepository.findOne({
             ...(options ? options : {}),
             where: {
                 name,
                 ...(guard ? { guard } : {}),
-                ...(tenantId ? { tenantId } : { tenantId: (0, typeorm_2.IsNull)() })
+                ...(tenantId ? { tenantId } : { tenantId: IsNull() })
             }
         });
+
         return role;
     }
-    async getSystemRoles(options) {
+
+    async getSystemRoles(options?: FindManyOptions<NestAuthRole>): Promise<NestAuthRole[]> {
         return this.roleRepository.find({
             ...(options ? options : {}),
             where: {
                 isSystem: true,
-                tenantId: (0, typeorm_2.IsNull)(),
+                tenantId: IsNull(),
                 ...(options?.where ? options.where : {})
             },
             order: {
@@ -82,10 +110,12 @@ let RoleService = class RoleService {
             }
         });
     }
-    async getRoles(options) {
+
+    async getRoles(options?: FindManyOptions<NestAuthRole>): Promise<NestAuthRole[]> {
         return this.roleRepository.find(options);
     }
-    async getSystemRolesByGuard(guard, options) {
+
+    async getSystemRolesByGuard(guard: string, options?: FindManyOptions<NestAuthRole>): Promise<NestAuthRole[]> {
         return this.roleRepository.find({
             ...(options ? options : {}),
             where: {
@@ -98,7 +128,12 @@ let RoleService = class RoleService {
             }
         });
     }
-    async getRolesByGuard(guard, tenantId, options) {
+
+    async getRolesByGuard(
+        guard: string,
+        tenantId?: string,
+        options?: FindManyOptions<NestAuthRole>
+    ): Promise<NestAuthRole[]> {
         if (!guard) {
             return [];
         }
@@ -106,28 +141,36 @@ let RoleService = class RoleService {
             ...(options ? options : {}),
             where: {
                 guard,
-                ...(tenantId ? { tenantId } : { tenantId: (0, typeorm_2.IsNull)() }),
+                ...(tenantId ? { tenantId } : { tenantId: IsNull() }),
                 ...(options?.where ? options.where : {})
             },
         });
     }
-    async getRolesByTenant(tenantId, includeSystemRoles = true, options) {
+
+    async getRolesByTenant(tenantId: string, includeSystemRoles: boolean = true, options?: FindManyOptions<NestAuthRole>): Promise<NestAuthRole[]> {
         tenantId = await this.tenantService.resolveTenantId(tenantId);
         if (!tenantId) {
             return [];
         }
+
         const query = this.roleRepository.createQueryBuilder('role');
+
+        // Add tenant condition
         query.where('role.tenantId = :tenantId', { tenantId });
+
+        // Add system roles condition if needed
         if (includeSystemRoles) {
             query.orWhere('role.tenantId IS NULL AND role.isSystem = :isSystem', { isSystem: true });
         }
+
+        // Apply any additional options
         if (options) {
             if (options.where) {
                 query.andWhere(options.where);
             }
             if (options.order) {
                 Object.entries(options.order).forEach(([key, value]) => {
-                    query.addOrderBy(`role.${key}`, value);
+                    query.addOrderBy(`role.${key}`, value as 'ASC' | 'DESC');
                 });
             }
             if (options.skip) {
@@ -137,88 +180,110 @@ let RoleService = class RoleService {
                 query.take(options.take);
             }
         }
+
         return query.getMany();
     }
-    async updateRole(id, data) {
+
+    async updateRole(id: string, data: Partial<NestAuthRole>): Promise<NestAuthRole> {
         const role = await this.getRoleById(id);
+
         if (!role) {
-            throw new common_1.NotFoundException({
+            throw new NotFoundException({
                 message: `Role with ID ${id} not found`,
                 code: 'ROLE_NOT_FOUND'
             });
         }
+
         if (role.isSystem) {
-            throw new common_1.ConflictException({
+            throw new ConflictException({
                 message: 'Cannot update system role',
                 code: 'SYSTEM_ROLE_UPDATE_ERROR',
             });
         }
+
+        // Prevent changing system status and tenant
         delete data.isSystem;
         delete data.tenantId;
+
+        // If name or guard is being changed, check for conflicts
         if ((data.name && data.name !== role.name) || (data.guard && data.guard !== role.guard)) {
-            const systemRole = await this.getRoleByName(data.name || role.name, data.guard || role.guard);
+            // First check for system role conflicts
+            const systemRole = await this.getRoleByName(
+                data.name || role.name,
+                data.guard || role.guard
+            );
+
             if (systemRole) {
-                throw new common_1.ConflictException({
+                throw new ConflictException({
                     message: `Cannot use name '${data.name || role.name}' as it conflicts with a system role`,
                     code: 'SYSTEM_ROLE_CONFLICT'
                 });
             }
-            const existingRole = await this.getRoleByName(data.name || role.name, data.guard || role.guard, role.tenantId);
+
+            // Then check for tenant role conflicts
+            const existingRole = await this.getRoleByName(
+                data.name || role.name,
+                data.guard || role.guard,
+                role.tenantId
+            );
+
             if (existingRole && existingRole.id !== role.id) {
-                throw new common_1.ConflictException({
+                throw new ConflictException({
                     message: `Role with name '${data.name || role.name}' already exists in guard '${data.guard || role.guard}'${role.tenantId ? ` for tenant '${role.tenantId}'` : ''}`,
                     code: 'ROLE_ALREADY_EXISTS'
                 });
             }
         }
+
         Object.assign(role, data);
         return this.roleRepository.save(role);
     }
-    async updateRolePermissions(id, permissionIds) {
+
+    async updateRolePermissions(id: string, permissionIds: string | string[]): Promise<NestAuthRole> {
         const role = await this.getRoleById(id);
+
         if (!role) {
-            throw new common_1.NotFoundException({
+            throw new NotFoundException({
                 message: `Role with ID ${id} not found`,
                 code: 'ROLE_NOT_FOUND'
             });
         }
+
         if (role.isSystem) {
-            throw new common_1.BadRequestException({
+            throw new BadRequestException({
                 message: 'Cannot update system role',
                 code: 'SYSTEM_ROLE_UPDATE_ERROR',
             });
         }
+
         await role.syncPermissions(permissionIds);
         return this.roleRepository.save(role);
     }
-    async deleteRole(id) {
+
+    async deleteRole(id: string): Promise<void> {
         const role = await this.getRoleById(id);
+
         if (!role) {
-            throw new common_1.NotFoundException({
+            throw new NotFoundException({
                 message: `Role with ID ${id} not found`,
                 code: 'ROLE_NOT_FOUND'
             });
         }
+
         if (role.isSystem) {
-            throw new common_1.BadRequestException({
+            throw new BadRequestException({
                 message: 'Cannot delete system role',
                 code: 'SYSTEM_ROLE_DELETE_ERROR',
             });
         }
+
         await this.roleRepository.remove(role);
     }
-    async deleteSystemRole(id) {
+
+    async deleteSystemRole(id: string): Promise<void> {
         const role = await this.getRoleById(id);
         if (role?.isSystem) {
             await this.roleRepository.remove(role);
         }
     }
-};
-exports.RoleService = RoleService;
-exports.RoleService = RoleService = tslib_1.__decorate([
-    (0, common_1.Injectable)(),
-    tslib_1.__param(0, (0, typeorm_1.InjectRepository)(role_entity_1.NestAuthRole)),
-    tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
-        tenant_1.TenantService])
-], RoleService);
-//# sourceMappingURL=role.service.js.map
+}

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

@@ -0,0 +1,54 @@
+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/index.ts

@@ -0,0 +1,20 @@
+// Entities
+export * from './entities/session.entity';
+
+// Interfaces
+export * from './interfaces/session-repository.interface';
+
+// Repositories
+export * from './repositories/base-session.repository';
+export * from './repositories/typeorm-session.repository';
+export * from './repositories/redis-session.repository';
+export * from './repositories/memory-session.repository';
+
+// Services
+export * from './services/session-manager.service';
+
+// Utils
+export * from './utils/session.util';
+
+// Module
+export * from './session.module';

package/src/lib/session/interfaces/session-repository.interface.ts

@@ -0,0 +1,58 @@
+import { NestAuthSession } from '../entities/session.entity';
+import { SessionPayload } from '../../core/interfaces/token-payload.interface';
+
+/**
+ * Interface for session repository implementations
+ * Allows different storage backends (Database, Redis, Memory)
+ */
+export interface ISessionRepository {
+    /**
+     * Create a new session
+     */
+    create(session: SessionPayload): Promise<NestAuthSession>;
+
+    /**
+     * Find session by ID
+     */
+    findById(sessionId: string): Promise<NestAuthSession | null>;
+
+    /**
+     * Find all sessions for a user
+     */
+    findByUserId(userId: string): Promise<NestAuthSession[]>;
+
+    /**
+     * Find active sessions for a user (not expired)
+     */
+    findActiveByUserId(userId: string): Promise<NestAuthSession[]>;
+
+    /**
+     * Update session
+     */
+    update(sessionId: string, updates: Partial<NestAuthSession>): Promise<NestAuthSession>;
+
+    /**
+     * Delete session by ID
+     */
+    delete(sessionId: string): Promise<void>;
+
+    /**
+     * Delete all sessions for a user
+     */
+    deleteByUserId(userId: string): Promise<void>;
+
+    /**
+     * Delete expired sessions
+     */
+    deleteExpired(): Promise<number>;
+
+    /**
+     * Count active sessions for a user
+     */
+    countActiveByUserId(userId: string): Promise<number>;
+
+    /**
+     * Update last active timestamp
+     */
+    updateLastActive(sessionId: string): Promise<void>;
+}

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

@@ -0,0 +1,74 @@
+import { NestAuthSession } from '../entities/session.entity';
+import { SessionPayload } from '../../core/interfaces/token-payload.interface';
+import { ISessionRepository } from '../interfaces/session-repository.interface';
+import ms from 'ms';
+
+/**
+ * Abstract base class for session repositories
+ * Provides common functionality and helper methods
+ */
+export abstract class BaseSessionRepository implements ISessionRepository {
+
+    // Abstract methods that must be implemented by subclasses
+    abstract create(session: SessionPayload): Promise<NestAuthSession>;
+    abstract findById(sessionId: string): Promise<NestAuthSession | null>;
+    abstract findByUserId(userId: string): Promise<NestAuthSession[]>;
+    abstract findActiveByUserId(userId: string): Promise<NestAuthSession[]>;
+    abstract update(sessionId: string, updates: Partial<NestAuthSession>): Promise<NestAuthSession>;
+    abstract delete(sessionId: string): Promise<void>;
+    abstract deleteByUserId(userId: string): Promise<void>;
+    abstract deleteExpired(): Promise<number>;
+    abstract countActiveByUserId(userId: string): Promise<number>;
+    abstract updateLastActive(sessionId: string): Promise<void>;
+
+    /**
+     * Helper: Check if session is expired
+     */
+    protected isExpired(session: NestAuthSession): boolean {
+        if (!session.expiresAt) return false;
+        return new Date() > new Date(session.expiresAt);
+    }
+
+    /**
+     * Helper: Calculate expiration date from duration string
+     */
+    protected calculateExpiresAt(duration: string | number): Date {
+        const milliseconds = typeof duration === 'string' ? ms(duration) : duration;
+        return new Date(Date.now() + milliseconds);
+    }
+
+    /**
+     * Helper: Serialize session data for storage
+     */
+    protected serializeSession(session: SessionPayload | NestAuthSession): Record<string, any> {
+        return {
+            ...session,
+            data: session.data ? JSON.stringify(session.data) : null,
+            expiresAt: session.expiresAt instanceof Date
+                ? session.expiresAt.toISOString()
+                : session.expiresAt,
+            lastActive: session.lastActive instanceof Date
+                ? session.lastActive.toISOString()
+                : session.lastActive,
+        };
+    }
+
+    /**
+     * Helper: Deserialize session data from storage
+     */
+    protected deserializeSession(data: Record<string, any>): NestAuthSession {
+        return {
+            ...data,
+            data: data['data'] ? JSON.parse(data['data']) : null,
+            expiresAt: data['expiresAt'] ? new Date(data['expiresAt']) : null,
+            lastActive: data['lastActive'] ? new Date(data['lastActive']) : null,
+        } as NestAuthSession;
+    }
+
+    /**
+     * Helper: Filter only active sessions (not expired)
+     */
+    protected filterActive(sessions: NestAuthSession[]): NestAuthSession[] {
+        return sessions.filter(session => !this.isExpired(session));
+    }
+}

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

@@ -0,0 +1,153 @@
+import { Injectable } from '@nestjs/common';
+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';
+
+/**
+ * In-memory implementation of session repository
+ * Useful for testing and development
+ * WARNING: Sessions are lost on server restart!
+ */
+@Injectable()
+export class MemorySessionRepository extends BaseSessionRepository {
+    private sessions: Map<string, NestAuthSession> = new Map();
+    private userSessions: Map<string, Set<string>> = new Map();
+
+    async create(session: SessionPayload): Promise<NestAuthSession> {
+        const sessionId = session.id || uuidv4();
+
+        const sessionData: NestAuthSession = {
+            id: sessionId,
+            userId: session.userId,
+            refreshToken: session.refreshToken,
+            data: session.data,
+            expiresAt: session.expiresAt,
+            userAgent: session.userAgent,
+            deviceName: session.deviceName,
+            ipAddress: session.ipAddress,
+            lastActive: session.lastActive || new Date(),
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        } as NestAuthSession;
+
+        this.sessions.set(sessionId, sessionData);
+
+        // Track user sessions
+        if (!this.userSessions.has(session.userId)) {
+            this.userSessions.set(session.userId, new Set());
+        }
+        this.userSessions.get(session.userId)!.add(sessionId);
+
+        return sessionData;
+    }
+
+    async findById(sessionId: string): Promise<NestAuthSession | null> {
+        const session = this.sessions.get(sessionId);
+        if (!session) return null;
+
+        // Check expiration
+        if (this.isExpired(session)) {
+            await this.delete(sessionId);
+            return null;
+        }
+
+        return session;
+    }
+
+    async findByUserId(userId: string): Promise<NestAuthSession[]> {
+        const sessionIds = this.userSessions.get(userId) || new Set();
+        const sessions: NestAuthSession[] = [];
+
+        for (const sessionId of sessionIds) {
+            const session = await this.findById(sessionId);
+            if (session) {
+                sessions.push(session);
+            }
+        }
+
+        return sessions.sort((a, b) =>
+            (b.createdAt?.getTime() || 0) - (a.createdAt?.getTime() || 0)
+        );
+    }
+
+    async findActiveByUserId(userId: string): Promise<NestAuthSession[]> {
+        const allSessions = await this.findByUserId(userId);
+        return this.filterActive(allSessions);
+    }
+
+    async update(sessionId: string, updates: Partial<NestAuthSession>): Promise<NestAuthSession> {
+        const session = await this.findById(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+
+        const updated = {
+            ...session,
+            ...updates,
+            updatedAt: new Date(),
+        } as NestAuthSession;
+
+        this.sessions.set(sessionId, updated);
+        return updated;
+    }
+
+    async delete(sessionId: string): Promise<void> {
+        const session = this.sessions.get(sessionId);
+        if (!session) return;
+
+        this.sessions.delete(sessionId);
+
+        // Remove from user sessions
+        const userSessionIds = this.userSessions.get(session.userId);
+        if (userSessionIds) {
+            userSessionIds.delete(sessionId);
+            if (userSessionIds.size === 0) {
+                this.userSessions.delete(session.userId);
+            }
+        }
+    }
+
+    async deleteByUserId(userId: string): Promise<void> {
+        const sessionIds = this.userSessions.get(userId) || new Set();
+
+        for (const sessionId of sessionIds) {
+            this.sessions.delete(sessionId);
+        }
+
+        this.userSessions.delete(userId);
+    }
+
+    async deleteExpired(): Promise<number> {
+        let count = 0;
+        const now = new Date();
+
+        for (const [sessionId, session] of this.sessions.entries()) {
+            if (this.isExpired(session)) {
+                await this.delete(sessionId);
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    async countActiveByUserId(userId: string): Promise<number> {
+        const activeSessions = await this.findActiveByUserId(userId);
+        return activeSessions.length;
+    }
+
+    async updateLastActive(sessionId: string): Promise<void> {
+        await this.update(sessionId, {
+            lastActive: new Date(),
+        } as any);
+    }
+
+    /**
+     * Clear all sessions (useful for testing)
+     */
+    clear(): void {
+        this.sessions.clear();
+        this.userSessions.clear();
+    }
+}