@solidstarters/solid-core 1.2.38 → 1.2.40

package/src/services/media.service.ts

@@ -1,292 +1,182 @@
-import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
-import { InjectRepository } from "@nestjs/typeorm";
-import { Repository, SelectQueryBuilder } from "typeorm";
-import { Media } from "../entities/media.entity";
-import { ModelMetadata } from "../entities/model-metadata.entity";
-import { MediaStorageProviderMetadata } from "../entities/media-storage-provider-metadata.entity";
-import { FieldMetadata } from "../entities/field-metadata.entity";
-import { BasicFilterDto } from "../dtos/basic-filters.dto";
-import { CrudHelperService } from "./crud-helper.service";
-import { FileService } from "src/services/file.service";
-import { ConfigService } from "@nestjs/config";
-import { MediaStorageProviderType } from "../dtos/create-media-storage-provider-metadata.dto";
-import { FileStorageProvider } from "./mediaStorageProviders/file-storage-provider";
-import { FileS3StorageProvider } from "./mediaStorageProviders/file-s3-storage-provider";
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { EntityManager, Repository } 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 { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
+import { Media } from 'src/entities/media.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { getMediaStorageProvider } from "./mediaStorageProviders";
+import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
 
-@Injectable()
-export class MediaService {
-    constructor(
-        @InjectRepository(Media)
-        private readonly mediaRepo: Repository<Media>,
-        @InjectRepository(ModelMetadata)
-        private readonly modelMetadataRepo: Repository<ModelMetadata>,
-        @InjectRepository(MediaStorageProviderMetadata)
-        private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
-        @InjectRepository(FieldMetadata)
-        private readonly fieldMetadataRepo: Repository<FieldMetadata>,
-        private readonly crudHelperService: CrudHelperService,
-        readonly fileService: FileService,
-        // @Inject(radixConfig.KEY)
-        // private readonly radixConfiguration: ConfigType<typeof radixConfig>,
-        private readonly configService: ConfigService,
-    ) { }
-
-    async findMany(basicFilterDto: BasicFilterDto) {
-        const alias = 'media';
-        // Extract the required keys from the input query
-        let { limit, offset } = basicFilterDto;
-
-        // Create above query on pincode table using query builder
-        var qb: SelectQueryBuilder<Media> = this.mediaRepo.createQueryBuilder(alias)
-        qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
-
-        // Get the records and the count
-        const [entities, count] = await qb.getManyAndCount();
 
-        const currentPage = Math.floor(offset / limit) + 1;
-        const totalPages = Math.ceil(count / limit);
-
-        const nextPage = currentPage < totalPages ? currentPage + 1 : null;
-        const prevPage = currentPage > 1 ? currentPage - 1 : null;
-
-        const r = {
-            meta: {
-                totalRecords: count,
-                currentPage: currentPage,
-                nextPage: nextPage,
-                prevPage: prevPage,
-                totalPages: totalPages,
-                perPage: +limit,
-            },
-            records: entities
-        };
-        return r
-    }
-
-    async findOne(id: number, relations = {}) {
-        const lov = await this.mediaRepo.findOne({
-            where: {
-                id: id,
-            },
-            relations: relations,
-        });
-        if (!lov) {
-            throw new NotFoundException(`Media with #${id} not found`);
+@Injectable()
+export class MediaService extends CRUDService<Media> {
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    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>,
+    readonly moduleRef: ModuleRef,
+
+
+
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'media', 'solid-core', moduleRef);
+  }
+  async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
+    const data = await super.find(basicFilterDto, solidRequestContext);
+    if (data.records) {
+      data.records.forEach((media: Media) => {
+        if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
+          media.relativeUri = `${process.env.BASE_URL}/${this.getFileSysytemFullFilePath(media.relativeUri)}`;
+        } else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
+          media.relativeUri = this.getAwsS3FullFilePath(
+            media.relativeUri,
+            media.mediaStorageProviderMetadata.bucketName,
+            media.mediaStorageProviderMetadata.region
+          );
         }
-        return lov;
+      });
     }
-
-    async create(createDto: any) {
-        createDto['fieldMetadata'] = await this.fieldMetadataRepo.findOne({
-            where: {
-                id: createDto['fieldMetadataId']
-            },
-        });
-        createDto['modelMetadata'] = await this.modelMetadataRepo.findOne({
-            where: {
-                id: createDto['modelMetadataId']
-            },
-        });
-        createDto['mediaStorageProviderMetadata'] = await this.mediaStorageProviderMetadataRepo.findOne({
-            where: {
-                id: createDto['mediaStorageProviderMetadataId']
-            },
+    if (data.groupRecords) {
+      data.groupRecords.forEach((group) => {
+        group.groupData.records.forEach((media) => {
+            if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
+                media.relativeUri = `${process.env.BASE_URL}/${this.getFileSysytemFullFilePath(media.relativeUri)}`;
+            }
+            else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
+                media.relativeUri = this.getAwsS3FullFilePath(media.relativeUri, media.mediaStorageProviderMetadata.bucketName, media.mediaStorageProviderMetadata.region);
+            }
         });
-        const media = this.mediaRepo.create(createDto);
-        return this.mediaRepo.save(media);
+    });
     }
+    return data
+  }
+  async upload(createDto: any, files: Array<Express.Multer.File>) {
 
-    async upload(createDto: any, files: Array<Express.Multer.File>) {
-
-        if (!files) {
-            throw new NotFoundException(`File Not Found`);
-
-        }
-        const savedMedias = [];
-        for (let i = 0; i < files.length; i++) {
-
-
-            createDto['fieldMetadata'] = await this.fieldMetadataRepo.findOne({
-                where: {
-                    id: createDto['fieldMetadataId']
-                },
-            });
-            createDto['modelMetadata'] = await this.modelMetadataRepo.findOne({
-                where: {
-                    id: createDto['modelMetadataId']
-                },
-            });
-            createDto['mediaStorageProviderMetadata'] = await this.mediaStorageProviderMetadataRepo.findOne({
-                where: {
-                    id: createDto['mediaStorageProviderMetadataId']
-                },
-            });
+    if (!files) {
+      throw new NotFoundException(`File Not Found`);
 
-            const file = files[i];
-
-            switch (createDto.mediaStorageProviderMetadata.type) {
-                case MediaStorageProviderType.Filesystem:
-                    const fileStoragePath = this.getFileSysytemFullFilePath(this.getFileName(file));
-                    await this.fileService.copyFile(file.path, fileStoragePath);
-                    createDto['relativeUri'] = this.getFileName(file);
-                    break;
-                case MediaStorageProviderType.AwsS3:
-                    const fileName = this.getFileName(file);
-                    let awsFileUrl;
-                    if (createDto.mediaStorageProviderMetadata.isPublic === true) {
-                        awsFileUrl = await this.fileService.copyToS3(file.path, file.mimetype, fileName, createDto.mediaStorageProviderMetadata.bucketName,);
-                    } else {
-                        awsFileUrl = await this.fileService.copyToS3WithPublic(file.path, file.mimetype, fileName, createDto.mediaStorageProviderMetadata.bucketName,);
-                    }
-                    // createDto['relativeUri'] = this.getAwsS3FullFilePath(awsFileUrl, createDto.mediaStorageProviderMetadata.bucketName, createDto.mediaStorageProviderMetadata.region);
-                    createDto['relativeUri'] = awsFileUrl
-                    break;
-                default:
-                    break;
-            }
-            await this.fileService.deleteFile(file.path);
-
-            const media = this.mediaRepo.create(createDto);
-            const savedMedia = await this.mediaRepo.save(media);
-            savedMedias.push(savedMedia)
-        }
-        return savedMedias
     }
-
-    async deleteMany(ids: number[]): Promise<any> {
-        if (!ids || ids.length === 0) {
-            throw new Error('At least one ID is required for deletion');
-        }
-        const removedEntities = [];
-        for (let i = 0; i < ids.length; i++) {
-            const id = ids[i]
-            const entity = await this.modelMetadataRepo.findOne({
-                where: {
-                    //@ts-ignore
-                    id: id,
-                }
-            });
-            // if (!entity) {
-            //     throw new Error(`Entity with id ${id} not found`);
-            // }
-            removedEntities.push(await this.modelMetadataRepo.remove(entity));
-        }
-
-        return removedEntities
+    const savedMedias = [];
+    for (let i = 0; i < files.length; i++) {
+
+
+      createDto['fieldMetadata'] = await this.fieldMetadataRepo.findOne({
+        where: {
+          id: createDto['fieldMetadataId']
+        },
+      });
+      createDto['modelMetadata'] = await this.modelMetadataRepo.findOne({
+        where: {
+          id: createDto['modelMetadataId']
+        },
+      });
+      createDto['mediaStorageProviderMetadata'] = await this.mediaStorageProviderMetadataRepo.findOne({
+        where: {
+          id: createDto['mediaStorageProviderMetadataId']
+        },
+      });
+
+      const file = files[i];
+
+      switch (createDto.mediaStorageProviderMetadata.type) {
+        case MediaStorageProviderType.Filesystem:
+          const fileStoragePath = this.getFileSysytemFullFilePath(this.getFileName(file));
+          await this.fileService.copyFile(file.path, fileStoragePath);
+          createDto['relativeUri'] = this.getFileName(file);
+          break;
+        case MediaStorageProviderType.AwsS3:
+          const fileName = this.getFileName(file);
+          let awsFileUrl;
+          if (createDto.mediaStorageProviderMetadata.isPublic === true) {
+            awsFileUrl = await this.fileService.copyToS3(file.path, file.mimetype, fileName, createDto.mediaStorageProviderMetadata.bucketName,);
+          } else {
+            awsFileUrl = await this.fileService.copyToS3WithPublic(file.path, file.mimetype, fileName, createDto.mediaStorageProviderMetadata.bucketName,);
+          }
+          // createDto['relativeUri'] = this.getAwsS3FullFilePath(awsFileUrl, createDto.mediaStorageProviderMetadata.bucketName, createDto.mediaStorageProviderMetadata.region);
+          createDto['relativeUri'] = awsFileUrl
+          break;
+        default:
+          break;
+      }
+      await this.fileService.deleteFile(file.path);
+
+      const media = this.repo.create(createDto);
+      const savedMedia = await this.repo.save(media);
+      savedMedias.push(savedMedia)
     }
-
-    async remove(id: number) {
-        // const lov = await this.findOne(id);
-        const media = await this.mediaRepo.findOne({
-            where: {
-                id: id,
-            },
-            relations: ['mediaStorageProviderMetadata', 'fieldMetadata', 'fieldMetadata.model','fieldMetadata.mediaStorageProvider'],
-        });
-        const modelEntity = await this.modelMetadataRepo.findOne({
-            where: {
-                id: media.entityId,
-            }
-        }
-        );
-        // if (media.mediaStorageProviderMetadata.type === 'filesystem') {
-        //     const fileStorageProvider = new FileStorageProvider(this.configService, this.fileService, this);
-
-        //     await fileStorageProvider.delete(media, media.fieldMetadata);
-
-        // } else if (media.mediaStorageProviderMetadata.type === 'aws-s3') {
-        //     const fileStorageProvider = new FileS3StorageProvider(this.configService, this.fileService, this);
-        //     await fileStorageProvider.delete(media, media.fieldMetadata);
-
-        // } else {
-        // }
-        const storageProviderType = media.mediaStorageProviderMetadata.type as MediaStorageProviderType;
-        const storageProvider = getMediaStorageProvider(this.configService, this.fileService, this, storageProviderType);
-        await storageProvider.delete(modelEntity, media.fieldMetadata);
-
-        return this.mediaRepo.remove(media);
+    return savedMedias
+  }
+
+  async remove(id: number) {
+    // const lov = await this.findOne(id);
+    const media = await this.repo.findOne({
+      where: {
+        id: id,
+      },
+      relations: ['mediaStorageProviderMetadata', 'fieldMetadata', 'fieldMetadata.model', 'fieldMetadata.mediaStorageProvider'],
+    });
+    const modelEntity = await this.modelMetadataRepo.findOne({
+      where: {
+        id: media.entityId,
+      }
     }
+    );
+    // if (media.mediaStorageProviderMetadata.type === 'filesystem') {
+    //     const fileStorageProvider = new FileStorageProvider(this.configService, this.fileService, this);
 
-    async delete(id: number) {
-        if (!id) {
-            throw new BadRequestException('Id is required for update');
-        }
-        const entity = await this.mediaRepo.findOne({
-            where: {
-                //@ts-ignore
-                id: id,
-            }
-        });
-        if (!entity) {
-            throw new NotFoundException(`Entity with id ${id} not found`);
-        }
-        return this.mediaRepo.remove(entity);
-    }
+    //     await fileStorageProvider.delete(media, media.fieldMetadata);
 
-    // async deleteByEntityId(entityId: number) {
-    //     if (!entityId) {
-    //         throw new BadRequestException('Entity id is required for deletion');
-    //     }
-    //     const entities = await this.mediaRepo.find({
-    //         where: {
-    //             entityId: entityId,
-    //         }
-    //     });
-    //     return this.mediaRepo.remove(entities);
-    // }
+    // } else if (media.mediaStorageProviderMetadata.type === 'aws-s3') {
+    //     const fileStorageProvider = new FileS3StorageProvider(this.configService, this.fileService, this);
+    //     await fileStorageProvider.delete(media, media.fieldMetadata);
 
-    // async findByEntityId(entityId: number) {
-    //     return this.mediaRepo.find({
-    //         where: {
-    //             entityId: entityId,
-    //         }
-    //     });
+    // } else {
     // }
+    const storageProviderType = media.mediaStorageProviderMetadata.type as MediaStorageProviderType;
+    const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
+    await storageProvider.delete(modelEntity, media.fieldMetadata);
 
-    async findByEntityIdAndFieldIdAndModelMetadataId(entityId: number, fieldMetadataId: number, modelMetadataId: number, relations = {}) {
-        return await this.mediaRepo.find({
-            where: {
-                modelMetadata: {
-                    id: modelMetadataId
-                },
-                fieldMetadata: {
-                    id: fieldMetadataId
-                },
-                entityId: entityId,
-            },
-            relations: relations,
-        });
-    }
-
-    async deleteByEntityIdAndFieldIdAndModelMetadataId(entityId: number, fieldMetadataId: number, modelMetadataId: number) {
-        const entities = await this.mediaRepo.find({
-            where: {
-                modelMetadata: {
-                    id: modelMetadataId
-                },
-                fieldMetadata: {
-                    id: fieldMetadataId
-                },
-                entityId: entityId,
-            }
-        });
-        return this.mediaRepo.remove(entities);
-    }
+    return this.repo.remove(media);
+  }
+  //TODO: Move this to a app builder config
 
-    //TODO: Move this to a app builder config
+  private getFileSysytemFullFilePath(fileName: string): string {
+    return `${this.configService.get('app-builder.fileStorageDir')}/${fileName}`;
+  }
 
-    private getFileSysytemFullFilePath(fileName: string): string {
-        return `${this.configService.get('app-builder.fileStorageDir')}/${fileName}`;
-    }
 
+  private getAwsS3FullFilePath(awsMediaurl: string, bucketName: string, regionName: string): string {
+    // https://lunarismedia.s3.ap-south-1.amazonaws.com/LUNARIS_CP_REGISTRATION_CREATIVE.jpg
+    return `https://${bucketName}.s3.${regionName}.amazonaws.com/${awsMediaurl}`;
+  }
 
-    private getAwsS3FullFilePath(awsMediaurl: string, bucketName: string, regionName: string): string {
-        // https://lunarismedia.s3.ap-south-1.amazonaws.com/LUNARIS_CP_REGISTRATION_CREATIVE.jpg
-        return `https://${bucketName}.s3.${regionName}.amazonaws.com/${awsMediaurl}`;
-    }
+  private getFileName(file: Express.Multer.File): string {
+    return `${file.filename}-${file.originalname}`;
+  }
 
-    private getFileName(file: Express.Multer.File): string {
-        return `${file.filename}-${file.originalname}`;
-    }
-}
+}

package/src/services/mediaStorageProviders/file-s3-storage-provider.ts

@@ -1,13 +1,14 @@
-import { Inject, Logger } from "@nestjs/common";
+import { Inject, Injectable, Logger } from "@nestjs/common";
 import { ConfigService, ConfigType } from "@nestjs/config";
 import { MediaStorageProvider } from "src/interfaces";
 import { FileService } from "src/services/file.service";
-import { MediaService } from "../media.service";
 import { Media } from "src/entities/media.entity";
 import { CommonEntity } from "src/entities/common.entity";
 import { FieldMetadata } from "src/entities/field-metadata.entity";
 import appBuilderConfig from "src/config/app-builder.config";
+import { MediaRepository } from "src/repository/media.repository";
 
+@Injectable()
 export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
     private logger = new Logger(FileS3StorageProvider.name);
 
@@ -16,13 +17,13 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         // private readonly appBuilderConfiguration: ConfigType<typeof appBuilderConfig>,
         private readonly configService: ConfigService,
         readonly fileService: FileService,
-        readonly mediaService: MediaService
+        readonly mediaRepository: MediaRepository
     ) { }
     async retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
         if (!(entity instanceof CommonEntity)) {
             throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
-        const media = await this.mediaService.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
+        const media = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
         // Add the full URL to the media
         media.forEach(m => {
             m['_full_url'] = this.getFullFilePath(m);
@@ -47,7 +48,7 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
             await this.fileService.deleteFile(file.path);
 
             // Create an entry in the media table
-            const mediaEntity = await this.mediaService.create({
+            const mediaEntity = await this.mediaRepository.createMedia({
                 entityId: entity.id,
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: awsFileUrl,
@@ -67,8 +68,8 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         if (!(entity instanceof CommonEntity)) {
             throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
-        const existingMedia = await this.mediaService.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id,['mediaStorageProviderMetadata']);
-        this.mediaService.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
+        const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id,['mediaStorageProviderMetadata']);
+        this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
         existingMedia.forEach(media => {
             this.fileService.deleteFromS3(media.relativeUri, mediaFieldMetadata.mediaStorageProvider.bucketName); //TODO
         });

package/src/services/mediaStorageProviders/file-storage-provider.ts

@@ -1,13 +1,13 @@
-import { Inject, Logger } from "@nestjs/common";
+import { Inject, Injectable, Logger } from "@nestjs/common";
 import { ConfigService, ConfigType } from "@nestjs/config";
 import { MediaStorageProvider } from "src/interfaces";
 import { FileService } from "src/services/file.service";
-import { MediaService } from "../media.service";
 import { Media } from "src/entities/media.entity";
 import { CommonEntity } from "src/entities/common.entity";
 import { FieldMetadata } from "src/entities/field-metadata.entity";
-import appBuilderConfig from "src/config/app-builder.config";
+import { MediaRepository } from "src/repository/media.repository";
 
+@Injectable()
 export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     private logger = new Logger(FileStorageProvider.name);
 
@@ -16,13 +16,15 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
         // private readonly appBuilderConfiguration: ConfigType<typeof appBuilderConfig>,
         private readonly configService: ConfigService, 
         readonly fileService: FileService,
-        readonly mediaService: MediaService
+        readonly mediaRepository: MediaRepository
+    
     ) { }
+    
     async retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
         if (!(entity instanceof CommonEntity)) {
             throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
-        const media = await this.mediaService.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
+        const media = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
         // Add the full URL to the media
         media.forEach(m => {
             m['_full_url'] = `${process.env.BASE_URL}/${this.getFullFilePath(m.relativeUri)}`;
@@ -42,7 +44,7 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
             this.fileService.deleteFile(file.path);
 
             // Create an entry in the media table
-            const mediaEntity = await this.mediaService.create({
+            const mediaEntity = await this.mediaRepository.createMedia({
                 entityId: entity.id,
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: this.getFileName(file),
@@ -62,8 +64,8 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
         if (!(entity instanceof CommonEntity)) {
             throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
-        const existingMedia = await this.mediaService.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id,['mediaStorageProviderMetadata']);
-        this.mediaService.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
+        const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id,['mediaStorageProviderMetadata']);
+        this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
         existingMedia.forEach(media => {
             this.fileService.deleteFile(this.getFullFilePath(media.relativeUri));
         });

package/src/services/mediaStorageProviders/index.ts

@@ -1,22 +1,16 @@
+import { ModuleRef } from "@nestjs/core";
 import { MediaStorageProviderType } from "src/dtos/create-media-storage-provider-metadata.dto";
-import { FileStorageProvider } from "./file-storage-provider";
-import { MediaStorageProvider } from "src/interfaces";
-import { ConfigService } from "@nestjs/config";
-import { FileService } from "src/services/file.service";
-import { MediaService } from "../media.service";
-import { CommonEntity } from "src/entities/common.entity";
 import { FileS3StorageProvider } from "./file-s3-storage-provider";
+import { FileStorageProvider } from "./file-storage-provider";
 
-export function getMediaStorageProvider<T>(
-    configService: ConfigService, 
-    fileService: FileService, 
-    mediaService: MediaService, 
-    type: MediaStorageProviderType): MediaStorageProvider<T> {
+export async function getMediaStorageProvider<T>(
+    moduleRef: ModuleRef,
+    type: MediaStorageProviderType): Promise<any> {
     switch(type) {
         case MediaStorageProviderType.Filesystem:
-            return new FileStorageProvider<T>(configService, fileService, mediaService);
+            return await moduleRef.get(FileStorageProvider,{ strict: false });
         case MediaStorageProviderType.AwsS3:
-            return new FileS3StorageProvider<T>(configService, fileService, mediaService);
+            return await moduleRef.get(FileS3StorageProvider,{ strict: false });
         default:
             throw new Error(`Unknown media storage provider type ${type}`);
     }

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

@@ -1,13 +1,11 @@
 import { Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { DiscoveryService } from "@nestjs/core";
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { EntityManager, Repository } from 'typeorm';
 import { CRUDService } from 'src/services/crud.service';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { MediaStorageProviderMetadataService } from 'src/services/media-storage-provider-metadata.service';
 import { ConfigService } from '@nestjs/config';
-import { MediaService } from "src/services/media.service";
 import { FileService } from "src/services/file.service";
 import { CrudHelperService } from "src/services/crud-helper.service";
 
@@ -23,18 +21,18 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
   constructor(
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
-    readonly mediaStorageProviderService: MediaStorageProviderMetadataService,
     readonly configService: ConfigService,
     readonly fileService: FileService,
-    readonly mediaService: MediaService,
     readonly discoveryService: DiscoveryService,
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     @InjectRepository(MenuItemMetadata, 'default')
     readonly repo: Repository<MenuItemMetadata>,
+    readonly moduleRef: ModuleRef
+
   ) {
-    super(modelMetadataService, moduleMetadataService, mediaStorageProviderService, configService, fileService, mediaService, discoveryService, crudHelperService, entityManager, repo, 'menuItemMetadata', 'app-builder');
+    super(modelMetadataService, moduleMetadataService, configService, fileService,  discoveryService, crudHelperService, entityManager, repo, 'menuItemMetadata', 'app-builder',moduleRef);
   }