@solidstarters/solid-core 1.2.191 → 1.2.193

package/src/services/list-of-values.service.ts

@@ -1,20 +1,29 @@
 import { Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, Repository } from 'typeorm';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
 
+import { ConfigService } from '@nestjs/config';
+import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
+import { FileService } from 'src/services/file.service';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from 'src/services/file.service';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 
 
+import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
+import { ListOfValuesRepository } from 'src/repository/list-of-values.repository';
 import { ListOfValues } from '../entities/list-of-values.entity';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
+import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
+import { ListOfValuesMapper } from 'src/mappers/list-of-values-mapper';
+
 
 @Injectable()
 export class ListOfValuesService extends CRUDService<ListOfValues> {
+  logger: any;
+  // moduleMetadataHelperService: any;
+  // listOfValuesMapper: any;
   constructor(
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
@@ -22,11 +31,15 @@ export class ListOfValuesService extends CRUDService<ListOfValues> {
     readonly fileService: FileService,
     readonly discoveryService: DiscoveryService,
     readonly crudHelperService: CrudHelperService,
+    
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ListOfValues, 'default')
-    readonly repo: Repository<ListOfValues>,
-    readonly moduleRef: ModuleRef
+    // @InjectRepository(ListOfValues, 'default')
+    // readonly repo: Repository<ListOfValues>,
+    readonly repo: ListOfValuesRepository,
+    readonly moduleRef: ModuleRef,
+    private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+    readonly listOfValuesMapper: ListOfValuesMapper,
 
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'listOfValues', 'solid-core', moduleRef);
@@ -64,4 +77,175 @@ export class ListOfValuesService extends CRUDService<ListOfValues> {
     }
   }
 
+
+  async saveListofValuesToConfig(entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // Write the listofvalue to the config file
+    await this.writeToConfig(metaData, listofvalue, filePath);
+  }
+
+  async updateListofValuesToConfig(oldentity: ListOfValues, entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const oldlistofvalue = oldentity as ListOfValues;
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // Write the listofvalue to the config file
+    await this.updateToConfig(metaData, oldlistofvalue, listofvalue, filePath);
+  }
+
+  async deleteListOfValuesFromConfig(entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // delete the listofvalue to the config file
+    await this.deleteFromConfig(metaData, listofvalue, filePath);
+  }
+
+  private async getConfigFileDetails(moduleName: string): Promise<{ filePath: string; metaData: any }> {
+    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+    try {
+      await fs.access(filePath);
+    } catch (error) {
+      throw new Error(`Configuration file not found for module: ${moduleName}`);
+    }
+    const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
+    return { filePath, metaData };
+  }
+
+  private async writeToConfig(metaData: any, listofvalues: ListOfValues, filePath: string) {
+    const dto = await this.listOfValuesMapper.toDto(listofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    // Match by type + value + module
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === dto.type &&
+        item.value === dto.value &&
+        item.module === dto.module
+    );
+
+    if (existingIndex !== -1) {
+      // Replace existing entry
+      metaData.listOfValues[existingIndex] = dto;
+    } else {
+      // Insert new entry
+      // metaData.listOfValues.unshift(dto);
+
+      if (metaData.listOfValues.length === 0) {
+        // Case 1: Empty array → add first item
+        metaData.listOfValues.push(dto);
+      } else {
+        // Case 2: Insert new item right after index 0
+        metaData.listOfValues.unshift(dto);
+      }
+
+    }
+
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+  }
+
+  private async updateToConfig(metaData: any, oldlistofvalues: ListOfValues, listofvalues: ListOfValues, filePath: string) {
+    const newvalue = await this.listOfValuesMapper.toDto(listofvalues);
+    const oldvalue = await this.listOfValuesMapper.toDto(oldlistofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    const searchType = oldvalue.type || newvalue.type;
+    const searchValue = oldvalue.value || newvalue.value;
+    const searchModule = oldvalue.module || newvalue.module;
+
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === searchType && item.value === searchValue && item.module === searchModule
+    );
+    if (existingIndex !== -1) {
+      // Replace existing match
+      metaData.listOfValues[existingIndex] = newvalue;
+    }
+
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+  }
+
+  private async deleteFromConfig(metaData: any, listofvalues: ListOfValues, filePath: string) {
+    const dto = await this.listOfValuesMapper.toDto(listofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    // Match by type + value + module
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === dto.type &&
+        item.value === dto.value &&
+        item.module === dto.module
+    );
+
+    if (existingIndex !== -1) {
+      // Remove the item
+      metaData.listOfValues.splice(existingIndex, 1);
+      this.logger.debug(`Deleted LOV ${dto.type}:${dto.value} (module ${dto.module}) from config`);
+    } else {
+      this.logger.warn(
+        `LOV ${dto.type}:${dto.value} (module ${dto.module}) not found in config during delete`
+      );
+    }
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+
+  }
 }

