Feat: backend dashboard api and dashborad frontend with basic crud of roles, menus, projects and chats with initialize

.tmuxinator/dev.yml

@@ -32,3 +32,9 @@ windows:
         - docker:
             - echo "Docker Services (Ctrl+a 4 to focus)"
             - docker compose up
+  - dashboard:
+      root: <%= ENV["PWD"] %>/dashboard
+      panes:
+        - dashboard:
+            - echo "Dashboard (Ctrl+a 5 to focus, Ctrl+a r to restart)"
+            - pnpm run start

backend/src/app.module.ts

@@ -20,6 +20,8 @@ import { MailModule } from './mail/mail.module';
 import { GitHubModule } from './github/github.module';
 import { AppConfigService } from './config/config.service';
 import { getDatabaseConfig } from './database.config';
+import { DashboardModule } from './dashboard/dashboard.module';
+import { InterceptorModule } from './interceptor/interceptor.module';
 
 @Module({
   imports: [
@@ -56,6 +58,8 @@ import { getDatabaseConfig } from './database.config';
     MailModule,
     TypeOrmModule.forFeature([User]),
     GitHubModule,
+    DashboardModule,
+    InterceptorModule,
   ],
   providers: [
     AppResolver,

backend/src/auth/auth.module.ts

@@ -13,6 +13,10 @@ import { MailModule } from 'src/mail/mail.module';
 import { GoogleStrategy } from './oauth/GoogleStrategy';
 import { GoogleController } from './google.controller';
 import { AppConfigModule } from 'src/config/config.module';
+import { RoleResolver } from './role/role.resolver';
+import { MenuResolver } from './menu/menu.resolver';
+import { RoleService } from './role/role.service';
+import { MenuService } from './menu/menu.service';
 
 @Module({
   imports: [
@@ -29,8 +33,16 @@ import { AppConfigModule } from 'src/config/config.module';
     JwtCacheModule,
     MailModule,
   ],
+  providers: [
+    AuthService,
+    AuthResolver,
+    RoleResolver,
+    MenuResolver,
+    RoleService,
+    MenuService,
+    GoogleStrategy,
+  ],
+  exports: [AuthService, RoleService, MenuService, JwtModule],
   controllers: [GoogleController],
-  providers: [AuthService, AuthResolver, GoogleStrategy],
-  exports: [AuthService, JwtModule],
 })
 export class AuthModule {}

backend/src/auth/menu/dto/create-menu.input.ts

@@ -0,0 +1,25 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsString, IsNotEmpty, IsOptional, IsArray } from 'class-validator';
+
+@InputType()
+export class CreateMenuInput {
+  @Field()
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @Field()
+  @IsString()
+  @IsNotEmpty()
+  path: string;
+
+  @Field()
+  @IsString()
+  @IsNotEmpty()
+  permission: string;
+
+  @Field(() => [String], { nullable: true })
+  @IsArray()
+  @IsOptional()
+  roleIds?: string[];
+}

backend/src/auth/menu/dto/update-menu.input.ts

@@ -0,0 +1,32 @@
+import { Field, ID, InputType } from '@nestjs/graphql';
+import { IsString, IsOptional, IsArray } from 'class-validator';
+
+@InputType()
+export class UpdateMenuInput {
+  @Field(() => ID)
+  id: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  path?: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  permission?: string;
+
+  @Field({ nullable: true })
+  @IsOptional()
+  isActive?: boolean;
+
+  @Field(() => [String], { nullable: true })
+  @IsArray()
+  @IsOptional()
+  roleIds?: string[];
+}

backend/src/auth/menu/menu.model.ts

@@ -1,13 +1,19 @@
 import { ObjectType, Field, ID } from '@nestjs/graphql';
-import { SystemBaseModel } from 'src/system-base-model/system-base.model';
-import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from 'typeorm';
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToMany,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from 'typeorm';
 import { Role } from '../role/role.model';
 
 @Entity()
 @ObjectType()
-export class Menu extends SystemBaseModel {
+export class Menu {
   @Field(() => ID)
-  @PrimaryGeneratedColumn()
+  @PrimaryGeneratedColumn('uuid')
   id: string;
 
   @Field()
@@ -22,6 +28,27 @@ export class Menu extends SystemBaseModel {
   @Column()
   permission: string;
 
+  @Field(() => String, { nullable: true })
+  @Column({ nullable: true })
+  description?: string;
+
+  @Field()
+  @Column({ default: true })
+  isActive: boolean;
+
+  @Field()
+  @Column({ default: false })
+  isDeleted: boolean;
+
+  @Field()
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @Field()
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @Field(() => [Role], { nullable: true })
   @ManyToMany(() => Role, (role) => role.menus)
   roles: Role[];
 }

backend/src/auth/menu/menu.resolver.ts

@@ -0,0 +1,65 @@
+import { Resolver, Query, Mutation, Args, ID } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+import { MenuService } from './menu.service';
+import { Menu } from './menu.model';
+import { CreateMenuInput } from './dto/create-menu.input';
+import { UpdateMenuInput } from './dto/update-menu.input';
+import { RequireAuth } from '../../decorator/auth.decorator';
+import { JWTAuthGuard } from 'src/guard/jwt-auth.guard';
+
+@UseGuards(JWTAuthGuard)
+@Resolver(() => Menu)
+export class MenuResolver {
+  constructor(private readonly menuService: MenuService) {}
+
+  @Query(() => [Menu])
+  @RequireAuth({
+    roles: ['Admin'],
+    menuPath: '/menu/list',
+  })
+  async menus(): Promise<Menu[]> {
+    return this.menuService.findAll();
+  }
+
+  @Query(() => Menu)
+  @RequireAuth({
+    roles: ['Admin'],
+    menuPath: '/menu/detail',
+  })
+  async menu(@Args('id', { type: () => ID }) id: string): Promise<Menu> {
+    return this.menuService.findOne(id);
+  }
+
+  @Mutation(() => Menu)
+  @RequireAuth({
+    roles: ['Admin'],
+    menuPath: '/menu/create',
+  })
+  async createMenu(
+    @Args('createMenuInput') createMenuInput: CreateMenuInput,
+  ): Promise<Menu> {
+    return this.menuService.create(createMenuInput);
+  }
+
+  @Mutation(() => Menu)
+  @RequireAuth({
+    roles: ['Admin'],
+    menuPath: '/menu/update',
+  })
+  async updateMenu(
+    @Args('updateMenuInput') updateMenuInput: UpdateMenuInput,
+  ): Promise<Menu> {
+    return this.menuService.update(updateMenuInput.id, updateMenuInput);
+  }
+
+  @Mutation(() => Boolean)
+  @RequireAuth({
+    roles: ['Admin'],
+    menuPath: '/menu/delete',
+  })
+  async removeMenu(
+    @Args('id', { type: () => ID }) id: string,
+  ): Promise<boolean> {
+    return this.menuService.remove(id);
+  }
+}

backend/src/auth/menu/menu.service.ts

@@ -0,0 +1,69 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Menu } from './menu.model';
+import { CreateMenuInput } from './dto/create-menu.input';
+import { UpdateMenuInput } from './dto/update-menu.input';
+
+@Injectable()
+export class MenuService {
+  constructor(
+    @InjectRepository(Menu)
+    private readonly menuRepository: Repository<Menu>,
+  ) {}
+
+  async create(createMenuInput: CreateMenuInput): Promise<Menu> {
+    const menu = this.menuRepository.create(createMenuInput);
+    return this.menuRepository.save(menu);
+  }
+
+  async findAll(): Promise<Menu[]> {
+    return this.menuRepository.find({
+      relations: ['roles'],
+    });
+  }
+
+  async findOne(id: string): Promise<Menu> {
+    const menu = await this.menuRepository.findOne({
+      where: { id },
+      relations: ['roles'],
+    });
+
+    if (!menu) {
+      throw new NotFoundException(`Menu with ID "${id}" not found`);
+    }
+
+    return menu;
+  }
+
+  async update(id: string, updateMenuInput: UpdateMenuInput): Promise<Menu> {
+    const menu = await this.findOne(id);
+    Object.assign(menu, updateMenuInput);
+    return this.menuRepository.save(menu);
+  }
+
+  async remove(id: string): Promise<boolean> {
+    const result = await this.menuRepository.delete(id);
+    return result.affected > 0;
+  }
+
+  async findByPermission(permission: string): Promise<Menu[]> {
+    return this.menuRepository.find({
+      where: { permission },
+      relations: ['roles'],
+    });
+  }
+
+  async findByPath(path: string): Promise<Menu> {
+    const menu = await this.menuRepository.findOne({
+      where: { path },
+      relations: ['roles'],
+    });
+
+    if (!menu) {
+      throw new NotFoundException(`Menu with path "${path}" not found`);
+    }
+
+    return menu;
+  }
+}

backend/src/auth/role/dto/create-role.input.ts

@@ -0,0 +1,19 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsString, IsArray, IsOptional } from 'class-validator';
+
+@InputType()
+export class CreateRoleInput {
+  @Field()
+  @IsString()
+  name: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @Field(() => [String], { nullable: true })
+  @IsArray()
+  @IsOptional()
+  menuIds?: string[];
+}

backend/src/auth/role/dto/update-role.input.ts

@@ -0,0 +1,27 @@
+import { Field, ID, InputType } from '@nestjs/graphql';
+import { IsString, IsArray, IsOptional } from 'class-validator';
+
+@InputType()
+export class UpdateRoleInput {
+  @Field(() => ID)
+  id: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @Field({ nullable: true })
+  @IsOptional()
+  isActive?: boolean;
+
+  @Field(() => [String], { nullable: true })
+  @IsArray()
+  @IsOptional()
+  menuIds?: string[];
+}