@solidstarters/solid-core 1.2.0

package/src/services/media-storage-provider-metadata.service.ts

@@ -0,0 +1,152 @@
+import { Injectable, NotFoundException } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository, SelectQueryBuilder } from "typeorm";
+import { MediaStorageProviderMetadata } from "../entities/media-storage-provider-metadata.entity";
+import { BasicFilterDto } from "../dtos/basic-filters.dto";
+import { CrudHelperService } from "./crud-helper.service";
+import { UpdateMediaStorageProviderMetadataDto } from "../dtos/update-media-storage-provider.dto";
+
+@Injectable()
+export class MediaStorageProviderMetadataService {
+    constructor(
+        @InjectRepository(MediaStorageProviderMetadata)
+        private readonly mediaStorageProviderRepo: Repository<MediaStorageProviderMetadata>,
+        private readonly crudHelperService: CrudHelperService
+    ) { }
+
+    async findMany(basicFilterDto: BasicFilterDto) {
+        const alias = 'mediaStorageProviderMetadata';
+        // Extract the required keys from the input query
+        let { limit, offset, populateMedia } = basicFilterDto;
+
+        // Create above query on pincode table using query builder
+        var qb: SelectQueryBuilder<MediaStorageProviderMetadata> = this.mediaStorageProviderRepo.createQueryBuilder(alias)
+        qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+
+        // 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.mediaStorageProviderRepo.findOne({
+            where: {
+                id: id,
+            },
+            relations: relations,
+        });
+        if (!lov) {
+            throw new NotFoundException(`Media Storage Provider with #${id} not found`);
+        }
+        return lov;
+    }
+
+    async findOneByUserKey(name: string, relations = {}) {
+        const lov = await this.mediaStorageProviderRepo.findOne({
+            where: {
+                name: name,
+            },
+            relations: relations,
+        });
+        // if (!lov) {
+        //     throw new NotFoundException(`Media Storage Provider with #${name} not found`);
+        // }
+        return lov;
+    }
+
+    async findOnebyType(type: string, relations = {}) {
+        const lov = await this.mediaStorageProviderRepo.findOne({
+            where: {
+                type: type,
+            },
+            relations: relations,
+        });
+        if (!lov) {
+            throw new NotFoundException(`Media Storage Provider with #${type} not found`);
+        }
+        return lov;
+    }
+
+    async create(createDto: any) {
+        const lov = this.mediaStorageProviderRepo.create(createDto);
+        return this.mediaStorageProviderRepo.save(lov);
+    }
+
+    async upsert(updateMediaStorageProviderDto: any) {
+        // First check if module already exists using name
+        const existingMediaStorageProvider = await this.mediaStorageProviderRepo.findOne({
+            where: {
+                name: updateMediaStorageProviderDto.name
+            }
+        })
+
+        // if found
+        if (existingMediaStorageProvider) {
+            const updatedMediaStorageProviderDto = { ...existingMediaStorageProvider, ...updateMediaStorageProviderDto };
+            return this.mediaStorageProviderRepo.save(updatedMediaStorageProviderDto);
+        }
+        // if not found - create new 
+        else {
+            const moduleMetadata = this.mediaStorageProviderRepo.create(updateMediaStorageProviderDto);
+            return this.mediaStorageProviderRepo.save(moduleMetadata);
+        }
+    }
+
+    async update(id: number, updateMediaStorageProviderMetadataDto: UpdateMediaStorageProviderMetadataDto) {
+
+        const entity = await this.mediaStorageProviderRepo.preload({
+            id,
+            ...updateMediaStorageProviderMetadataDto,
+        });
+
+        if (!entity) {
+            throw new NotFoundException(`Module ${id} not found`);
+        }
+        return this.mediaStorageProviderRepo.save(entity);
+    }
+
+    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.mediaStorageProviderRepo.findOne({
+                where: {
+                    //@ts-ignore
+                    id: id,
+                }
+            });
+            // if (!entity) {
+            //     throw new Error(`Entity with id ${id} not found`);
+            // }
+            removedEntities.push(await this.mediaStorageProviderRepo.remove(entity));
+        }
+
+        return removedEntities
+    }
+
+    async remove(id: number) {
+        const lov = await this.findOne(id);
+        return this.mediaStorageProviderRepo.remove(lov);
+    }
+}

package/src/services/media.service.ts