package/src/services/locale.service.ts

@@ -1,18 +1,18 @@
 import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { DiscoveryService, ModuleRef  } from "@nestjs/core";
-import { EntityManager, Repository } from 'typeorm';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
 
+import { ConfigService } from '@nestjs/config';
+import { Locale } from 'src/entities/locale.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { LocaleRepository } from 'src/repository/locale.repository';
+import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
+import { FileService } from 'src/services/file.service';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from 'src/services/file.service';
-import { CrudHelperService } from 'src/services/crud-helper.service';
-import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { RequestContextService } from './request-context.service';
-import { Locale } from 'src/entities/locale.entity';
-import { SolidRegistry } from 'src/helpers/solid-registry';
 @Injectable()
 export class LocaleService extends CRUDService<Locale> implements OnApplicationBootstrap{
   constructor(
@@ -24,12 +24,14 @@ export class LocaleService extends CRUDService<Locale> implements OnApplicationB
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(Locale, 'default')
-    readonly repo: Repository<Locale>,
-    @InjectRepository(Locale, 'default')
+    // @InjectRepository(Locale, 'default')
+    // readonly repo: Repository<Locale>,
+    readonly repo: LocaleRepository,
+    // @InjectRepository(Locale, 'default')
     readonly moduleRef: ModuleRef,
-    @InjectRepository(ModelMetadata)
-    private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    // @InjectRepository(ModelMetadata)
+    // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    // private readonly modelMetadataRepo: ModelMetadataRepository,
     readonly requestContextService: RequestContextService,
     readonly solidRegistry: SolidRegistry,
  ) {

package/src/services/mail/smtp-email.service.ts

@@ -114,7 +114,13 @@ export class SMTPEMailService implements IMail {
     }
 
     async sendEmailSynchronously(message: QueueMessage<any>) {
-        const { from, to, subject, body, attachments = [], cc, bcc } = message.payload;
+        let from;
+        const { to, subject, body, attachments = [], cc, bcc } = message.payload;
+
+        const envFrom = this.commonConfiguration.smtpMail.from;
+        if (envFrom) {
+            from = envFrom;
+        }
 
         // if any of the required fields are missing, throw an error.
         if (!from || !to || !subject || !body) {

package/src/services/media-storage-provider-metadata.service.ts

@@ -1,17 +1,18 @@
 import { Injectable, NotFoundException } from "@nestjs/common";
-import { InjectRepository } from "@nestjs/typeorm";
-import { Repository, SelectQueryBuilder } from "typeorm";
-import { MediaStorageProviderMetadata } from "../entities/media-storage-provider-metadata.entity";
+import { ERROR_MESSAGES } from "src/constants/error-messages";
+import { MediaStorageProviderMetadataRepository } from "src/repository/media-storage-provider-metadata.repository";
+import { SelectQueryBuilder } from "typeorm";
 import { BasicFilterDto } from "../dtos/basic-filters.dto";
-import { CrudHelperService } from "./crud-helper.service";
 import { UpdateMediaStorageProviderMetadataDto } from "../dtos/update-media-storage-provider.dto";
-import { ERROR_MESSAGES } from "src/constants/error-messages";
+import { MediaStorageProviderMetadata } from "../entities/media-storage-provider-metadata.entity";
+import { CrudHelperService } from "./crud-helper.service";
 
 @Injectable()
 export class MediaStorageProviderMetadataService {
     constructor(
-        @InjectRepository(MediaStorageProviderMetadata)
-        private readonly mediaStorageProviderRepo: Repository<MediaStorageProviderMetadata>,
+        // @InjectRepository(MediaStorageProviderMetadata)
+        // private readonly mediaStorageProviderRepo: Repository<MediaStorageProviderMetadata>,
+        private readonly mediaStorageProviderRepo: MediaStorageProviderMetadataRepository,
         private readonly crudHelperService: CrudHelperService
     ) { }
 
@@ -21,8 +22,8 @@ export class MediaStorageProviderMetadataService {
         let { limit, offset, populateMedia } = basicFilterDto;
 
         // Create above query on pincode table using query builder
-        var qb: SelectQueryBuilder<MediaStorageProviderMetadata> = this.mediaStorageProviderRepo.createQueryBuilder(alias)
-        qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+        var qb: SelectQueryBuilder<MediaStorageProviderMetadata> = await this.mediaStorageProviderRepo.createSecurityRuleAwareQueryBuilder(alias)
+        qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
 
         // Get the records and the count
         const [entities, count] = await qb.getManyAndCount();

package/src/services/media.service.ts

@@ -19,6 +19,10 @@ import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { MediaRepository } from 'src/repository/media.repository';
+import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
+import { MediaStorageProviderMetadataRepository } from 'src/repository/media-storage-provider-metadata.repository';
+import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 
 
 @Injectable()
@@ -32,14 +36,18 @@ export class MediaService extends CRUDService<Media> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(Media, 'default')
-    readonly repo: Repository<Media>,
-    @InjectRepository(ModelMetadata)
-    private readonly modelMetadataRepo: Repository<ModelMetadata>,
-    @InjectRepository(MediaStorageProviderMetadata)
-    private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
-    @InjectRepository(FieldMetadata)
-    private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+    // @InjectRepository(Media, 'default')
+    // readonly repo: Repository<Media>,
+    readonly repo: MediaRepository,
+    // @InjectRepository(ModelMetadata)
+    // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    // @InjectRepository(MediaStorageProviderMetadata)
+    // private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
+    // @InjectRepository(FieldMetadata)
+    // private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+    private readonly modelMetadataRepo: ModelMetadataRepository,
+    private readonly mediaStorageProviderMetadataRepo: MediaStorageProviderMetadataRepository,
+    private readonly fieldMetadataRepo: FieldMetadataRepository,
     readonly moduleRef: ModuleRef,
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'media', 'solid-core', moduleRef);

package/src/services/menu-item-metadata.service.ts

@@ -15,6 +15,7 @@ import { UpdateMenuItemMetadataDto } from '../dtos/update-menu-item-metadata.dto
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 import { dasherize } from '@angular-devkit/core/src/utils/strings';
+import { MenuItemMetadataRepository } from 'src/repository/menu-item-metadata.repository';
 
 @Injectable()
 export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
@@ -27,8 +28,9 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(MenuItemMetadata, 'default')
-    readonly repo: Repository<MenuItemMetadata>,
+    // @InjectRepository(MenuItemMetadata, 'default')
+    // readonly repo: Repository<MenuItemMetadata>,
+    readonly repo: MenuItemMetadataRepository,
     readonly moduleRef: ModuleRef
 
   ) {
@@ -83,8 +85,9 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
     //     },
     //     relations: ['module', 'parentMenuItem', 'action']
     // });
-    const menuItems = await this.repo
-      .createQueryBuilder('menuItem')
+    const qb = await this.repo.createSecurityRuleAwareQueryBuilder('menuItem')
+
+    const menuItems = await qb
       .leftJoinAndSelect('menuItem.module', 'module')
       .leftJoinAndSelect('menuItem.parentMenuItem', 'parentMenuItem')
       .leftJoinAndSelect('menuItem.action', 'action')

package/src/services/model-metadata.service.ts

@@ -1,13 +1,19 @@
 import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
+import { InjectDataSource } from '@nestjs/typeorm';
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
 import { DataSource, EntityManager, In, Repository, SelectQueryBuilder } from 'typeorm';
 import { CreateModelMetadataDto } from '../dtos/create-model-metadata.dto';
 import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 
+import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { DisallowInProduction } from 'src/decorators/disallow-in-production.decorator';
 import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
+import { PermissionMetadata } from 'src/entities/permission-metadata.entity';
 import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
+import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
+import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
 import { BasicFilterDto } from '../dtos/basic-filters.dto';
 import { UpdateModelMetaDataDto } from '../dtos/update-model-metadata.dto';
 import { ActionMetadata } from '../entities/action-metadata.entity';
@@ -24,19 +30,17 @@ import { CrudHelperService } from './crud-helper.service';
 import { FieldMetadataService } from './field-metadata.service';
 import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
 import { RoleMetadataService } from './role-metadata.service';
-import { PermissionMetadata } from 'src/entities/permission-metadata.entity';
-import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
-import { DisallowInProduction } from 'src/decorators/disallow-in-production.decorator';
-import { ERROR_MESSAGES } from 'src/constants/error-messages';
 
 @Injectable()
 export class ModelMetadataService {
   private logger = new Logger('ModelMetadataService');
   constructor(
-    @InjectRepository(ModelMetadata)
-    private readonly modelMetadataRepo: Repository<ModelMetadata>,
-    @InjectRepository(FieldMetadata)
-    private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+    // @InjectRepository(ModelMetadata)
+    // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    // @InjectRepository(FieldMetadata)
+    // private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+    private readonly modelMetadataRepo: ModelMetadataRepository,
+    private readonly fieldMetadataRepo: FieldMetadataRepository,
     private readonly schematicService: SchematicService,
     @InjectDataSource()
     private readonly dataSource: DataSource,
@@ -55,7 +59,7 @@ export class ModelMetadataService {
     let { limit, offset } = basicFilterDto;
 
     // Create above query on pincode table using query builder
-    var qb: SelectQueryBuilder<ModelMetadata> = this.modelMetadataRepo.createQueryBuilder(alias)
+    var qb: SelectQueryBuilder<ModelMetadata> = await this.modelMetadataRepo.createSecurityRuleAwareQueryBuilder(alias)
     qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
 
     // Get the records and the count
@@ -555,50 +559,52 @@ export class ModelMetadataService {
       return;
     }
 
-    this.logger.log(`Cleaning up for model: ${modelEntity.singularName} belonging to module: ${modelEntity.module.name}`);
-
-    const modulePath = await this.moduleMetadataHelperService.getModulePath(modelEntity.module.name);
-    // /Users/harishpatel/Code/javascript/school-fees-portal/solid-api/src/solid-core
-    this.logger.log(`Module path: ${modulePath}`);
-
-    const filesToDelete = [];
-    // <singularName>.entity.ts | The TypeORM model that needs to be deleted. | Automatic
-    const entityFilePath = `${modulePath}/entities/${dasherize(modelEntity.singularName)}.entity.ts`;
-    filesToDelete.push(entityFilePath);
-    this.logger.log(`About to delete entity file path: ${entityFilePath}`);
-
-    // <singularName>.create.dto.ts | The TypeORM model that needs to be deleted. | Automatic
-    const createDtoFilePath = `${modulePath}/dtos/create-${dasherize(modelEntity.singularName)}.dto.ts`;
-    filesToDelete.push(createDtoFilePath);
-    this.logger.log(`About to delete create DTO file path: ${createDtoFilePath}`);
-
-    // <singularName>.update.dto.ts | The TypeORM model that needs to be deleted. | Automatic
-    const updateDtoFilePath = `${modulePath}/dtos/update-${dasherize(modelEntity.singularName)}.dto.ts`;
-    filesToDelete.push(updateDtoFilePath);
-    this.logger.log(`About to delete update DTO file path: ${updateDtoFilePath}`);
-
-    // <singularName>.repository.ts | The TypeORM model that needs to be deleted. | Automatic
-    const repositoryFilePath = `${modulePath}/repositories/${dasherize(modelEntity.singularName)}.repository.ts`;
-    filesToDelete.push(repositoryFilePath);
-    this.logger.log(`About to delete repository file path: ${repositoryFilePath}`);
-
-    // <singularName>.service.ts | The TypeORM model that needs to be deleted. | Automatic
-    const serviceFilePath = `${modulePath}/services/${dasherize(modelEntity.singularName)}.service.ts`;
-    filesToDelete.push(serviceFilePath);
-    this.logger.log(`About to delete service file path: ${serviceFilePath}`);
-
-    // <singularName>.controller.ts | The TypeORM model that needs to be deleted. | Automatic
-    const controllerFilePath = `${modulePath}/controllers/${dasherize(modelEntity.singularName)}.controller.ts`;
-    filesToDelete.push(controllerFilePath);
-    this.logger.log(`About to delete controller file path: ${controllerFilePath}`);
-
-    for (let i = 0; i < filesToDelete.length; i++) {
-      const fileToDelete = filesToDelete[i];
-      try {
-        await fs.unlink(fileToDelete);
-        this.logger.log(`Deleted file: ${fileToDelete}`);
-      } catch (error) {
-        this.logger.error(`Error deleting file: ${fileToDelete}`, error);
+    this.logger.log(`Cleaning up for model: ${modelEntity.singularName} belonging to module: ${modelEntity.module?.name}`);
+
+    const modulePath = await this.moduleMetadataHelperService.getModulePath(modelEntity.module?.name);
+    if (modulePath) {
+      // /Users/harishpatel/Code/javascript/school-fees-portal/solid-api/src/solid-core
+      this.logger.log(`Module path: ${modulePath}`);
+
+      const filesToDelete = [];
+      // <singularName>.entity.ts | The TypeORM model that needs to be deleted. | Automatic
+      const entityFilePath = `${modulePath}/entities/${dasherize(modelEntity.singularName)}.entity.ts`;
+      filesToDelete.push(entityFilePath);
+      this.logger.log(`About to delete entity file path: ${entityFilePath}`);
+
+      // <singularName>.create.dto.ts | The TypeORM model that needs to be deleted. | Automatic
+      const createDtoFilePath = `${modulePath}/dtos/create-${dasherize(modelEntity.singularName)}.dto.ts`;
+      filesToDelete.push(createDtoFilePath);
+      this.logger.log(`About to delete create DTO file path: ${createDtoFilePath}`);
+
+      // <singularName>.update.dto.ts | The TypeORM model that needs to be deleted. | Automatic
+      const updateDtoFilePath = `${modulePath}/dtos/update-${dasherize(modelEntity.singularName)}.dto.ts`;
+      filesToDelete.push(updateDtoFilePath);
+      this.logger.log(`About to delete update DTO file path: ${updateDtoFilePath}`);
+
+      // <singularName>.repository.ts | The TypeORM model that needs to be deleted. | Automatic
+      const repositoryFilePath = `${modulePath}/repositories/${dasherize(modelEntity.singularName)}.repository.ts`;
+      filesToDelete.push(repositoryFilePath);
+      this.logger.log(`About to delete repository file path: ${repositoryFilePath}`);
+
+      // <singularName>.service.ts | The TypeORM model that needs to be deleted. | Automatic
+      const serviceFilePath = `${modulePath}/services/${dasherize(modelEntity.singularName)}.service.ts`;
+      filesToDelete.push(serviceFilePath);
+      this.logger.log(`About to delete service file path: ${serviceFilePath}`);
+
+      // <singularName>.controller.ts | The TypeORM model that needs to be deleted. | Automatic
+      const controllerFilePath = `${modulePath}/controllers/${dasherize(modelEntity.singularName)}.controller.ts`;
+      filesToDelete.push(controllerFilePath);
+      this.logger.log(`About to delete controller file path: ${controllerFilePath}`);
+
+      for (let i = 0; i < filesToDelete.length; i++) {
+        const fileToDelete = filesToDelete[i];
+        try {
+          await fs.unlink(fileToDelete);
+          this.logger.log(`Deleted file: ${fileToDelete}`);
+        } catch (error) {
+          this.logger.error(`Error deleting file: ${fileToDelete}`, error);
+        }
       }
     }
 
@@ -655,7 +661,7 @@ export class ModelMetadataService {
     await viewRepo.delete({ model: { id: modelEntity.id } })
 
     // <moduleName>-metadata.json | Remove references to this model in the model metadata, menu, action & view sections. | Automatic
-    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(modelEntity.module.name);
+    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(modelEntity.module?.name);
     const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
     if (metaData) {
       const existingModelIndex = metaData.moduleMetadata.models.findIndex(
@@ -668,13 +674,13 @@ export class ModelMetadataService {
       }
 
       // Remove references to this model in the menu, action & view sections.
-      metaData.moduleMetadata.menus = metaData.moduleMetadata.menus.filter(
+      metaData.moduleMetadata.menus = metaData.moduleMetadata?.menus?.filter(
         (menu: any) => menu.modelUserKey !== modelEntity.singularName
       );
-      metaData.moduleMetadata.actions = metaData.moduleMetadata.actions.filter(
+      metaData.moduleMetadata.actions = metaData.moduleMetadata?.actions?.filter(
         (action: any) => action.modelUserKey !== modelEntity.singularName
       );
-      metaData.moduleMetadata.views = metaData.moduleMetadata.views.filter(
+      metaData.moduleMetadata.views = metaData.moduleMetadata?.views?.filter(
         (view: any) => view.modelUserKey !== modelEntity.singularName
       );
 

package/src/services/module-metadata.service.ts

@@ -23,6 +23,8 @@ import { ModelMetadataService } from './model-metadata.service';
 import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
 import { DisallowInProduction } from 'src/decorators/disallow-in-production.decorator';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import Module from 'module';
+import { ModuleMetadataRepository } from 'src/repository/module-metadata.repository';
 
 @Injectable()
 export class ModuleMetadataService {
@@ -31,8 +33,9 @@ export class ModuleMetadataService {
   constructor(
     @InjectDataSource()
     private readonly dataSource: DataSource,
-    @InjectRepository(ModuleMetadata)
-    private readonly moduleMetadataRepo: Repository<ModuleMetadata>,
+    // @InjectRepository(ModuleMetadata)
+    // private readonly moduleMetadataRepo: Repository<ModuleMetadata>,
+    private readonly moduleMetadataRepo: ModuleMetadataRepository,
     private readonly crudHelperService: CrudHelperService,
     private readonly schematicService: SchematicService,
     private readonly configService: ConfigService,
@@ -50,7 +53,7 @@ export class ModuleMetadataService {
     let { limit, offset } = basicFilterDto;
 
     // Create above query on pincode table using query builder
-    var qb: SelectQueryBuilder<ModuleMetadata> = this.moduleMetadataRepo.createQueryBuilder(alias)
+    var qb: SelectQueryBuilder<ModuleMetadata> = await this.moduleMetadataRepo.createSecurityRuleAwareQueryBuilder(alias)
     qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
 
     // Get the records and the count

package/src/services/mq-message-queue.service.ts

@@ -11,6 +11,7 @@ import { CrudHelperService } from "src/services/crud-helper.service";
 
 
 import { MqMessageQueue } from '../entities/mq-message-queue.entity';
+import { MqMessageQueueRepository } from 'src/repository/mq-message-queue.repository';
 
 @Injectable()
 export class MqMessageQueueService extends CRUDService<MqMessageQueue> {
@@ -24,8 +25,9 @@ export class MqMessageQueueService extends CRUDService<MqMessageQueue> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(MqMessageQueue)
-    readonly repo: Repository<MqMessageQueue>,
+    // @InjectRepository(MqMessageQueue)
+    // readonly repo: Repository<MqMessageQueue>,
+    readonly repo: MqMessageQueueRepository,
     readonly moduleRef: ModuleRef
 
   ) {