feat: Add seeder module and services for all lookup tables

libs/common/src/constants/space-type.enum.ts

@@ -0,0 +1,7 @@
+export enum SpaceType {
+  COMMUNITY = 'community',
+  BUILDING = 'building',
+  FLOOR = 'floor',
+  UNIT = 'unit',
+  ROOM = 'room',
+}

libs/common/src/helper/helper.module.ts

@@ -1,30 +1,11 @@
 import { Global, Module } from '@nestjs/common';
 import { HelperHashService } from './services';
-import { UserRepository } from '../modules/user/repositories';
-import { UserRepositoryModule } from '../modules/user/user.repository.module';
-import { UserRoleRepository } from '../modules/user-role/repositories';
-import { UserRoleRepositoryModule } from '../modules/user-role/user.role.repository.module';
-import { RoleTypeRepository } from '../modules/role-type/repositories';
-import { RoleTypeRepositoryModule } from '../modules/role-type/role.type.repository.module';
-import { ConfigModule } from '@nestjs/config';
-import { SuperAdminService } from './services/super.admin.sarvice';
 
 @Global()
 @Module({
-  providers: [
-    HelperHashService,
-    SuperAdminService,
-    UserRepository,
-    UserRoleRepository,
-    RoleTypeRepository,
-  ],
-  exports: [HelperHashService, SuperAdminService],
+  providers: [HelperHashService],
+  exports: [HelperHashService],
   controllers: [],
-  imports: [
-    ConfigModule.forRoot(),
-    UserRepositoryModule,
-    UserRoleRepositoryModule,
-    RoleTypeRepositoryModule,
-  ],
+  imports: [],
 })
 export class HelperModule {}

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

@@ -1,13 +1,13 @@
-import { HelperHashService } from './helper.hash.service';
 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 SuperAdminService {
+export class SuperAdminSeeder {
   constructor(
     private readonly configService: ConfigService,
     private readonly userRepository: UserRepository,

src/app.module.ts

@@ -13,6 +13,7 @@ import { BuildingModule } from './building/building.module';
 import { FloorModule } from './floor/floor.module';
 import { UnitModule } from './unit/unit.module';
 import { RoleModule } from './role/role.module';
+import { SeederModule } from '@app/common/seed/seeder.module';
 @Module({
   imports: [
     ConfigModule.forRoot({
@@ -30,6 +31,7 @@ import { RoleModule } from './role/role.module';
     GroupModule,
     DeviceModule,
     UserDevicePermissionModule,
+    SeederModule,
   ],
   controllers: [AuthenticationController],
 })

src/main.ts

@@ -4,7 +4,7 @@ import rateLimit from 'express-rate-limit';
 import helmet from 'helmet';
 import { setupSwaggerAuthentication } from '../libs/common/src/util/user-auth.swagger.utils';
 import { ValidationPipe } from '@nestjs/common';
-import { SuperAdminService } from '@app/common/helper/services/super.admin.sarvice';
+import { SeederService } from '@app/common/seed/services/seeder.service';
 
 async function bootstrap() {
   const app = await NestFactory.create(AuthModule);
@@ -34,10 +34,14 @@ async function bootstrap() {
       },
     }),
   );
-  // Create super admin user
-  const superAdminService = app.get(SuperAdminService);
-  await superAdminService.createSuperAdminIfNotFound();
 
+  const seederService = app.get(SeederService);
+  try {
+    await seederService.seed();
+    console.log('Seeding complete!');
+  } catch (error) {
+    console.error('Seeding failed!', error);
+  }
   await app.listen(process.env.PORT || 4000);
 }
 console.log('Starting auth at port ...', process.env.PORT || 4000);