@solidstarters/solid-core 1.2.67 → 1.2.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.67",
+  "version": "1.2.69",
   "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/dtos/create-field-metadata.dto.ts

@@ -409,4 +409,9 @@ export class CreateFieldMetadataDto {
   @IsOptional()
   @IsBoolean()
   enableAuditTracking?: boolean;
+
+  @IsOptional()
+  @ApiProperty({ description: 'Is MultiSelect Field', })
+  @IsBoolean()
+  isMultiSelect: boolean;
 }

package/src/entities/field-metadata.entity.ts

@@ -155,4 +155,7 @@ export class FieldMetadata extends CommonEntity {
 
     @Column({ name: 'enable_audit_tracking', default: false })
     enableAuditTracking: boolean;
+
+    @Column({ name: "is_multiSelect", default: false })
+    isMultiSelect: boolean;
 }

package/src/helpers/field-crud-managers/SelectionDynamicFieldCrudManager.ts

@@ -10,6 +10,7 @@ export interface SelectionDynamicFieldOptions {
     selectionDynamicProviderCtxt: any;
     fieldName: string;
     discoveryService: DiscoveryService;
+    isMultiSelect: boolean | undefined | null;
 }
 
 export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
@@ -19,8 +20,31 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
 
     async validate(dto: any): Promise<ValidationError[]> {
         const fieldValue: any = dto[this.options.fieldName];
+        const isMultiSelect = this.options?.isMultiSelect;
+
+        // return this.applyValidations(fieldValue);
+        // Handle multi-select scenario
+    if (isMultiSelect) {
+        let values: any[];
+
+        try {
+            // Try to parse the field value, which should be a JSON stringified array
+            values = JSON.parse(fieldValue);
+        } catch {
+            // If parsing fails, fallback to a single value
+            values = [fieldValue];
+        }
+
+        // Apply validations to each value asynchronously
+        const allErrors = await Promise.all(values.map(value => this.applyValidations(value)));
+
+        // Flatten the array of errors and return
+        return allErrors.flat();
+    } else {
+        // For non-multi-select, apply validations to the single field value
         return this.applyValidations(fieldValue);
     }
+    }
 
     private async applyValidations(fieldValue: any): Promise<ValidationError[]> {
         const errors: ValidationError[] = [];

package/src/helpers/field-crud-managers/SelectionStaticFieldCrudManager.ts

@@ -7,6 +7,7 @@ export interface SelectionStaticFieldOptions {
     selectionValueType: SelectionValueType;
     required: boolean | undefined | null;
     fieldName: string;
+    isMultiSelect: boolean | undefined | null;
 }
 
 export class SelectionStaticFieldCrudManager implements FieldCrudManager {
@@ -14,9 +15,30 @@ export class SelectionStaticFieldCrudManager implements FieldCrudManager {
     constructor(private readonly options: SelectionStaticFieldOptions) {
     }
 
-    validate(dto: any): ValidationError[] {
-        const fieldValue: any = dto[this.options.fieldName];
-        return this.applyValidations(fieldValue);
+    async validate(dto: any): Promise<ValidationError[]> {
+         const fieldValue: any = dto[this.options.fieldName];
+        // return this.applyValidations(fieldValue);
+        const isMultiSelect = this.options?.isMultiSelect;
+        if (isMultiSelect) {
+            let values: any[];
+    
+            try {
+                // Try to parse the field value, which should be a JSON stringified array
+                values = JSON.parse(fieldValue);
+            } catch {
+                // If parsing fails, fallback to a single value
+                values = [fieldValue];
+            }
+    
+            // Apply validations to each value asynchronously
+            const allErrors = await Promise.all(values.map(value => this.applyValidations(value)));
+    
+            // Flatten the array of errors and return
+            return allErrors.flat();
+        } else {
+            // For non-multi-select, apply validations to the single field value
+            return this.applyValidations(fieldValue);
+        }
     }
 
     private applyValidations(fieldValue: any): ValidationError[] {

package/src/seeders/seed-data/solid-core-metadata.json

@@ -910,6 +910,20 @@
             "encrypt": false,
             "columnName": "relation_join_table_name",
             "isSystem": true
+          },
+          {
+            "name": "isMultiSelect",
+            "displayName": "Is MultiSelect",
+            "type": "boolean",
+            "ormType": "boolean",
+            "defaultValue": "false",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "columnName": "is_multiSelect",
+            "isSystem": true
           }
         ]
       },

package/src/services/crud.service.ts

@@ -34,8 +34,7 @@ import { FileService } from "./file.service";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { ModuleMetadataService } from "./module-metadata.service";
-const DEFAULT_LIMIT = 10;
-const DEFAULT_OFFSET = 0;
+import { isArray } from "class-validator";
 export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
     constructor(
@@ -366,7 +365,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 //     Validation against the selectionStatic values. No transformation is required
                 //     If the value is not in the selectionStatic values, then throw
                 //     Also validate against the selectionType
-                const options = { ...commonOptions, selectionStaticValues: fieldMetadata.selectionStaticValues, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType };
+                const options = { ...commonOptions, selectionStaticValues: fieldMetadata.selectionStaticValues, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, isMultiSelect: fieldMetadata.isMultiSelect};
                 return new SelectionStaticFieldCrudManager(options);
             }
             case SolidFieldType.selectionDynamic: {// [HOLD]
@@ -375,7 +374,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 //     dataSource: string; // The name of the selection provider
                 //     filterSchema : json // This is a custom json object that every data source will handle accordingly. We could validate the query against the selection provider
                 //     values : string[]; // The values returned by the selection provider
-                const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: fieldMetadata.selectionDynamicProviderCtxt, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService };
+                const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: fieldMetadata.selectionDynamicProviderCtxt, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService, isMultiSelect: fieldMetadata.isMultiSelect};
                 return new SelectionDynamicFieldCrudManager(options);
             }
             case SolidFieldType.uuid: {
@@ -497,16 +496,15 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
         // 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);
+                await this.populateMediaObject(mediaFieldPath, model, entity);
             }
