@ackplus/nest-auth 0.1.51 → 1.1.0

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

@@ -0,0 +1,56 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    CreateDateColumn,
+    UpdateDateColumn,
+    BaseEntity,
+    Index,
+    Unique,
+} from 'typeorm';
+import { DEFAULT_GUARD_NAME } from '../../auth.constants';
+
+/**
+ * Permission Registry Entity
+ *
+ * This table acts as a registry/suggestions list for permissions.
+ * Roles store permission names as JSON strings (not foreign keys),
+ * so deleting a permission from this table won't break existing roles.
+ *
+ * Purpose:
+ * - Provides autocomplete/suggestions when adding permissions to roles
+ * - Prevents typos and ensures consistency
+ * - Allows tracking permission descriptions and metadata
+ * - Can be used for permission documentation/management
+ *
+ * Note: Permissions are unique per (name, guard) combination
+ */
+@Entity('nest_auth_permissions')
+@Unique(['name', 'guard'])
+export class NestAuthPermission extends BaseEntity {
+    @PrimaryGeneratedColumn('uuid')
+    id: string;
+
+    @Column()
+    @Index()
+    name: string;
+
+    @Column({ nullable: true, default: DEFAULT_GUARD_NAME })
+    @Index()
+    guard: string;
+
+    @Column({ nullable: true, type: 'text' })
+    description?: string;
+
+    @Column({ nullable: true })
+    category?: string; // e.g., 'users', 'posts', 'admin', etc.
+
+    @Column({ type: 'simple-json', nullable: true, default: '{}' })
+    metadata?: Record<string, any>;
+
+    @CreateDateColumn()
+    createdAt: Date;
+
+    @UpdateDateColumn()
+    updatedAt: Date;
+}

package/src/lib/permission/index.ts

@@ -0,0 +1,4 @@
+export * from './entities/permission.entity';
+export * from './services/permission.service';
+export * from './permission.module';
+

package/src/lib/permission/permission.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { NestAuthPermission } from './entities/permission.entity';
+import { PermissionService } from './services/permission.service';
+
+@Module({
+    imports: [
+        TypeOrmModule.forFeature([NestAuthPermission]),
+    ],
+    providers: [PermissionService],
+    exports: [PermissionService, TypeOrmModule],
+})
+export class PermissionModule { }
+

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

