@solidstarters/solid-core 1.2.63 → 1.2.64

package/package.json

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

package/src/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/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,13 @@ 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
@@ -496,42 +495,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 +583,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 +796,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/1.js

@@ -1,6 +0,0 @@
-1. Do i need to create a storeStreams method for aws service too?
-    - Handle later
-2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
-    - startExport should either return the data or return the transaction id
-3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
-    - show the userKey