@solidstarters/solid-core 1.2.189 → 1.2.192

package/src/services/import-transaction.service.ts

@@ -1,7 +1,7 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, ForbiddenException, Injectable, Logger } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-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';
@@ -13,20 +13,25 @@ import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 import { classify } from '@angular-devkit/core/src/utils/strings';
 import { HttpService } from '@nestjs/axios';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { RelationFieldsCommand, RelationType, SolidFieldType } from 'src/dtos/create-field-metadata.dto';
 import { ImportInstructionsResponseDto, StandardImportInstructionsResponseDto } from 'src/dtos/import-instructions.dto';
 import { FieldMetadata } from 'src/entities/field-metadata.entity';
 import { ImportTransactionErrorLog } from 'src/entities/import-transaction-error-log.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { parseFlexibleDate } from 'src/helpers/date.helper';
 import { MediaWithFullUrl } from 'src/interfaces';
+import { ImportTransactionRepository } from 'src/repository/import-transaction.repository';
 import { Readable } from 'stream';
 import { v4 as uuidv4 } from 'uuid';
 import { ImportTransaction } from '../entities/import-transaction.entity';
 import { CsvService } from './csv.service';
 import { ExcelService } from './excel.service';
 import { SolidIntrospectService } from './solid-introspect.service';
-import { ERROR_MESSAGES } from 'src/constants/error-messages';
-import { parseFlexibleDate } from 'src/helpers/date.helper';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
+import { getUserExcludedFields } from 'src/helpers/user-helper';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+import {upperFirst, camelCase} from 'lodash';
 
 interface ImportTemplateFileInfo {
   stream: NodeJS.ReadableStream;
@@ -97,13 +102,15 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ImportTransaction, 'default')
-    readonly repo: Repository<ImportTransaction>,
+    // @InjectRepository(ImportTransaction, 'default')
+    // readonly repo: Repository<ImportTransaction>,
+    readonly repo: ImportTransactionRepository,
     readonly moduleRef: ModuleRef,
     readonly excelService: ExcelService,
     readonly csvService: CsvService,
     readonly httpService: HttpService,
     readonly introspectService: SolidIntrospectService,
+    private readonly modelMetadataHelperService: ModelMetadataHelperService,
     // readonly fieldMetadataService: FieldMetadataService,
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'importTransaction', 'solid-core', moduleRef);
@@ -124,8 +131,16 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     if (!modelMetadata) {
       throw new Error(ERROR_MESSAGES.MODEL_METADATA_NOT_FOUND(modelMetadataId));
     }
+
+    const allFields = await this.modelMetadataHelperService.loadFieldHierarchy(
+      modelMetadata.singularName,
+    );
+
+    // Replace original fields with full hierarchy fields
+    // modelMetadata.fields = allFields;  
+
     // Create a header row with the display names of the fields, excluding the media fields,computed fields
-    const headers = this.fieldsAllowedForImport(modelMetadata.fields)
+    const headers = this.fieldsAllowedForImport(allFields)
       .map(field => field.displayName);
 
     // Depending on the format, generate the template
@@ -163,6 +178,19 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
       throw new Error(ERROR_MESSAGES.MODEL_METADATA_NOT_FOUND(modelMetadataId));
     }
 
+    // Step 2: Load full field hierarchy (includes parent model fields)
+    const allFields = await this.modelMetadataHelperService.loadFieldHierarchy(
+      modelMetadata.singularName,
+    );
+
+    const systemFieldNames = this.modelMetadataHelperService
+      .getSystemFieldsMetadata()
+      .map(field => field.name);
+
+    const userExcluded = getUserExcludedFields();
+    // Replace modelMetadata.fields with combined (child + parent) fields
+    // modelMetadata.fields = allFields;
+
     // Create the standard import instructions
     const standardInstructions: StandardImportInstructionsResponseDto = {
       requiredFields: [],
@@ -176,8 +204,18 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     };
 
     // Iterate through the fields and populate the standard instructions
-    for (const field of modelMetadata.fields) {
-      if (field.isSystem) continue; // Skip system fields
+    for (const field of allFields) {
+      // Skip system fields
+      if (systemFieldNames.includes(field.name)) {
+        continue;
+      }
+
+      // Skip excluded user fields (NO model name check needed)
+      if (userExcluded.includes(field.name)) {
+        continue;
+      }
+
+      // if (field.isSystem) continue; // Skip system fields
       if (field.required) {
         standardInstructions.requiredFields.push(field.displayName);
       }
@@ -255,9 +293,22 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     };
   }
 
