@solidstarters/solid-core 1.2.63 → 1.2.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.63",
+  "version": "1.2.66",
   "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",
@@ -51,6 +51,7 @@
     "mailgen": "^2.0.28",
     "mongoose": "^8.7.0",
     "mysql2": "^3.13.0",
+    "nestjs-cls": "^5.4.3",
     "nodemailer": "^6.9.13",
     "passport": "^0.7.0",
     "passport-google-oauth2": "^0.2.0",

package/src/controllers/chatter-message.controller.ts

@@ -98,8 +98,7 @@ export class ChatterMessageController {
   async postMessage(
     @Body() postDto: PostChatterMessageDto,
     @UploadedFiles() files: Array<Express.Multer.File>,
-    @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto
   ) {
-    return this.service.postMessage(postDto, solidRequestContext, files);
+    return this.service.postMessage(postDto, files);
   }
 }

package/src/decorators/active-user.decorator.ts

@@ -5,6 +5,7 @@ import { REQUEST_USER_KEY } from "../constants";
 export const ActiveUser = createParamDecorator(
     (field: keyof ActiveUserData | undefined, ctx: ExecutionContext) => {
         const request = ctx.switchToHttp().getRequest();
+        // TODO idealiy we should use RequestContextService and getActiveUser method. (Works for async scenarios too)
         const user: ActiveUserData | undefined = request[REQUEST_USER_KEY];
         return field ? user?.[field] : user;
     },

package/src/decorators/solid-request-context.decorator.ts

@@ -6,7 +6,8 @@ import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 export const SolidRequestContextDecorator = createParamDecorator(
   (data: unknown, ctx: ExecutionContext): SolidRequestContextDto => {
     const request = ctx.switchToHttp().getRequest();
-    const activeUser: ActiveUserData | undefined = request[REQUEST_USER_KEY]; // Get active user
+    // TODO idealiy we should use RequestContextService and getActiveUser method. (Works for async scenarios too)
+    const activeUser: ActiveUserData | undefined = request[REQUEST_USER_KEY];
 
     // Create a new instance of SolidRequestContextDto and stamp user data
     const solidRequestContext = new SolidRequestContextDto();

package/src/guards/access-token.guard.ts

@@ -12,6 +12,7 @@ import { ActiveUserData } from '../interfaces/active-user-data.interface';
 import { jwtConfig } from '../config/iam.config';
 import { REQUEST_USER_KEY } from "../constants";
 import { PermissionMetadataService } from '../services/permission-metadata.service';
+import { ClsService } from 'nestjs-cls';
 
 @Injectable()
 export class AccessTokenGuard implements CanActivate {
@@ -20,6 +21,7 @@ export class AccessTokenGuard implements CanActivate {
     @Inject(jwtConfig.KEY)
     private readonly jwtConfiguration: ConfigType<typeof jwtConfig>,
     private readonly permissionsService: PermissionMetadataService,
+    private readonly cls: ClsService
   ) { }
 
   async canActivate(context: ExecutionContext): Promise<boolean> {
@@ -40,6 +42,7 @@ export class AccessTokenGuard implements CanActivate {
       payload.permissions = permissions.map((permission) => permission.name);
 
       request[REQUEST_USER_KEY] = payload;
+      this.cls.set(REQUEST_USER_KEY, payload);
       // console.log(`About to set payload in the request user key:`);
       // console.log(payload);
     } catch {

package/src/index.ts

@@ -228,7 +228,6 @@ export * from './services/security-rule.service'
 export * from './services/request-context.service'
 export * from './services/chatter-message.service'
 export * from './services/chatter-message-details.service'
-export * from './services/user-context.service'
 // Repositories
 export * from './repository/solid-base.repository'
 export * from './repository/security-rule.repository'

package/src/interfaces.ts

@@ -162,4 +162,8 @@ export interface QueuesModuleOptions {
   name: string;
   type: BrokerType;
   queueName: string;
-}
+}
+
+export type MediaWithFullUrl = Media & {
+  _full_url: string;
+};

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

@@ -11,7 +11,6 @@ import { FileService } from 'src/services/file.service';
 import { CrudHelperService } from 'src/services/crud-helper.service';
 
 import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
-import { UserContextService } from './user-context.service';
 
 @Injectable()
 export class ChatterMessageDetailsService extends CRUDService<ChatterMessageDetails>{
@@ -27,8 +26,7 @@ export class ChatterMessageDetailsService extends CRUDService<ChatterMessageDeta
     @InjectRepository(ChatterMessageDetails, 'default')
     readonly repo: Repository<ChatterMessageDetails>,
     readonly moduleRef: ModuleRef,
-    readonly userContextService: UserContextService
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'chatterMessageDetails', 'solid-core', moduleRef, userContextService);
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'chatterMessageDetails', 'solid-core', moduleRef);
   }
 }

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

@@ -16,7 +16,7 @@ import { getMediaStorageProvider } from './mediaStorageProviders';
 import { MediaStorageProviderType } from '../dtos/create-media-storage-provider-metadata.dto';
 import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
-import { UserContextService } from './user-context.service';
+import { RequestContextService } from './request-context.service';
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage>{
   constructor(
@@ -35,24 +35,27 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
     readonly moduleRef: ModuleRef,
     @InjectRepository(ModelMetadata)
     private readonly modelMetadataRepo: Repository<ModelMetadata>,
-    readonly userContextService: UserContextService
+    readonly requestContextService: RequestContextService
  ) {
-   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'chatterMessage', 'solid-core', moduleRef, userContextService);
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'chatterMessage', 'solid-core', moduleRef);
  }
 
- async postMessage(postDto: PostChatterMessageDto, solidRequestContext: SolidRequestContextDto, files: Express.Multer.File[] = []) {
+ async postMessage(postDto: PostChatterMessageDto, files: Express.Multer.File[] = []) {
     const chatterMessage = new ChatterMessage();
     chatterMessage.messageType = 'custom';
-    chatterMessage.messageSubType = postDto.messageSubType || 'general';
+    chatterMessage.messageSubType = postDto.messageSubType || 'post_message';
     chatterMessage.messageBody = postDto.messageBody;
     chatterMessage.coModelEntityId = postDto.coModelEntityId;
     chatterMessage.coModelName = postDto.coModelName;
     
-    const userId = typeof solidRequestContext.activeUser === 'object' 
-        ? solidRequestContext.activeUser.sub 
-        : solidRequestContext.activeUser;
-    
-    chatterMessage.user = { id: userId } as any;
+    const activeUser = this.requestContextService.getActiveUser();
+
+    if (activeUser) {
+        const userId = activeUser?.sub;
+        chatterMessage.user = { id: userId } as any;
+    } else {
+        chatterMessage.user = null;
+    }
 
     const savedMessage = await this.repo.save(chatterMessage);
 
@@ -81,7 +84,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
     return savedMessage;
  }
 
- async postAuditMessageOnInsert(entity: any, metadata: EntityMetadata, activeUser: any, messageQueue: boolean = false) {
+ async postAuditMessageOnInsert(entity: any, metadata: EntityMetadata, messageQueue: boolean = false) {
     const model = await this.modelMetadataRepo.findOne({
         where: {
             displayName: metadata.name
@@ -98,9 +101,12 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
 
     const auditFields = model.fields.filter(field => 
         field.enableAuditTracking && 
-        !['oneToMany', 'mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type)
+        !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
+        !(field.type === 'relation' && field.relationType === 'one-to-many')
     );
 
+    const activeUser = this.requestContextService.getActiveUser();
+
     const chatterMessage = new ChatterMessage();
     chatterMessage.messageType = 'audit';
     chatterMessage.messageSubType = 'insert';
@@ -109,7 +115,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
     chatterMessage.messageBody = `New ${model.displayName} created`;
     
     if (activeUser) {
-        const userId = typeof activeUser === 'object' ? activeUser.sub : activeUser;
+        const userId = activeUser?.sub;
         chatterMessage.user = { id: userId } as any;
     } else {
         chatterMessage.user = null;
@@ -132,7 +138,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
     }
 }
 
-async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEntity: any, activeUser: any, messageQueue: boolean = false) {
+async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEntity: any, messageQueue: boolean = false) {
     const model = await this.modelMetadataRepo.findOne({
         where: {
             displayName: metadata.name
@@ -149,7 +155,8 @@ async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEn
 
     const auditFields = model.fields.filter(field => 
         field.enableAuditTracking && 
-        !['oneToMany', 'mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type)
+        !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
+        !(field.type === 'relation' && field.relationType === 'one-to-many')
     );
 
     const relationFields = auditFields.filter(field => 
@@ -164,16 +171,16 @@ async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEn
             databaseEntity = populatedEntity;
         }
     }
-
     const changedFields = auditFields.filter(field => {
         const newValue = entity[field.name];
         const oldValue = databaseEntity[field.name];
         return this.hasValueChanged(newValue, oldValue);
     });
-
+    
     if (changedFields.length === 0) {
         return;
     }
+    const activeUser = this.requestContextService.getActiveUser();
 
     const chatterMessage = new ChatterMessage();
     chatterMessage.messageType = 'audit';
@@ -183,7 +190,7 @@ async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEn
     chatterMessage.messageBody = `${model.displayName} updated`;
     
     if (activeUser) {
-        const userId = typeof activeUser === 'object' ? activeUser.sub : activeUser;
+        const userId = activeUser?.sub;
         chatterMessage.user = { id: userId } as any;
     } else {
         chatterMessage.user = null;
@@ -203,7 +210,7 @@ async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEn
     }
 }
 
-async postAuditMessageOnDelete(entity: any, metadata: EntityMetadata, databaseEntity: any, activeUser: any, messageQueue: boolean = false) {
+async postAuditMessageOnDelete(entity: any, metadata: EntityMetadata, databaseEntity: any, messageQueue: boolean = false) {
     const model = await this.modelMetadataRepo.findOne({
         where: {
             displayName: metadata.name
@@ -225,8 +232,10 @@ async postAuditMessageOnDelete(entity: any, metadata: EntityMetadata, databaseEn
     chatterMessage.coModelName = model.singularName;
     chatterMessage.messageBody = `${model.displayName} deleted`;
     
+    const activeUser = this.requestContextService.getActiveUser();
+
     if (activeUser) {
-        const userId = typeof activeUser === 'object' ? activeUser.sub : activeUser;
+        const userId = activeUser?.sub;
         chatterMessage.user = { id: userId } as any;
     } else {
         chatterMessage.user = null;

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

@@ -158,11 +158,18 @@ export class CrudHelperService {
 
     buildFilterQuery(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string): 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 = [] } = basicFilterDto;
+        const { fields, sort, groupBy, populate = [], populateMedia=[] } = basicFilterDto;
 
         // Normalize the fields, sort, groupBy and populate options i.e (since they can be either a string or an array of strings, when coming from the request)
         const normalizedFields = this.normalize(fields);
         const normalizedPopulate = this.normalize(populate);
+        const normalizedPopulateMedia = this.normalize(populateMedia);
+
+        // if normalizedPopulateMedia, has any nested media paths, then add then to populate excluding the last part
+        const additionalPopulate = this.additionalRelationsRequiredForMediaPopulation(normalizedPopulateMedia);
+        // Add the additional populate relations to the normalizedPopulate, if they are not already present
+        normalizedPopulate.push(...additionalPopulate.filter((relation) => !normalizedPopulate.includes(relation)));
+
         const normalizedSort = this.normalize(sort);
         const normalizedGroupBy = this.normalize(groupBy);
         if (normalizedGroupBy.length > 1) {
@@ -223,6 +230,17 @@ export class CrudHelperService {
         return qb;
     }
 
+    additionalRelationsRequiredForMediaPopulation(normalizedPopulateMedia: string[]) {
+        // Populate relations containing the media field
+        return normalizedPopulateMedia
+        .filter(pm => pm.includes("."))
+        .map((pm) => {
+            const mediaPathParts = pm.split('.');
+            if (mediaPathParts.length <= 1) return pm;
+            return  mediaPathParts.slice(0, -1).join('.');
+        });
+    }
+
     private buildPopulateQuery(normalizedPopulate: string[], entityAlias: string, qb: SelectQueryBuilder<any>) {
         normalizedPopulate.forEach((relation) => {
             this.buildJoinQueryForRelation(qb, entityAlias, relation);

package/src/services/crud.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException } from "@nestjs/common";
+import { BadRequestException, Optional } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { EntityManager, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
@@ -28,14 +28,12 @@ import { SelectionDynamicFieldCrudManager } from "../helpers/field-crud-managers
 import { SelectionStaticFieldCrudManager } from "../helpers/field-crud-managers/SelectionStaticFieldCrudManager";
 import { ShortTextFieldCrudManager } from "../helpers/field-crud-managers/ShortTextFieldCrudManager";
 import { UUIDFieldCrudManager } from "../helpers/field-crud-managers/UUIDFieldCrudManager";
-import { FieldCrudManager } from "../interfaces";
+import { FieldCrudManager, MediaWithFullUrl } from "../interfaces";
 import { CrudHelperService } from "./crud-helper.service";
 import { FileService } from "./file.service";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { ModuleMetadataService } from "./module-metadata.service";
-import { UserContextService } from "./user-context.service";
-import { Optional } from "@nestjs/common";
 const DEFAULT_LIMIT = 10;
 const DEFAULT_OFFSET = 0;
 export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
@@ -52,7 +50,6 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         readonly modelName: string,
         readonly moduleName: string,
         readonly moduleRef: ModuleRef,
-        @Optional() readonly userContextService?: UserContextService
         //We can just have the Model Entity here
     ) { }
 
@@ -68,9 +65,6 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // Check wheather user has create permission for model
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasCreatePermissionOnModel(solidRequestContext.activeUser, model.singularName);
-            if (this.userContextService) {
-                this.userContextService.setUser(solidRequestContext.activeUser);
-            }
             if (!hasPermission) {
                 throw new BadRequestException('Forbidden');
             }
@@ -165,9 +159,6 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasUpdatePermissionOnModel(solidRequestContext.activeUser, model.singularName);
-            if (this.userContextService) {
-                this.userContextService.setUser(solidRequestContext.activeUser);
-            }
             if (!hasPermission) {
                 throw new BadRequestException('Forbidden');
             }
@@ -496,42 +487,85 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return r;
     }
 
-    private async handlePopulateMedia(populateMedia: string[], entities: T[]) {
-        const model = await this.modelMetadataService.findOneBySingularName(this.modelName, {
-            fields: {
-                model: true,
-                mediaStorageProvider: true,
+   private async handlePopulateMedia(populateMedia: string[], entities: T[]) {
+        const model = await this.entityManager.getRepository(ModelMetadata).findOne({
+            where: {
+                singularName: this.modelName,
             },
-            module: true,
+            relations: ['fields', 'fields.mediaStorageProvider', 'fields.model','module'],
         });
 
-        const mediaFields = model.fields.filter(field => (field.type === 'mediaSingle' || field.type === 'mediaMultiple') && populateMedia.includes(field.name)
-        );
-
-        if (mediaFields.length > 0) {
-            // Map over all entities and retrieve media in parallel for each entity
-            await Promise.all(entities.map(async (entity) => {
-                const mediaObj: Record<string, any> = {};
-                // Retrieve media for each media field in parallel
-                const media = await Promise.all(mediaFields.map(async (mediaField) => {
-                    const storageProviderMetadata = mediaField.mediaStorageProvider;
-                    const storageProviderType = storageProviderMetadata.type as MediaStorageProviderType;
-                    const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
-                    const mediaResult = await storageProvider.retrieve(entity, mediaField);
-                    mediaObj[mediaField.name] = mediaResult;
-                }));
-
-                // If media is found, assign to _media field
-                if (media.length > 0) {
-                    entity['_media'] = mediaObj;
-                }
-            }));
+        // Will iterate through every entity &  all populateMedia & call getMediaDetails for each field
+        for (const entity of entities) {
+            const mediaObj: Record<string, any> = {};
+            for (const mediaFieldPath of populateMedia) {
+                mediaObj[mediaFieldPath]  = await this.getMediaObject(mediaFieldPath, model, entity);
+            }
+            entity['_media'] = mediaObj;
+        }
+        return entities;
+   } 
+
+    private async getMediaObject(mediaFieldPath: string, model: ModelMetadata, entity: T) {
+        if (mediaFieldPath.includes('.')) { // mediaFieldPath is a nested field
+            const pathParts = mediaFieldPath.split('.');
+            const mediaFieldMetadata = await this.getFieldMetadataRecursively(pathParts, model.fields);
+            if (!mediaFieldMetadata) {
+                throw new BadRequestException(`Media field ${mediaFieldPath} not found in model ${this.modelName}`);
+            }
+
+            // We can assume that the media field entity model is already populated as part of the entity data
+            const mediaFieldEntity = this.getMediaFieldEntity(entity, pathParts);
+            if (!mediaFieldEntity) {
+                throw new BadRequestException(`Media field path ${mediaFieldPath} is not populated in model ${this.modelName}`);
+            }
+            const mediaWithFullUrl = await this.getMediaWithFullUrl(mediaFieldEntity, mediaFieldMetadata);
+            return mediaWithFullUrl;
+        }
+        else {
+            // mediaFieldPath is a single field
+            const mediaFieldMetadata = model.fields.find(field => field.name === mediaFieldPath);
+            if (!mediaFieldMetadata) {
+                throw new BadRequestException(`Media field ${mediaFieldPath} not found in model ${this.modelName}`);
+            }
+            const mediaWithFullUrl = await this.getMediaWithFullUrl(entity, mediaFieldMetadata);
+            return mediaWithFullUrl;
+        }
+    }
+
+    private getMediaFieldEntity(entity: T, mediaPathParts: string[]) {
+        let mediaFieldEntity = entity;
+        for (let i = 0; i < mediaPathParts.length - 1; i++) {
+            const pathPart = mediaPathParts[i];
+            if (mediaFieldEntity[pathPart]) {
+                mediaFieldEntity = mediaFieldEntity[pathPart];
+            } else {
+                throw new BadRequestException(`Media field ${pathPart} not found in entity ${JSON.stringify(entity)}`);
+            }
         }
+        return mediaFieldEntity;
+    }
+
+    async getMediaWithFullUrl(mediaEntity: any, mediaFieldMetadata: FieldMetadata): Promise<MediaWithFullUrl>{
+            const storageProviderMetadata = mediaFieldMetadata.mediaStorageProvider;
+            const storageProviderType = storageProviderMetadata.type as MediaStorageProviderType;
+            const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
+            const mediaDetails = await storageProvider.retrieve(mediaEntity, mediaFieldMetadata);
+            return mediaDetails as MediaWithFullUrl;
     }
 
     async findOne(id: number, query: any, solidRequestContext: any = {}) {
         const { populate = [], fields = [], populateMedia = [] } = query;
 
+        // const normalizedFields = this.crudHelperService.normalize(fields);
+        const normalizedPopulate = this.crudHelperService.normalize(populate);
+        const normalizedPopulateMedia = this.crudHelperService.normalize(populateMedia);
+
+        // if normalizedPopulateMedia, has any nested media paths, then add then to populate excluding the last part
+        const additionalPopulate = this.crudHelperService.additionalRelationsRequiredForMediaPopulation(normalizedPopulateMedia);
+        // Add the additional populate relations to the normalizedPopulate, if they are not already present
+        normalizedPopulate.push(...additionalPopulate.filter((relation) => !normalizedPopulate.includes(relation)));
+
         const model = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
@@ -541,42 +575,21 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             }
         }
 
-        const entity = await this.repo.findOne({
+        let entity = await this.repo.findOne({
             where: {
                 //@ts-ignore
                 id: id,
             },
-            relations: populate,
+            relations: normalizedPopulate,
             select: fields,
         });
         if (!entity) {
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
         // Populate the entity with the media
-        if (populateMedia.length > 0) {
-            const model = await this.modelMetadataService.findOneBySingularName(this.modelName, {
-                fields: {
-                    model: true,
-                    mediaStorageProvider: true,
-                },
-                module: true,
-            });
-            const mediaObj: Record<string, any> = {};
-            for (const mediaField of model.fields.filter(field => field.type === 'mediaSingle' || field.type === 'mediaMultiple')) {
-                if (!populateMedia.includes(mediaField.name)) {
-                    continue;
-                }
-                const storageProviderMetadata = mediaField.mediaStorageProvider;
-                const storageProviderType = storageProviderMetadata.type as MediaStorageProviderType;
-                const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
-                const mediaResult = await storageProvider.retrieve(entity, mediaField);
-                let obj = { [mediaField.name]: mediaResult }
-                mediaObj[mediaField.name] = mediaResult;
-                // entity['media'][mediaField.name] = await storageProvider.retrieve(entity, mediaField);
-            }
-            if (Object.keys(mediaObj).length > 0) {
-                entity['_media'] = mediaObj;
-            }
+        if (normalizedPopulateMedia.length > 0) {
+            const populatedEntities = await this.handlePopulateMedia(normalizedPopulateMedia, [entity]);
+            entity = populatedEntities[0] as Awaited<T>;
         }
         return entity;
     }
@@ -775,4 +788,37 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
     }
 
 
+    async getFieldMetadataRecursively(pathParts: string[], fields: FieldMetadata[]) {
+        if (!pathParts || pathParts.length === 0) {
+            throw new BadRequestException('Path parts cannot be empty');
+        }
+    
+        const [currentPart, ...remainingParts] = pathParts;
+        const field = fields.find(field => field.name === currentPart);
+    
+        if (!field) {
+            throw new BadRequestException(`Field ${currentPart} not found in model ${this.modelName}`);
+        }
+    
+        // Base case: last part, return the field
+        if (remainingParts.length === 0) {
+            return field;
+        }
+    
+        if (!field.relationCoModelSingularName) {
+            throw new BadRequestException(`Field ${field.name} does not define a relationCoModelSingularName`);
+        }
+    
+        const relationCoModel = await this.entityManager.getRepository(ModelMetadata).findOne({
+            where: { singularName: field.relationCoModelSingularName },
+            relations: ['fields', 'fields.mediaStorageProvider', 'fields.model'],
+        });
+    
+        if (!relationCoModel) {
+            throw new BadRequestException(`Model ${field.relationCoModelSingularName} not found`);
+        }
+    
+        return this.getFieldMetadataRecursively(remainingParts, relationCoModel.fields);
+    }
 }
+

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

@@ -503,6 +503,7 @@ export class FieldMetadataService {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.bigint:
@@ -521,7 +522,8 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             // case SolidFieldType.float:
@@ -560,7 +562,8 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.shortText:
@@ -582,7 +585,8 @@ export class FieldMetadataService {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "isUserKey"
+                    "isUserKey",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.longtext:
@@ -665,7 +669,8 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.date:
@@ -684,7 +689,8 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.datetime:
@@ -703,7 +709,8 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.time:
@@ -722,7 +729,8 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.relation:
@@ -750,7 +758,8 @@ export class FieldMetadataService {
                     "columnName",
                     "relationJoinTableName",
                     "isRelationManyToManyOwner",
-                    "relationFieldFixedFilter"
+                    "relationFieldFixedFilter",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.mediaSingle:
@@ -812,7 +821,8 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.password:
@@ -855,7 +865,8 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.selectionDynamic:
@@ -877,8 +888,8 @@ export class FieldMetadataService {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "isUserKey"
-
+                    "isUserKey",
+                    "enableAuditTracking"
                 ];
             case SolidFieldType.computed:
                 return [