@@ -0,0 +1,233 @@
+import { Injectable, ConflictException, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, Like } from 'typeorm';
+import { NestAuthPermission } from '../entities/permission.entity';
+import { DEFAULT_GUARD_NAME } from '../../auth.constants';
+
+@Injectable()
+export class PermissionService {
+    constructor(
+        @InjectRepository(NestAuthPermission)
+        private permissionRepository: Repository<NestAuthPermission>,
+    ) { }
+
+    async createPermission(data: {
+        name: string;
+        guard?: string;
+        description?: string;
+        category?: string;
+        metadata?: Record<string, any>;
+    }): Promise<NestAuthPermission> {
+        const guard = data.guard || DEFAULT_GUARD_NAME;
+        const existing = await this.permissionRepository.findOne({
+            where: { name: data.name.trim(), guard },
+        });
+
+        if (existing) {
+            throw new ConflictException(`Permission '${data.name}' with guard '${guard}' already exists`);
+        }
+
+        const permission = this.permissionRepository.create({
+            name: data.name.trim(),
+            guard,
+            description: data.description?.trim(),
+            category: data.category?.trim(),
+            metadata: data.metadata || {},
+        });
+
+        return this.permissionRepository.save(permission);
+    }
+
+    async getPermissions(options?: {
+        search?: string;
+        category?: string;
+        guard?: string;
+        limit?: number;
+    }): Promise<NestAuthPermission[]> {
+        const query = this.permissionRepository.createQueryBuilder('permission');
+
+        if (options?.search) {
+            query.where(
+                '(permission.name LIKE :search OR permission.description LIKE :search)',
+                { search: `%${options.search}%` }
+            );
+        }
+
+        if (options?.category) {
+            query.andWhere('permission.category = :category', { category: options.category });
+        }
+
+        if (options?.guard) {
+            query.andWhere('permission.guard = :guard', { guard: options.guard });
+        }
+
+        query.orderBy('permission.name', 'ASC');
+
+        if (options?.limit) {
+            query.limit(options.limit);
+        }
+
+        return query.getMany();
+    }
+
+    async getPermissionByName(name: string, guard?: string): Promise<NestAuthPermission | null> {
+        return this.permissionRepository.findOne({
+            where: { name, guard: guard || DEFAULT_GUARD_NAME },
+        });
+    }
+
+    async getPermissionsByGuard(guard: string): Promise<NestAuthPermission[]> {
+        return this.permissionRepository.find({
+            where: { guard },
+            order: { name: 'ASC' },
+        });
+    }
+
+    async getGuards(): Promise<string[]> {
+        const result = await this.permissionRepository
+            .createQueryBuilder('permission')
+            .select('DISTINCT permission.guard', 'guard')
+            .getRawMany();
+
+        return result.map(r => r.guard).filter(Boolean).sort();
+    }
+
+    async getPermissionById(id: string): Promise<NestAuthPermission> {
+        const permission = await this.permissionRepository.findOne({
+            where: { id },
+        });
+
+        if (!permission) {
+            throw new NotFoundException(`Permission with id ${id} not found`);
+        }
+
+        return permission;
+    }
+
+    async updatePermission(
+        id: string,
+        data: {
+            name?: string;
+            guard?: string;
+            description?: string;
+            category?: string;
+            metadata?: Record<string, any>;
+        }
+    ): Promise<NestAuthPermission> {
+        const permission = await this.getPermissionById(id);
+        const guard = data.guard || permission.guard;
+
+        if (data.name && data.name !== permission.name) {
+            // Check if new name already exists for this guard
+            const existing = await this.permissionRepository.findOne({
+                where: { name: data.name.trim(), guard },
+            });
+            if (existing) {
+                throw new ConflictException(`Permission '${data.name}' with guard '${guard}' already exists`);
+            }
+            permission.name = data.name.trim();
+        }
+
+        if (data.guard && data.guard !== permission.guard) {
+            // Check if permission with new guard already exists
+            const existing = await this.permissionRepository.findOne({
+                where: { name: permission.name, guard: data.guard },
+            });
+            if (existing) {
+                throw new ConflictException(`Permission '${permission.name}' with guard '${data.guard}' already exists`);
+            }
+            permission.guard = data.guard;
+        }
+
+        if (data.description !== undefined) {
+            permission.description = data.description?.trim() || null;
+        }
+
+        if (data.category !== undefined) {
+            permission.category = data.category?.trim() || null;
+        }
+
+        if (data.metadata !== undefined) {
+            permission.metadata = data.metadata || {};
+        }
+
+        return this.permissionRepository.save(permission);
+    }
+
+    async deletePermission(id: string): Promise<void> {
+        const permission = await this.getPermissionById(id);
+        await this.permissionRepository.remove(permission);
+    }
+
+    async getPermissionsByNames(names: string[]): Promise<NestAuthPermission[]> {
+        if (names.length === 0) {
+            return [];
+        }
+        return this.permissionRepository.find({
+            where: names.map(name => ({ name })),
+        });
+    }
+
+    async searchPermissions(query: string, guard?: string, limit: number = 20): Promise<NestAuthPermission[]> {
+        const whereConditions: any[] = [
+            { name: Like(`%${query}%`) },
+            { description: Like(`%${query}%`) },
+        ];
+
+        if (guard) {
+            // Apply guard filter to all conditions
+            whereConditions.forEach(condition => {
+                condition.guard = guard;
+            });
+        }
+
+        return this.permissionRepository.find({
+            where: whereConditions,
+            take: limit,
+            order: { name: 'ASC' },
+        });
+    }
+
+    async getCategories(): Promise<string[]> {
+        const result = await this.permissionRepository
+            .createQueryBuilder('permission')
+            .select('DISTINCT permission.category', 'category')
+            .where('permission.category IS NOT NULL')
+            .getRawMany();
+
+        return result.map(r => r.category).filter(Boolean).sort();
+    }
+
+    /**
+     * Batch create permissions - useful for seeding
+     */
+    async createPermissions(permissions: Array<{
+        name: string;
+        description?: string;
+        category?: string;
+        metadata?: Record<string, any>;
+    }>): Promise<NestAuthPermission[]> {
+        const existing = await this.permissionRepository.find({
+            where: permissions.map(p => ({ name: p.name })),
+        });
+
+        const existingNames = new Set(existing.map(p => p.name));
+        const toCreate = permissions.filter(p => !existingNames.has(p.name));
+
+        if (toCreate.length === 0) {
+            return existing;
+        }
+
+        const newPermissions = this.permissionRepository.create(
+            toCreate.map(p => ({
+                name: p.name.trim(),
+                description: p.description?.trim(),
+                category: p.category?.trim(),
+                metadata: p.metadata || {},
+            }))
+        );
+
+        const saved = await this.permissionRepository.save(newPermissions);
+        return [...existing, ...saved];
+    }
+}

package/src/lib/request-context/index.ts

@@ -0,0 +1,2 @@
+export * from './request-context';
+export * from './request-context.middleware';

package/src/lib/request-context/request-context.middleware.ts

@@ -0,0 +1,13 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+
+import { RequestContext } from './request-context';
+
+
+@Injectable()
+export class RequestContextMiddleware implements NestMiddleware {
+
+    use(req, res, next) {
+        RequestContext.create(req, res, next);
+    }
+
+}

