@solidstarters/solid-core 1.2.133 → 1.2.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.133",
+  "version": "1.2.134",
   "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/helpers/field-crud-managers/SelectionDynamicFieldCrudManager.ts

@@ -20,31 +20,57 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
 
     async validate(dto: any): Promise<ValidationError[]> {
         const fieldValue: any = dto[this.options.fieldName];
+        // return this.applyValidations(fieldValue);
         const isMultiSelect = this.options?.isMultiSelect;
+        if (isMultiSelect && fieldValue) {
+            const arrayCheck = this.parseAndValidateArray(fieldValue);
 
-        // return this.applyValidations(fieldValue);
-        // Handle multi-select scenario
-    if (isMultiSelect) {
-        let values: any[];
+            if (!arrayCheck.isValid) {
+                return [
+                    {
+                        field: this.options.fieldName,
+                        error: `Field: ${this.options.fieldName} must be a valid array`,
+                    },
+                ];
+            }
 
-        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];
-        }
+            const values = arrayCheck.values;
 
-        // Apply validations to each value asynchronously
-        const allErrors = await Promise.all(values.map(value => this.applyValidations(value)));
+            if (this.isApplyRequiredValidation() && values.length === 0) {
+                return [
+                    {
+                        field: this.options.fieldName,
+                        error: `Field: ${this.options.fieldName} is required`,
+                    },
+                ];
+            }
 
-        // 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);
+            // Apply validations to each value
+            const allErrors = await Promise.all(values.map((val) => this.applyValidations(val)));
+            return allErrors.flat();
+        } else {
+            // For non-multi-select, apply validations to the single field value
+            return this.applyValidations(fieldValue);
+        }
     }
+
+    private parseAndValidateArray(fieldValue: any): { isValid: boolean; values: any[] } {
+        if (Array.isArray(fieldValue)) {
+            return { isValid: true, values: fieldValue };
+        }
+    
+        try {
+            const parsed = typeof fieldValue === 'string' ? JSON.parse(fieldValue) : null;
+            if (Array.isArray(parsed)) {
+                return { isValid: true, values: parsed };
+            }
+        } catch {
+            // fall through
+        }
+    
+        return { isValid: false, values: [] };
     }
+    
 
     private async applyValidations(fieldValue: any): Promise<ValidationError[]> {
         const errors: ValidationError[] = [];

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

@@ -16,24 +16,34 @@ export class SelectionStaticFieldCrudManager implements FieldCrudManager {
     }
 
     async validate(dto: any): Promise<ValidationError[]> {
-         const fieldValue: any = dto[this.options.fieldName];
+        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];
+        if (isMultiSelect && fieldValue) {
+            const arrayCheck = this.parseAndValidateArray(fieldValue);
+
+            if (!arrayCheck.isValid) {
+                return [
+                    {
+                        field: this.options.fieldName,
+                        error: `Field: ${this.options.fieldName} must be a valid array`,
+                    },
+                ];
             }
-    
-            // Apply validations to each value asynchronously
-            const allErrors = await Promise.all(values.map(value => this.applyValidations(value)));
-    
-            // Flatten the array of errors and return
+
+            const values = arrayCheck.values;
+
+            if (this.isApplyRequiredValidation() && values.length === 0) {
+                return [
+                    {
+                        field: this.options.fieldName,
+                        error: `Field: ${this.options.fieldName} is required`,
+                    },
+                ];
+            }
+
+            // Apply validations to each value
+            const allErrors = await Promise.all(values.map((val) => this.applyValidations(val)));
             return allErrors.flat();
         } else {
             // For non-multi-select, apply validations to the single field value
@@ -41,6 +51,24 @@ export class SelectionStaticFieldCrudManager implements FieldCrudManager {
         }
     }
 
+    private parseAndValidateArray(fieldValue: any): { isValid: boolean; values: any[] } {
+        if (Array.isArray(fieldValue)) {
+            return { isValid: true, values: fieldValue };
+        }
+    
+        try {
+            const parsed = typeof fieldValue === 'string' ? JSON.parse(fieldValue) : null;
+            if (Array.isArray(parsed)) {
+                return { isValid: true, values: parsed };
+            }
+        } catch {
+            // fall through
+        }
+    
+        return { isValid: false, values: [] };
+    }
+    
+
     private applyValidations(fieldValue: any): ValidationError[] {
         const errors: ValidationError[] = [];
         this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }) : "no errors";

package/src/services/import-transaction.service.ts

@@ -339,9 +339,10 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
       throw new BadRequestException(`Failed to create export stream for import transaction ID ${importTransactionId}.`);
     }
     // Return the export stream
+    const extension = templateFormat === "excel" ? 'xlsx' : 'csv';
     return {
       stream: exportStream,
-      fileName: `${importTransaction.modelMetadata.singularName}-failed-imports.${templateFormat}`,
+      fileName: `${importTransaction.modelMetadata.singularName}-failed-imports.${extension}`,
       mimeType: templateFormat === "excel" ? ImportMimeTypes.EXCEL : ImportMimeTypes.CSV,
     };