-  async startImportSync(importTransactionId: number): Promise<ImportSyncResult> {
+  async startImportSync(importTransactionId: number, activeUser: ActiveUserData): Promise<ImportSyncResult> {
     // Load the import transaction for the given ID
     const importTransaction = await this.loadImportTransaction(importTransactionId);
+    const modelName = upperFirst(camelCase(importTransaction.modelMetadata.singularName));
+    const permissionKey = `${modelName}Controller.insertMany`;
+
+    const userPermissions = activeUser.permissions ?? [];
+    const hasPermission = Array.isArray(userPermissions)
+      ? userPermissions.includes(permissionKey)
+      : userPermissions[permissionKey] === true;
+
+    if (!hasPermission) {
+      throw new ForbiddenException(
+        `Missing permission: ${permissionKey}`
+      );
+    }
 
     // Get the import file media object from the import transaction
     const importFileMediaObject = this.getImportFileObject(importTransaction);
@@ -366,18 +417,43 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
   }
 
 
+  // private async loadImportTransaction(importTransactionId: number) {
+  //   const importTransaction = await this.findOne(importTransactionId, {
+  //     populate: ['modelMetadata', 'modelMetadata.fields'],
+  //     populateMedia: ['fileLocation'],
+  //   });
+  //   if (!importTransaction) {
+  //     throw new Error(`Import transaction with ID ${importTransactionId} not found.`);
+  //   }
+  //   return importTransaction;
+  // }
+
   private async loadImportTransaction(importTransactionId: number) {
+    // Step 1: Load the transaction with model metadata
     const importTransaction = await this.findOne(importTransactionId, {
-      populate: ['modelMetadata', 'modelMetadata.fields'],
+      populate: ['modelMetadata'],
       populateMedia: ['fileLocation'],
     });
-    if (!importTransaction) {
-      throw new Error(`Import transaction with ID ${importTransactionId} not found.`);
-    }
+
+    // Step 2: Load full field hierarchy (child + parent fields)
+    const modelFields = await this.modelMetadataHelperService.loadFieldHierarchy(
+      importTransaction.modelMetadata.singularName,
+    );
+
+    // Step 3: Attach the combined fields back into the modelMetadata
+    importTransaction.modelMetadata.fields = modelFields;
+
     return importTransaction;
   }
 
   private fieldsAllowedForImport(fields: FieldMetadata[]): FieldMetadata[] {
+    // Get system field names (e.g. id, createdAt, updatedAt...)
+    const systemFieldNames = this.modelMetadataHelperService
+      .getSystemFieldsMetadata()
+      .map(field => field.name);
+
+    const userExcluded = getUserExcludedFields();
+
     // Filter out fields that are not allowed for import
     return fields.filter(field =>
       field.type !== SolidFieldType.mediaMultiple && // Exclude media multiple fields
@@ -387,7 +463,10 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
       field.type !== SolidFieldType.richText &&
       field.type !== SolidFieldType.uuid &&
       field.relationType !== RelationType.oneToMany &&
-      field.isSystem !== true // Exclude system fields
+      !systemFieldNames.includes(field.name) &&
+      // field.isSystem !== true // Exclude system fields
+
+      !userExcluded.includes(field.name)
     );
   }
 
@@ -567,11 +646,11 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     // TODO Move this logic to field crud managers i.e add a parse method to the field crud manager interface
     switch (fieldType) {
       case SolidFieldType.relation: {
-        return await this.populateDtoForRelations(fieldMetadata, record, key, dtoRecord); 
+        return await this.populateDtoForRelations(fieldMetadata, record, key, dtoRecord);
       }
       case SolidFieldType.date:
       case SolidFieldType.datetime:
-         return this.populateDtoForDate(record, key, fieldMetadata, dtoRecord);
+        return this.populateDtoForDate(record, key, fieldMetadata, dtoRecord);
       case SolidFieldType.int:
       case SolidFieldType.bigint:
       case SolidFieldType.decimal:
@@ -594,7 +673,7 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
       }
     }
   }
-  
+
   private populateDtoForSelectionValues(dtoRecord: Record<string, any>, fieldMetadata: FieldMetadata, record: Record<string, any>, key: string) {
     const rawValue = record[key];
 
@@ -658,17 +737,17 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
         dtoRecord[fieldMetadata.name] = null; // If the cell is empty, set the field to null
         return dtoRecord;
       }
-     // Use flexible date parser
-     this.logger.verbose(cellValue,'cellValue');
-     
-  const dateValue = parseFlexibleDate(cellValue);
-  this.logger.verbose(dateValue,'dateValue');
-
-  if (!dateValue) {
-    throw new Error(
-      `Invalid date value for cell ${key} with value ${cellValue}`
-    );
-  }
+      // Use flexible date parser
+      this.logger.verbose(cellValue, 'cellValue');
+
+      const dateValue = parseFlexibleDate(cellValue);
+      this.logger.verbose(dateValue, 'dateValue');
+
+      if (!dateValue) {
+        throw new Error(
+          `Invalid date value for cell ${key} with value ${cellValue}`
+        );
+      }
       dtoRecord[fieldMetadata.name] = dateValue;
       return dtoRecord;
     }

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')