@solidstarters/solid-core 1.2.158 → 1.2.160

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.158",
+  "version": "1.2.160",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/factories/whatsapp.factory.ts

@@ -22,11 +22,12 @@ export class WhatsAppFactory {
 
     getWhatsappService(name: string = null): IWhatsAppTransport {
         // This is the default provider
-        const whatsappServiceName = this.commonConfiguration.whatsappProvider || name;
+        const whatsappServiceName = name || this.commonConfiguration.whatsappProvider;
         if (!whatsappServiceName) {
             throw new Error("Unable to resolve whatsapp provider")
         }
         const whatsappProviders = this.solidRegistry.getWhatsappProviders();
+
         // Return the instance which matches the whatsappServiceName
         if (!whatsappProviders.length) {
             // throw new Error("No mail providers are registered.");

package/src/helpers/model-metadata-helper.service.ts

@@ -2,13 +2,18 @@
 
 import { Injectable, Logger } from "@nestjs/common";
 import { SolidRegistry } from "./solid-registry";
-import { In } from "typeorm";
+import { In, Repository } from "typeorm";
+import { InjectRepository } from "@nestjs/typeorm";
+import { ModelMetadata } from "src/entities/model-metadata.entity";
 
 @Injectable()
 export class ModelMetadataHelperService {
     private readonly logger = new Logger(ModelMetadataHelperService.name);
 
-    constructor(private readonly registry: SolidRegistry) {
+    constructor(private readonly registry: SolidRegistry,
+        @InjectRepository(ModelMetadata)
+        private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    ) {
     }
 
     getSystemFieldsMetadata(): any[] {
@@ -105,5 +110,28 @@ export class ModelMetadataHelperService {
         return systemFieldsMetadata;
     }
 
+    async loadFieldHierarchy(modelName: any) {
+        const model = await this.modelMetadataRepo.findOne({
+            where: {
+                singularName: modelName,
+            },
+            relations: {
+                fields: true,
+                parentModel: {
+                    fields: true,
+                }
+            }
+        });
+        const fields = [];
+        if (model) {
+            // Add the fields of the current model
+            fields.push(...model.fields);
 
+            // Add the fields of the parent model
+            if (model.parentModel) {
+                fields.push(...model.parentModel.fields);
+            }
+        }
+        return fields;
+    }
 }

package/src/helpers/string.helper.ts

@@ -0,0 +1,4 @@
+export const lowerFirst = (str: string): string => {
+    if (!str) return str;
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}

package/src/index.ts

@@ -279,6 +279,7 @@ export * from './factories/mail.factory'
 export * from './repository/solid-base.repository'
 export * from './repository/security-rule.repository'
 export * from './repository/field.repository'
+export * from './repository/chatter-message.repository'
 
 
 //softDeleteAwareEventSubscriber.subscriber.ts

package/src/repository/security-rule.repository.ts

@@ -8,8 +8,8 @@ import { RoleMetadata } from 'src/entities/role-metadata.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
-import { CrudHelperService } from 'src/services/crud-helper.service';
-import { DataSource, Repository, SelectQueryBuilder } from 'typeorm';
+import { CrudHelperService, FilterCombinator } from 'src/services/crud-helper.service';
+import { Brackets, DataSource, Repository, SelectQueryBuilder } from 'typeorm';
 
 @Injectable()
 export class SecurityRuleRepository extends Repository<SecurityRule> {
@@ -26,18 +26,31 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
         // Fetch the security rules for the model and roles
         const securityRules = this.solidRegistry.getSecurityRules(modelSingularName, activeUser.roles);
 
-        // Loop through the security rules and add only rules that are json parseable and have a rule
-        securityRules.forEach((rule: SecurityRule) => {
-            try {
-                // Parse the security rule and call the buildFilter method to build the query from the security rule
-                const parsedRule = JSON.parse(this.resolveSecurityRuleConfig(rule.securityRuleConfig, activeUser)) as SecurityRuleConfig;
+        // If no security rules, return the original query builder
+        if (!securityRules.length) {
+            return qb;
+        }
+
+        // Apply each security rule to the query builder. The rules are combined with OR logic at the top level.
+        qb.andWhere(new Brackets((outerQb) => {
+            for (const rule of securityRules) {
+                try {
+                    const parsedRule = JSON.parse(
+                        this.resolveSecurityRuleConfig(rule.securityRuleConfig, activeUser)
+                    ) as SecurityRuleConfig;
+
                 if (parsedRule && parsedRule.filters) {
-                    this.crudHelperService.buildFilterQuery(qb, parsedRule, securityRuleAlias);
+                        outerQb.orWhere( // combine each rule-group with OR at the outer level
+                            new Brackets((innerQb) => {
+                               this.crudHelperService.applyFilters(innerQb, parsedRule.filters, securityRuleAlias, qb); // AND within a rule
+                            })
+                        );
+                    }
+                } catch (error) {
+                    this.logger.warn(`Error parsing security rule: ${rule.securityRuleConfig}`, error);
                 }
-            } catch (error) {
-                this.logger.warn(`Error parsing security rule: ${rule.securityRuleConfig}`, error);
             }
-        });
+        }));
 
         return qb;
     }
@@ -85,7 +98,7 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
                 },
             });
             createDto['role'] = role;
-        } 
+        }
 
         if (createDto.roleUserKey) {
             const role = await roleRepository.findOne({

package/src/repository/user.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from "@nestjs/common";
+import { User } from "src/entities/user.entity";
+import { RequestContextService } from "src/services/request-context.service";
+import { DataSource } from "typeorm";
+import { SecurityRuleRepository } from "./security-rule.repository";
+import { SolidBaseRepository } from "./solid-base.repository";
+
+@Injectable()
+export class UserRepository extends SolidBaseRepository<User> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(User, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/seeders/seed-data/solid-core-metadata.json

@@ -1697,6 +1697,7 @@
         "dataSourceType": "postgres",
         "userKeyFieldUserKey": "username",
         "isSystem": true,
+        "enableAuditTracking": true,
         "fields": [
           {
             "name": "fullName",
@@ -1709,7 +1710,8 @@
             "index": false,
             "private": false,
             "encrypt": false,
-            "isSystem": true
+            "isSystem": true,
+            "enableAuditTracking": true
           },
           {
             "name": "username",
@@ -1722,7 +1724,8 @@
             "index": true,
             "private": false,
             "encrypt": false,
-            "isSystem": true
+            "isSystem": true,
+            "enableAuditTracking": true
           },
           {
             "name": "email",
@@ -1735,7 +1738,8 @@
             "index": true,
             "private": false,
             "encrypt": false,
-            "isSystem": true
+            "isSystem": true,
+            "enableAuditTracking": true
           },
           {
             "name": "mobile",
@@ -1748,7 +1752,8 @@
             "index": true,
             "private": false,
             "encrypt": false,
-            "isSystem": true
+            "isSystem": true,
+            "enableAuditTracking": true
           },
           {
             "name": "password",
@@ -1884,7 +1889,8 @@
             "relationCascade": "cascade",
             "relationModelModuleName": "solid-core",
             "isSystem": true,
-            "isRelationManyToManyOwner": true
+            "isRelationManyToManyOwner": true,
+            "enableAuditTracking": true
           },
           {
             "name": "forgotPasswordConfirmedAt",
@@ -12256,5 +12262,33 @@
   ],
   "checksums": [],
   "listOfValues": [],
-  "scheduledJobs": []
+  "scheduledJobs": [],
+  "securityRules": [
+    {
+      "name": "model:User-role:Internal User",
+      "description": "Show User record for the current user only",
+      "roleUserKey": "Internal User",
+      "modelMetadataUserKey": "user",
+      "securityRuleConfig": {
+        "filters": {
+          "id": {
+            "$eq": "$activeUserId"
+          }
+        }
+      }
+    },
+    {
+      "name": "model:User-role:Admin",
+      "description": "Show All User records",
+      "roleUserKey": "Admin",
+      "modelMetadataUserKey": "user",
+      "securityRuleConfig": {
+        "filters": {
+          "id": {
+            "$ne": "0"
+          }
+        }
+      }
+    }
+  ]
 }

package/src/services/chatter-message.service.ts

@@ -18,6 +18,8 @@ import { ChatterMessageDetails } from '../entities/chatter-message-details.entit
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { RequestContextService } from './request-context.service';
 import { ChatterMessageRepository } from 'src/repository/chatter-message.repository';
+import { lowerFirst } from 'src/helpers/string.helper';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage>{
   constructor(
@@ -36,7 +38,8 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
     readonly moduleRef: ModuleRef,
     @InjectRepository(ModelMetadata)
     private readonly modelMetadataRepo: Repository<ModelMetadata>,
-    readonly requestContextService: RequestContextService
+    readonly requestContextService: RequestContextService,
+    private readonly modelMetadataHelperService: ModelMetadataHelperService,
  ) {
    super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'chatterMessage', 'solid-core', moduleRef);
  }
@@ -91,7 +94,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
     }
     const model = await this.modelMetadataRepo.findOne({
         where: {
-            displayName: metadata.name
+            singularName: lowerFirst(metadata.name)
         },
         relations: {
             fields: true,
@@ -142,13 +145,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
     }
 }
 
-async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEntity: any, messageQueue: boolean = false) {
+async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEntity: any, updatedColumns: any[] = [], messageQueue: boolean = false) {
     if(!databaseEntity || !entity){
         return;
     }
     const model = await this.modelMetadataRepo.findOne({
         where: {
-            displayName: metadata.name
+            singularName: lowerFirst(metadata.name)
         },
         relations: {
             fields: true,
@@ -159,34 +162,70 @@ async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEn
     if (!model || !model.enableAuditTracking) {
         return;
     }
+    
+    const modelFields = await this.modelMetadataHelperService.loadFieldHierarchy(model.singularName)
 
-    const auditFields = model.fields.filter(field => 
+    const auditFields = modelFields.filter(field => 
         field.enableAuditTracking && 
         !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
         !(field.type === 'relation' && field.relationType === 'one-to-many')
     );
 
-    const relationFields = auditFields.filter(field => 
-        field.type === 'relation'
-    );
-    if (relationFields.length > 0) {
-        const populatedEntity = await this.entityManager.findOne(metadata.target, {
-            where: { id: databaseEntity.id },
-            relations: relationFields.map(field => field.name)
-        });
-        if (populatedEntity) {
-            databaseEntity = populatedEntity;
-        }
+    const updatedFieldNames = new Set(updatedColumns.map(col => col.propertyName));
+    
+    const allNonRelationFields = auditFields.filter(field => field.type !== 'relation');
+    const allRelationFields = auditFields.filter(field => field.type === 'relation');
+
+    let potentialNonRelationFields = [];
+    
+    if (updatedColumns.length > 0) {
+        potentialNonRelationFields = allNonRelationFields.filter(field => 
+            updatedFieldNames.has(field.name)
+        );
+    } else {
+        potentialNonRelationFields = allNonRelationFields;
     }
-    const changedFields = auditFields.filter(field => {
+
+    const potentialRelationFields = allRelationFields;
+
+    const changedNonRelationFields = potentialNonRelationFields.filter(field => {
         const newValue = entity[field.name];
         const oldValue = databaseEntity[field.name];
         return this.hasValueChanged(newValue, oldValue);
     });
+
+    const changedRelationFields = [];
+    if (potentialRelationFields.length > 0) {
+        const populatedOldEntity = await this.populateRelationFields(databaseEntity, potentialRelationFields, metadata);
+
+        for (const field of potentialRelationFields) {
+            const newValue = entity[field.name];
+            const oldValue = populatedOldEntity[field.name];
+            
+            if (this.hasRelationValueChanged(field, newValue, oldValue)) {
+                changedRelationFields.push({
+                    field,
+                    newValue,
+                    oldValue
+                });
+            }
+        }
+    }
+
+
+    const allChangedFields = [
+        ...changedNonRelationFields.map(field => ({
+            field,
+            newValue: entity[field.name],
+            oldValue: databaseEntity[field.name]
+        })),
+        ...changedRelationFields
+    ];
     
-    if (changedFields.length === 0) {
+    if (allChangedFields.length === 0) {
         return;
     }
+
     const activeUser = this.requestContextService.getActiveUser();
 
     const chatterMessage = new ChatterMessage();
@@ -205,14 +244,14 @@ async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEn
 
     const savedMessage = await this.repo.save(chatterMessage);
 
-    for (const field of changedFields) {
+    for (const { field, newValue, oldValue } of allChangedFields) {
         const messageDetail = new ChatterMessageDetails();
         messageDetail.chatterMessage = savedMessage;
         messageDetail.fieldName = field.name;
-        messageDetail.oldValue = this.formatFieldValue(field, databaseEntity[field.name]);
-        messageDetail.newValue = this.formatFieldValue(field, entity[field.name]);
-        messageDetail.oldValueDisplay = this.formatFieldValueDisplay(field, databaseEntity[field.name]);
-        messageDetail.newValueDisplay = this.formatFieldValueDisplay(field, entity[field.name]);
+        messageDetail.oldValue = this.formatFieldValue(field, oldValue);
+        messageDetail.newValue = this.formatFieldValue(field, newValue);
+        messageDetail.oldValueDisplay = this.formatFieldValueDisplay(field, oldValue);
+        messageDetail.newValueDisplay = this.formatFieldValueDisplay(field, newValue);
         await this.chatterMessageDetailsRepo.save(messageDetail);
     }
 }
@@ -220,7 +259,7 @@ async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEn
 async postAuditMessageOnDelete(entity: any, metadata: EntityMetadata, databaseEntity: any, messageQueue: boolean = false) {
     const model = await this.modelMetadataRepo.findOne({
         where: {
-            displayName: metadata.name
+            singularName: lowerFirst(metadata.name)
         },
         relations: {
             fields: true,
@@ -296,28 +335,139 @@ private formatFieldValueDisplay(field: any, value: any): string {
 }
 
 private hasValueChanged(newValue: any, oldValue: any): boolean {
-    if (
-        (newValue === null || newValue === undefined) &&
-        (oldValue === null || oldValue === undefined)
-    ) {
+    if (newValue === oldValue) {
         return false;
     }
 
-    if (newValue === oldValue) {
+    if (newValue === null && oldValue === null) {
         return false;
     }
 
-    if (Array.isArray(newValue) && Array.isArray(oldValue)) {
-        return JSON.stringify(newValue) !== JSON.stringify(oldValue);
+    if (newValue === undefined && oldValue === undefined) {
+        return false;
+    }
+
+    if (newValue && oldValue && typeof newValue === 'object' && typeof oldValue === 'object') {
+        if (newValue.id !== undefined && oldValue.id !== undefined) {
+            return newValue.id !== oldValue.id;
+        }
+        
+        if (Array.isArray(newValue) && Array.isArray(oldValue)) {
+            if (newValue.length !== oldValue.length) {
+                return true;
+            }
+            const newIds = newValue.map(item => item.id || item).sort();
+            const oldIds = oldValue.map(item => item.id || item).sort();
+            return JSON.stringify(newIds) !== JSON.stringify(oldIds);
+        }
     }
 
-    if (
-        typeof newValue === 'object' && newValue !== null &&
-        typeof oldValue === 'object' && oldValue !== null
-    ) {
+    if (Array.isArray(newValue) && Array.isArray(oldValue)) {
         return JSON.stringify(newValue) !== JSON.stringify(oldValue);
     }
 
     return true;
 }
+
+private hasRelationValueChanged(field: any, newValue: any, oldValue: any): boolean {
+    if (newValue === oldValue) {
+        return false;
+    }
+    
+    if ((newValue === null || newValue === undefined) && (oldValue === null || oldValue === undefined)) {
+        return false;
+    }
+
+    if (field.relationType === 'many-to-one') {
+        const newId = this.extractRelationId(newValue);
+        const oldId = this.extractRelationId(oldValue);
+        return newId !== oldId;
+    }
+
+    if (field.relationType === 'many-to-many' || field.relationType === 'manyToMany') {
+        const newIds = this.extractRelationIds(newValue);
+        const oldIds = this.extractRelationIds(oldValue);
+        
+        if (newIds.length !== oldIds.length) {
+            return true;
+        }
+        
+        newIds.sort();
+        oldIds.sort();
+        
+        return JSON.stringify(newIds) !== JSON.stringify(oldIds);
+    }
+
+    return this.hasValueChanged(newValue, oldValue);
+}
+
+private extractRelationId(value: any): any {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    
+    if (typeof value === 'string' || typeof value === 'number') {
+        return value;
+    }
+    
+    if (typeof value === 'object' && value.id !== undefined) {
+        return value.id;
+    }
+    
+    return null;
+}
+
+private extractRelationIds(value: any): any[] {
+    if (!Array.isArray(value)) {
+        const id = this.extractRelationId(value);
+        return id !== null ? [id] : [];
+    }
+    
+    return value.map(item => this.extractRelationId(item)).filter(id => id !== null);
+}
+
+private async populateRelationFields(databaseEntity: any, relationFields: any[], metadata: EntityMetadata): Promise<any> {
+    const populatedEntity = { ...databaseEntity };
+    
+    for (const field of relationFields) {
+        const relationValue = databaseEntity[field.name];
+        
+        if (relationValue === null || relationValue === undefined) {
+            populatedEntity[field.name] = relationValue;
+            continue;
+        }
+
+        const relationMetadata = metadata.relations.find(rel => rel.propertyName === field.name);
+        if (!relationMetadata) {
+            populatedEntity[field.name] = relationValue;
+            continue;
+        }
+
+        const targetEntity = relationMetadata.inverseEntityMetadata || relationMetadata.type;
+        
+        if (field.relationType === 'many-to-one') {
+            const relationId = this.extractRelationId(relationValue);
+            if (relationId) {
+                const relatedEntity = await this.entityManager.findOne(targetEntity as any, {
+                    where: { id: relationId }
+                });
+                populatedEntity[field.name] = relatedEntity;
+            } else {
+                populatedEntity[field.name] = relationValue; 
+            }
+        } else if (field.relationType === 'many-to-many' || field.relationType === 'manyToMany') {
+            const relationIds = this.extractRelationIds(relationValue);
+            if (relationIds.length > 0) {
+                const relatedEntities = await this.entityManager.findByIds(targetEntity as any, relationIds);
+                populatedEntity[field.name] = relatedEntities;
+            } else {
+                populatedEntity[field.name] = relationValue; 
+            }
+        } else {
+            populatedEntity[field.name] = relationValue;
+        }
+    }
+    
+    return populatedEntity;
+}
 }

package/src/services/crud-helper.service.ts

@@ -6,6 +6,10 @@ import { SolidRegistry } from "src/helpers/solid-registry";
 import { Logger } from "@nestjs/common";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 
+export enum FilterCombinator {
+    AND = '$and',
+    OR = '$or'
+}
 
 export class CrudHelperService {
     constructor(
@@ -24,7 +28,7 @@ export class CrudHelperService {
         return orderOptions;
     }
 
-    private applyFilters(qb: WhereExpressionBuilder, filters: any, alias: string = 'entity', selectQb: SelectQueryBuilder<any>) {
+    applyFilters(qb: WhereExpressionBuilder, filters: any, alias: string = 'entity', selectQb: SelectQueryBuilder<any>) {
         const normalizedFilters = this.normalizeObjectKeys(filters);
         if (normalizedFilters.$and) {
             normalizedFilters.$and.forEach((andFilter: any) => {
@@ -157,8 +161,16 @@ export class CrudHelperService {
     private hasJoins(queryBuilder: SelectQueryBuilder<any>): boolean {
         return queryBuilder.expressionMap.joinAttributes.length > 0;
     }
- 
-    buildFilterQuery(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string, internationalisation?: boolean, draftPublishWorkflow?: boolean,moduleRef?:any): SelectQueryBuilder<any> { // TODO : Check how to pass a type to SelectQueryBuilder instead of any
+
+    buildFilterQuery(
+        qb: SelectQueryBuilder<any>,
+        basicFilterDto: BasicFilterDto,
+        entityAlias: string,
+        internationalisation?: boolean,
+        draftPublishWorkflow?: boolean,
+        moduleRef?: any,
+        filterCombinator: FilterCombinator = FilterCombinator.AND
+    ): SelectQueryBuilder<any> { // TODO : Check how to pass a type to SelectQueryBuilder instead of any
         let { limit, offset, showSoftDeleted, filters } = basicFilterDto;
         const { fields, sort, groupBy, populate = [], populateMedia = [], locale, status } = basicFilterDto;
 
@@ -184,9 +196,15 @@ export class CrudHelperService {
         }
 
         if (filters) {
-            qb.andWhere(new Brackets(whereQb => {
-                this.applyFilters(whereQb, filters, entityAlias, qb);
-            }));
+            if (filterCombinator === FilterCombinator.AND) {
+                qb.andWhere(new Brackets(whereQb => {
+                    this.applyFilters(whereQb, filters, entityAlias, qb);
+                }));
+            } else if (filterCombinator === FilterCombinator.OR) {
+                qb.orWhere(new Brackets(whereQb => {
+                    this.applyFilters(whereQb, filters, entityAlias, qb);
+                }));
+            }
         }
 
         let finalLocale = locale

package/src/services/user.service.ts

@@ -16,6 +16,7 @@ import { User } from '../entities/user.entity';
 import { ActiveUserData } from '../interfaces/active-user-data.interface';
 import { iamConfig } from 'src/config/iam.config';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { UserRepository } from 'src/repository/user.repository';
 
 @Injectable()
 export class UserService extends CRUDService<User> {
@@ -28,8 +29,8 @@ export class UserService extends CRUDService<User> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(User, 'default')
-    readonly repo: Repository<User>,
+    // @InjectRepository(User, 'default')
+    readonly repo: UserRepository,
     @InjectRepository(RoleMetadata)
     private readonly roleRepository: Repository<RoleMetadata>,
     readonly moduleRef: ModuleRef,

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

@@ -21,6 +21,7 @@ import { ActionMetadataService } from './action-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { UserViewMetadataService } from './user-view-metadata.service';
 import { ViewMetadataRepository } from 'src/repository/view-metadata.repository';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
@@ -42,6 +43,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     private readonly fieldMetadataRepo: Repository<FieldMetadata>,
     @InjectRepository(ModelMetadata)
     private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    private readonly modelMetadataHelperService: ModelMetadataHelperService,
     readonly moduleRef: ModuleRef
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'viewMetadata', 'solid-core', moduleRef);
@@ -172,7 +174,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     }
 
     // 5. Create an easy to use map of field metadata, rather than sending an array of fields it becomes easier to use in the frontend.
-    const fields = await this.loadFieldHierarchy(modelName);
+    const fields = await this.modelMetadataHelperService.loadFieldHierarchy(modelName);
     const fieldsMap = new Map<string, FieldMetadata>();
     for (let i = 0; i < fields.length; i++) {
       const field = fields[i];