package/src/lib/request-context/{request-context.js → request-context.ts}

@@ -1,25 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestContext = void 0;
-const async_hooks_1 = require("async_hooks");
-class RequestContext {
-    constructor(request, response) {
+import { AsyncLocalStorage } from 'async_hooks';
+import { Request, Response } from 'express';
+import { JWTTokenPayload, SessionPayload } from '../core/interfaces/token-payload.interface';
+
+export class RequestContext {
+
+    private static storage = new AsyncLocalStorage<RequestContext>();
+
+    readonly id: number;
+
+    request: Request;
+
+    response: Response;
+
+    private constructor(request: Request, response: Response) {
         this.id = Math.random();
         this.request = request;
         this.response = response;
     }
-    static create(request, response, next) {
+
+    public static create(
+        request: Request,
+        response: Response,
+        next: () => void,
+    ) {
         const context = new RequestContext(request, response);
         RequestContext.storage.run(context, () => next());
     }
-    static current() {
+
+    public static current(): RequestContext | undefined {
         return RequestContext.storage.getStore();
     }
-    static currentRequest() {
+
+    public static currentRequest(): Request | null {
         const requestContext = RequestContext.current();
         return requestContext ? requestContext.request : null;
     }
-    static currentUser() {
+
+    public static currentUser(): JWTTokenPayload | null {
         const request = RequestContext.currentRequest();
         if (!request['user']) {
             return null;
@@ -27,20 +44,23 @@ class RequestContext {
         return {
             id: request['user'].sub,
             ...request['user']
-        };
+        } as JWTTokenPayload;
     }
-    static currentSession() {
+
+    public static currentSession(): SessionPayload | null {
         const request = RequestContext.currentRequest();
         return request ? request['session'] : null;
     }
-    static getDeviceInfo() {
+
+    public static getDeviceInfo(): { deviceName: string; ipAddress: string; browser: string } {
         return {
             deviceName: this.getDeviceName(),
             ipAddress: this.getIpAddress(),
             browser: this.getBrowser(),
         };
     }
-    static getDeviceName() {
+
+    private static getDeviceName(): string {
         const request = this.currentRequest();
         if (!request) {
             return 'Unknown Device';
@@ -48,51 +68,58 @@ class RequestContext {
         const userAgent = request.headers['user-agent'] || 'unknown';
         if (userAgent.includes('Windows')) {
             return 'Windows';
-        }
-        else if (userAgent.includes('Macintosh')) {
+        } else if (userAgent.includes('Macintosh')) {
             return 'Mac';
-        }
-        else if (userAgent.includes('Linux')) {
+        } else if (userAgent.includes('Linux')) {
             return 'Linux';
-        }
-        else if (userAgent.includes('Android')) {
+        } else if (userAgent.includes('Android')) {
             return 'Android';
-        }
-        else if (userAgent.includes('iPhone') || userAgent.includes('iPad')) {
+        } else if (userAgent.includes('iPhone') || userAgent.includes('iPad')) {
             return 'iOS';
         }
         return 'Unknown Device';
     }
-    static getBrowser() {
+
+    private static getBrowser(): string {
         const request = this.currentRequest();
         if (!request) {
             return 'unknown';
         }
         const userAgent = request.headers['user-agent'] || 'unknown';
+
+        // Chrome
         if (userAgent.includes('Chrome') && !userAgent.includes('Chromium')) {
             return 'Chrome';
         }
+        // Firefox
         if (userAgent.includes('Firefox')) {
             return 'Firefox';
         }
+        // Safari
         if (userAgent.includes('Safari') && !userAgent.includes('Chrome')) {
             return 'Safari';
         }
+        // Edge
         if (userAgent.includes('Edg')) {
             return 'Edge';
         }
+        // Opera
         if (userAgent.includes('Opera') || userAgent.includes('OPR')) {
             return 'Opera';
         }
+        // Internet Explorer
         if (userAgent.includes('MSIE') || userAgent.includes('Trident/')) {
             return 'Internet Explorer';
         }
+        // Brave
         if (userAgent.includes('Brave')) {
             return 'Brave';
         }
+
         return 'Unknown Browser';
     }
-    static getIpAddress() {
+
+    private static getIpAddress(): string {
         const request = this.currentRequest();
         if (request) {
             return request.ip ||
@@ -103,6 +130,3 @@ class RequestContext {
         return 'unknown';
     }
 }
-exports.RequestContext = RequestContext;
-RequestContext.storage = new async_hooks_1.AsyncLocalStorage();
-//# sourceMappingURL=request-context.js.map

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

@@ -0,0 +1,103 @@
+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/{index.d.ts → index.ts}

@@ -1 +1,3 @@
+
+// Services
 export * from './services/role.service';

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

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