@solidstarters/solid-core 1.2.158 → 1.2.159

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];

package/src/solid-core.module.ts

@@ -283,6 +283,7 @@ import { Three60WhatsappQueueSubscriberDatabase } from './jobs/database/three60-
 import { Three60WhatsappService } from './services/whatsapp/Three60WhatsappService';
 import { ThrottlerStorageRedisService } from '@nest-lab/throttler-storage-redis/src/throttler-storage-redis.service';
 import { isRedisConfigured } from './helpers/environment.helper';
+import { UserRepository } from './repository/user.repository';
 
 
 @Global()
@@ -546,6 +547,7 @@ import { isRedisConfigured } from './helpers/environment.helper';
     RoleMetadataService,
     PermissionMetadataSeederService,
     UserService,
+    UserRepository,
     SettingService,
     ConcatComputedFieldProvider,
     FileStorageProvider,
@@ -615,6 +617,7 @@ import { isRedisConfigured } from './helpers/environment.helper';
     MailFactory,
     ChatterMessageRepository,
     ChatterMessageDetailsRepository,
+
   ],
   exports: [
     ModuleMetadataService,

package/src/subscribers/audit.subscriber.ts

@@ -3,6 +3,9 @@ import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { DataSource, EntityMetadata, EntitySubscriberInterface, EventSubscriber, InsertEvent, RemoveEvent, Repository, UpdateEvent } from 'typeorm';
 import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ChatterMessageService } from '../services/chatter-message.service';
+import { lowerFirst } from 'src/helpers/string.helper';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
+
 @Injectable()
 @EventSubscriber()
 export class AuditSubscriber implements EntitySubscriberInterface {
@@ -13,6 +16,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
         private readonly chatterMessageService: ChatterMessageService,
         @InjectRepository(ModelMetadata)
         private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        private readonly modelMetadataHelperService : ModelMetadataHelperService,
     ) {
         this.dataSource.subscribers.push(this);
     }
@@ -20,7 +24,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
     private async shouldTrackAudit(entity: any, metadata: EntityMetadata): Promise<boolean> {
         const model = await this.modelMetadataRepo.findOne({
             where: {
-                displayName: metadata.name
+                singularName: lowerFirst(metadata.name)
             },
             relations: {
                 fields: true,
@@ -32,7 +36,9 @@ export class AuditSubscriber implements EntitySubscriberInterface {
             return false;
         }
 
-        const auditFields = model.fields.filter(field =>
+        const modelFields = await this.modelMetadataHelperService.loadFieldHierarchy(model.singularName)
+
+        const auditFields = modelFields.filter(field =>
             field.enableAuditTracking &&
             !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
             !(field.type === 'relation' && field.relationType === 'one-to-many')
@@ -56,7 +62,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
     async afterUpdate(event: UpdateEvent<any>) {
         if (await this.shouldTrackAudit(event.entity, event.metadata)) {
-            await this.chatterMessageService.postAuditMessageOnUpdate(event.entity, event.metadata, event.databaseEntity);
+            await this.chatterMessageService.postAuditMessageOnUpdate(event.entity, event.metadata, event.databaseEntity, event.updatedColumns || []);
         }
     }