feat: Add seeder module and services for all lookup tables

libs/common/src/seed/seeder.module.ts

@@ -0,0 +1,43 @@
+import { Global, Module } from '@nestjs/common';
+import { SeederService } from './services/seeder.service';
+import { PermissionTypeRepository } from '../modules/permission/repositories';
+import { PermissionTypeSeeder } from './services/permission.type.seeder';
+import { PermissionTypeRepositoryModule } from '../modules/permission/permission.repository.module';
+import { ConfigModule } from '@nestjs/config';
+import { RoleTypeRepositoryModule } from '../modules/role-type/role.type.repository.module';
+import { RoleTypeRepository } from '../modules/role-type/repositories';
+import { RoleTypeSeeder } from './services/role.type.seeder';
+import { SpaceTypeRepository } from '../modules/space-type/repositories';
+import { SpaceTypeSeeder } from './services/space.type.seeder';
+import { SpaceTypeRepositoryModule } from '../modules/space-type/space.type.repository.module';
+import { SuperAdminSeeder } from './services/supper.admin.seeder';
+import { UserRepository } from '../modules/user/repositories';
+import { UserRoleRepository } from '../modules/user-role/repositories';
+import { UserRoleRepositoryModule } from '../modules/user-role/user.role.repository.module';
+import { UserRepositoryModule } from '../modules/user/user.repository.module';
+@Global()
+@Module({
+  providers: [
+    PermissionTypeSeeder,
+    RoleTypeSeeder,
+    SpaceTypeSeeder,
+    SeederService,
+    PermissionTypeRepository,
+    RoleTypeRepository,
+    SpaceTypeRepository,
+    SuperAdminSeeder,
+    UserRepository,
+    UserRoleRepository,
+  ],
+  exports: [SeederService],
+  controllers: [],
+  imports: [
+    ConfigModule.forRoot(),
+    PermissionTypeRepositoryModule,
+    RoleTypeRepositoryModule,
+    UserRepositoryModule,
+    UserRoleRepositoryModule,
+    SpaceTypeRepositoryModule,
+  ],
+})
+export class SeederModule {}

libs/common/src/seed/services/permission.type.seeder.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '@nestjs/common';
+import { PermissionTypeRepository } from '../../modules/permission/repositories';
+import { PermissionType } from '../../constants/permission-type.enum';
+
+@Injectable()
+export class PermissionTypeSeeder {
+  constructor(
+    private readonly permissionTypeRepository: PermissionTypeRepository,
+  ) {}
+
+  async addPermissionTypeDataIfNotFound(): Promise<void> {
+    try {
+      const existingPermissionTypes =
+        await this.permissionTypeRepository.find();
+
+      const permissionTypeNames = existingPermissionTypes.map((pt) => pt.type);
+
+      const missingPermissionTypes = [];
+      if (!permissionTypeNames.includes(PermissionType.CONTROLLABLE)) {
+        missingPermissionTypes.push(PermissionType.CONTROLLABLE);
+      }
+      if (!permissionTypeNames.includes(PermissionType.READ)) {
+        missingPermissionTypes.push(PermissionType.READ);
+      }
+
+      if (missingPermissionTypes.length > 0) {
+        await this.addPermissionTypeData(missingPermissionTypes);
+      }
+    } catch (err) {
+      console.error('Error while checking permission type data:', err);
+      throw err;
+    }
+  }
+
+  private async addPermissionTypeData(
+    permissionTypes: string[],
+  ): Promise<void> {
+    try {
+      const permissionTypeEntities = permissionTypes.map((type) => ({
+        type,
+      }));
+
+      await this.permissionTypeRepository.save(permissionTypeEntities);
+    } catch (err) {
+      console.error('Error while adding permission type data:', err);
+      throw err;
+    }
+  }
+}

libs/common/src/seed/services/role.type.seeder.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@nestjs/common';
+import { RoleType } from '../../constants/role.type.enum';
+import { RoleTypeRepository } from '../../modules/role-type/repositories';
+
+@Injectable()
+export class RoleTypeSeeder {
+  constructor(private readonly roleTypeRepository: RoleTypeRepository) {}
+
+  async addRoleTypeDataIfNotFound(): Promise<void> {
+    try {
+      const existingRoleTypes = await this.roleTypeRepository.find();
+
+      const roleTypeNames = existingRoleTypes.map((pt) => pt.type);
+
+      const missingRoleTypes = [];
+      if (!roleTypeNames.includes(RoleType.SUPER_ADMIN)) {
+        missingRoleTypes.push(RoleType.SUPER_ADMIN);
+      }
+      if (!roleTypeNames.includes(RoleType.ADMIN)) {
+        missingRoleTypes.push(RoleType.ADMIN);
+      }
+      if (!roleTypeNames.includes(RoleType.USER)) {
+        missingRoleTypes.push(RoleType.USER);
+      }
+      if (missingRoleTypes.length > 0) {
+        await this.addRoleTypeData(missingRoleTypes);
+      }
+    } catch (err) {
+      console.error('Error while checking role type data:', err);
+      throw err;
+    }
+  }
+
+  private async addRoleTypeData(roleTypes: string[]): Promise<void> {
+    try {
+      const roleTypeEntities = roleTypes.map((type) => ({
+        type,
+      }));
+
+      await this.roleTypeRepository.save(roleTypeEntities);
+    } catch (err) {
+      console.error('Error while adding role type data:', err);
+      throw err;
+    }
+  }
+}