@@ -0,0 +1,262 @@
+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";
+
+@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`);
+        }
+        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']
+            },
+        });
+        const media = this.mediaRepo.create(createDto);
+        return this.mediaRepo.save(media);
+    }
+
+    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']
+                },
+            });
+
+            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
+    }
+
+    async remove(id: number) {
+        const lov = await this.findOne(id);
+        return this.mediaRepo.remove(lov);
+    }
+
+    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);
+    }
+
+    // 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);
+    // }
+
+    // async findByEntityId(entityId: number) {
+    //     return this.mediaRepo.find({
+    //         where: {
+    //             entityId: entityId,
+    //         }
+    //     });
+    // }
+
+    async findByEntityIdAndFieldIdAndModelMetadataId(entityId: number, fieldMetadataId: number, modelMetadataId: number, relations = {}) {
+        return 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);
+    }
+
+    //TODO: Move this to a app builder config
+
+    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 getFileName(file: Express.Multer.File): string {
+        return `${file.filename}-${file.originalname}`;
+    }
+}

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

@@ -0,0 +1,83 @@
+import { Inject, 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";
+
+export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
+    private logger = new Logger(FileS3StorageProvider.name);
+
+    constructor(
+        // @Inject(appBuilderConfig.KEY)
+        // private readonly appBuilderConfiguration: ConfigType<typeof appBuilderConfig>,
+        private readonly configService: ConfigService,
+        readonly fileService: FileService,
+        readonly mediaService: MediaService
+    ) { }
+    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']);
+        // Add the full URL to the media
+        media.forEach(m => {
+            m['_full_url'] = this.getFullFilePath(m);
+        });
+        return media;
+    }
+
+    async store(files: Express.Multer.File[], 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 result: Media[] = [];
+        files.forEach(async (file) => {
+            const fileName = this.getFileName(file);
+            // Store the file in the configured S3 Bucket
+            let awsFileUrl;
+            if (mediaFieldMetadata.mediaStorageProvider.isPublic === true) {
+                awsFileUrl = await this.fileService.copyToS3(file.path, file.mimetype, fileName, mediaFieldMetadata.mediaStorageProvider.bucketName,);
+            } else {
+                awsFileUrl = await this.fileService.copyToS3WithPublic(file.path, file.mimetype, fileName, mediaFieldMetadata.mediaStorageProvider.bucketName,);
+            }
+            await this.fileService.deleteFile(file.path);
+
+            // Create an entry in the media table
+            const mediaEntity = await this.mediaService.create({
+                entityId: entity.id,
+                modelMetadataId: mediaFieldMetadata.model.id,
+                relativeUri: awsFileUrl,
+                mediaStorageProviderMetadataId: mediaFieldMetadata.mediaStorageProvider.id,
+                fieldMetadataId: mediaFieldMetadata.id
+            }) as unknown as Media;
+            result.push(mediaEntity);
+            this.logger.debug(`Stored media with`, mediaEntity);
+        });
+        return result;
+    }
+
+    async delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void> {
+        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);
+        this.mediaService.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
+        existingMedia.forEach(media => {
+            this.fileService.deleteFromS3(media.relativeUri, mediaFieldMetadata.mediaStorageProvider.bucketName); //TODO
+        });
+    }
+
+    //TODO: Move this to a app builder config
+    private getFullFilePath(media: Media): string {
+        // https://lunarismedia.s3.ap-south-1.amazonaws.com/LUNARIS_CP_REGISTRATION_CREATIVE.jpg
+        return `https://${media.mediaStorageProviderMetadata.bucketName}.s3.${this.configService.get('S3_AWS_REGION_NAME')}.amazonaws.com/${media.relativeUri}`;
+    }
+
+    private getFileName(file: Express.Multer.File): string {
+        return `${file.filename}-${file.originalname}`;
+    }
+}

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

@@ -0,0 +1,76 @@
+import { Inject, 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";
+
+export class FileStorageProvider<T> implements MediaStorageProvider<T> {
+    private logger = new Logger(FileStorageProvider.name);
+
+    constructor(
+        // @Inject(appBuilderConfig.KEY)
+        // private readonly appBuilderConfiguration: ConfigType<typeof appBuilderConfig>,
+        private readonly configService: ConfigService, 
+        readonly fileService: FileService,
+        readonly mediaService: MediaService
+    ) { }
+    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']);
+        // Add the full URL to the media
+        media.forEach(m => {
+            m['_full_url'] = this.getFullFilePath(m.relativeUri);
+        });
+        return media;
+    }
+
+    async store(files: Express.Multer.File[], 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 result: Media[] = [];
+        files.forEach(async (file) => {
+            // Store the file in the configured file storage directory
+            const fileStoragePath = this.getFullFilePath(this.getFileName(file));
+            this.fileService.copyFile(file.path, fileStoragePath);
+            this.fileService.deleteFile(file.path);
+
+            // Create an entry in the media table
+            const mediaEntity = await this.mediaService.create({
+                entityId: entity.id,
+                modelMetadataId: mediaFieldMetadata.model.id,
+                relativeUri: this.getFileName(file),
+                mediaStorageProviderMetadataId: mediaFieldMetadata.mediaStorageProvider.id,
+                fieldMetadataId: mediaFieldMetadata.id
+            }) as unknown as Media;
+            result.push(mediaEntity);
+            this.logger.debug(`Stored media with`, mediaEntity);
+        });
+        return result;
+    }
+
+    async delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void> {
+        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);
+        this.mediaService.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
+        existingMedia.forEach(media => {
+            this.fileService.deleteFile(this.getFullFilePath(media.relativeUri));
+        });
+    }
+
+    private getFullFilePath(fileName: string): string {
+        return `${this.configService.get('app-builder.fileStorageDir')}/${fileName}`;
+    }
+
+    private getFileName(file: Express.Multer.File): string {
+        return `${file.filename}-${file.originalname}`;
+    }
+}

package/src/services/mediaStorageProviders/index.ts

@@ -0,0 +1,23 @@
+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";
+
+export function getMediaStorageProvider<T>(
+    configService: ConfigService, 
+    fileService: FileService, 
+    mediaService: MediaService, 
+    type: MediaStorageProviderType): MediaStorageProvider<T> {
+    switch(type) {
+        case MediaStorageProviderType.Filesystem:
+            return new FileStorageProvider<T>(configService, fileService, mediaService);
+        case MediaStorageProviderType.AwsS3:
+            return new FileS3StorageProvider<T>(configService, fileService, mediaService);
+        default:
+            throw new Error(`Unknown media storage provider type ${type}`);
+    }
+}