-            entity['_media'] = mediaObj;
         }
         return entities;
    } 
 
-    private async getMediaObject(mediaFieldPath: string, model: ModelMetadata, entity: T) {
+    // Adds the media with full URL to the entity / nested entity
+    private async populateMediaObject(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);
@@ -515,12 +513,15 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             }
 
             // 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) {
+            const mediaFieldEntities = this.getMediaFieldEntities(entity, pathParts);
+            if (!mediaFieldEntities || mediaFieldEntities.length === 0) {
                 throw new BadRequestException(`Media field path ${mediaFieldPath} is not populated in model ${this.modelName}`);
             }
-            const mediaWithFullUrl = await this.getMediaWithFullUrl(mediaFieldEntity, mediaFieldMetadata);
-            return mediaWithFullUrl;
+            // Populate the media field entities with the full URL
+            for (const mediaFieldEntity of mediaFieldEntities) {
+                const mediaWithFullUrl = await this.getMediaWithFullUrl(mediaFieldEntity, mediaFieldMetadata);
+                this.appendMediaKey(mediaFieldEntity, mediaWithFullUrl);
+            }
         }
         else {
             // mediaFieldPath is a single field
@@ -529,29 +530,40 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 throw new BadRequestException(`Media field ${mediaFieldPath} not found in model ${this.modelName}`);
             }
             const mediaWithFullUrl = await this.getMediaWithFullUrl(entity, mediaFieldMetadata);
-            return mediaWithFullUrl;
+            this.appendMediaKey(entity, mediaWithFullUrl);
         }
     }
 
-    private getMediaFieldEntity(entity: T, mediaPathParts: string[]) {
-        let mediaFieldEntity = entity;
+    // Add the media with full URL to the entity
+    private appendMediaKey(entity: T, mediaWithFullUrl: MediaWithFullUrl[]) {
+        // if _media key already exists, append the new media to the existing array
+        if (entity['_media']) {
+            entity['_media'] = [...entity['_media'], ...mediaWithFullUrl];
+        }
+        else {
+            entity['_media'] = mediaWithFullUrl;
+        } 
+    }
+
+    private getMediaFieldEntities(entity: T, mediaPathParts: string[]): T[] {
+        let entityPart = entity;
         for (let i = 0; i < mediaPathParts.length - 1; i++) {
             const pathPart = mediaPathParts[i];
-            if (mediaFieldEntity[pathPart]) {
-                mediaFieldEntity = mediaFieldEntity[pathPart];
+            if (entity[pathPart]) {
+                entityPart = entity[pathPart];
             } else {
                 throw new BadRequestException(`Media field ${pathPart} not found in entity ${JSON.stringify(entity)}`);
             }
         }
-        return mediaFieldEntity;
+        return isArray(entityPart) ? entityPart : [entityPart];
     }
 
-    async getMediaWithFullUrl(mediaEntity: any, mediaFieldMetadata: FieldMetadata): Promise<MediaWithFullUrl>{
+    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;
+            return mediaDetails as MediaWithFullUrl[];
     }
 
     async findOne(id: number, query: any, solidRequestContext: any = {}) {

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

@@ -866,7 +866,8 @@ export class FieldMetadataService {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isMultiSelect"
                 ];
 
             case SolidFieldType.selectionDynamic:
@@ -889,7 +890,8 @@ export class FieldMetadataService {
                     "decryptWhen",
                     "columnName",
                     "isUserKey",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isMultiSelect"
                 ];
             case SolidFieldType.computed:
                 return [