libs/common/src/seed/services/seeder.service.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { PermissionTypeSeeder } from './permission.type.seeder';
+import { RoleTypeSeeder } from './role.type.seeder';
+import { SpaceTypeSeeder } from './space.type.seeder';
+import { SuperAdminSeeder } from './supper.admin.seeder';
+@Injectable()
+export class SeederService {
+  constructor(
+    private readonly permissionTypeSeeder: PermissionTypeSeeder,
+    private readonly roleTypeSeeder: RoleTypeSeeder,
+    private readonly spaceTypeSeeder: SpaceTypeSeeder,
+    private readonly superAdminSeeder: SuperAdminSeeder,
+  ) {}
+
+  async seed() {
+    await this.permissionTypeSeeder.addPermissionTypeDataIfNotFound();
+    await this.roleTypeSeeder.addRoleTypeDataIfNotFound();
+    await this.spaceTypeSeeder.addSpaceTypeDataIfNotFound();
+    await this.superAdminSeeder.createSuperAdminIfNotFound();
+  }
+}

libs/common/src/seed/services/space.type.seeder.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@nestjs/common';
+import { SpaceType } from '../../constants/space-type.enum';
+import { SpaceTypeRepository } from '../../modules/space-type/repositories';
+
+@Injectable()
+export class SpaceTypeSeeder {
+  constructor(private readonly spaceTypeRepository: SpaceTypeRepository) {}
+
+  async addSpaceTypeDataIfNotFound(): Promise<void> {
+    try {
+      const existingSpaceTypes = await this.spaceTypeRepository.find();
+
+      const spaceTypeNames = existingSpaceTypes.map((pt) => pt.type);
+
+      const missingSpaceTypes = [];
+      if (!spaceTypeNames.includes(SpaceType.COMMUNITY)) {
+        missingSpaceTypes.push(SpaceType.COMMUNITY);
+      }
+      if (!spaceTypeNames.includes(SpaceType.BUILDING)) {
+        missingSpaceTypes.push(SpaceType.BUILDING);
+      }
+      if (!spaceTypeNames.includes(SpaceType.FLOOR)) {
+        missingSpaceTypes.push(SpaceType.FLOOR);
+      }
+      if (!spaceTypeNames.includes(SpaceType.UNIT)) {
+        missingSpaceTypes.push(SpaceType.UNIT);
+      }
+      if (!spaceTypeNames.includes(SpaceType.ROOM)) {
+        missingSpaceTypes.push(SpaceType.ROOM);
+      }
+      if (missingSpaceTypes.length > 0) {
+        await this.addSpaceTypeData(missingSpaceTypes);
+      }
+    } catch (err) {
+      console.error('Error while checking space type data:', err);
+      throw err;
+    }
+  }
+
+  private async addSpaceTypeData(spaceTypes: string[]): Promise<void> {
+    try {
+      const spaceTypeEntities = spaceTypes.map((type) => ({
+        type,
+      }));
+
+      await this.spaceTypeRepository.save(spaceTypeEntities);
+    } catch (err) {
+      console.error('Error while adding space type data:', err);
+      throw err;
+    }
+  }
+}

libs/common/src/seed/services/supper.admin.seeder.ts

@@ -0,0 +1,72 @@
+import { Injectable } from '@nestjs/common';
+import { UserRepository } from '@app/common/modules/user/repositories';
+import { RoleType } from '@app/common/constants/role.type.enum';
+import { UserRoleRepository } from '@app/common/modules/user-role/repositories';
+import { RoleTypeRepository } from '@app/common/modules/role-type/repositories';
+import { ConfigService } from '@nestjs/config';
+import { HelperHashService } from '../../helper/services';
+
+@Injectable()
+export class SuperAdminSeeder {
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly userRepository: UserRepository,
+    private readonly userRoleRepository: UserRoleRepository,
+    private readonly roleTypeRepository: RoleTypeRepository,
+    private readonly helperHashService: HelperHashService,
+  ) {}
+
+  async createSuperAdminIfNotFound(): Promise<void> {
+    try {
+      const superAdminData = await this.userRoleRepository.find({
+        where: { roleType: { type: RoleType.SUPER_ADMIN } },
+        relations: ['roleType'],
+      });
+
+      if (superAdminData.length <= 0) {
+        // Create the super admin user if not found
+        console.log('Creating super admin user...');
+
+        await this.createSuperAdmin();
+      }
+    } catch (err) {
+      console.error('Error while checking super admin:', err);
+      throw err;
+    }
+  }
+  private async getRoleUuidByRoleType(roleType: string) {
+    const role = await this.roleTypeRepository.findOne({
+      where: { type: roleType },
+    });
+
+    return role.uuid;
+  }
+  private async createSuperAdmin(): Promise<void> {
+    const salt = this.helperHashService.randomSalt(10); // Hash the password using bcrypt
+    const hashedPassword = await this.helperHashService.bcrypt(
+      this.configService.get<string>('super-admin.SUPER_ADMIN_PASSWORD'),
+      salt,
+    );
+    try {
+      const user = await this.userRepository.save({
+        email: this.configService.get<string>('super-admin.SUPER_ADMIN_EMAIL'),
+        password: hashedPassword,
+        firstName: 'Super',
+        lastName: 'Admin',
+        isUserVerified: true,
+        isActive: true,
+      });
+      const defaultUserRoleUuid = await this.getRoleUuidByRoleType(
+        RoleType.SUPER_ADMIN,
+      );
+
+      await this.userRoleRepository.save({
+        user: { uuid: user.uuid },
+        roleType: { uuid: defaultUserRoleUuid },
+      });
+    } catch (err) {
+      console.error('Error while creating super admin:', err);
+      throw err;
+    }
+  }
+}