@solidstarters/solid-core 1.2.66 → 1.2.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.66",
+  "version": "1.2.68",
   "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/providers/list-of-values-selection-providers.service.ts

@@ -34,12 +34,21 @@ export class ListOfValuesSelectionProvider implements ISelectionProvider<ListOfV
 
     async values(query: string, ctxt: ListOfValuesProviderContext): Promise<readonly ISelectionProviderValues[]> {
         const basicFilterQuery = new BasicFilterDto(DEFAULT_LIMIT, 0);
-        basicFilterQuery.filters = {
-            type: {
-                $eq: ctxt.type
-            }
+        if (ctxt.type) {
+            basicFilterQuery.filters = {
+                type: {
+                    $eq: ctxt.type
+                }
+            };
+        }
+        if (query) {
+            basicFilterQuery.filters = {
+                ...basicFilterQuery.filters,
+                display: {
+                    $containsi: `%${query}%`
+                }
+            };
         }
-
         const lovs = await this.listOfValuesService.find(basicFilterQuery);
         const selectionValues = lovs.records.map(lov => {
             return {

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
           }
         ]
       },
@@ -3807,7 +3821,7 @@
       "name": "media-menu-item",
       "sequenceNumber": 3,
       "actionUserKey": "media-root",
-      "moduleUserKey": "solid-core",                                             
+      "moduleUserKey": "solid-core",
       "parentMenuItemUserKey": ""
     },
     {
@@ -3980,32 +3994,11 @@
             {
               "attrs": {
                 "className": "pi pi-cog",
-                "label": "Generate Code"
-              },
-              "action": {
-                "title": "",
-                "body": "",
-                "confirmBtnLabel": "Generate Code",
-                "cancelBtnLabel": "Cancel",
-                "customComponent": "GenerateModuleCodeRowAction",
-                "customComponentIsSystem": true,
-                "endpoint": ""
-              }
-            }
-          ],
-          "headerButtons": [
-            {
-              "attrs": {
-                "className": "pi pi-cog",
-                "label": "Generate Code"
-              },
-              "action": {
-                "title": "",
-                "body": "",
-                "confirmBtnLabel": "Generate Code",
-                "cancelBtnLabel": "Cancel",
-                "customComponent": "GenerateModuleCode",
-                "endpoint": ""
+                "label": "Generate Code",
+                "action": "GenerateModuleCodeRowAction",
+                "openInPopup": true,
+                "actionInContextMenu": true,
+                "customComponentIsSystem": true
               }
             }
           ]
@@ -4172,32 +4165,11 @@
             {
               "attrs": {
                 "className": "pi pi-cog",
-                "label": "Generate Code"
-              },
-              "action": {
-                "title": "",
-                "body": "",
-                "confirmBtnLabel": "Generate Code",
-                "cancelBtnLabel": "Cancel",
-                "customComponent": "GenerateModelCodeRowAction",
+                "label": "Generate Code",
+                "action": "GenerateModelCodeRowAction",
                 "customComponentIsSystem": true,
-                "endpoint": ""
-              }
-            }
-          ],
-          "headerButtons": [
-            {
-              "attrs": {
-                "className": "pi pi-cog",
-                "label": "Generate Code"
-              },
-              "action": {
-                "title": "",
-                "body": "",
-                "confirmBtnLabel": "Generate Code",
-                "cancelBtnLabel": "Cancel",
-                "customComponent": "GenerateModelCode",
-                "endpoint": ""
+                "actionInContextMenu": true,
+                "openInPopup": true
               }
             }
           ]
@@ -6046,7 +6018,7 @@
             "attrs": {
               "name": "name",
               "isSearchable": true
-                        }
+            }
           },
           {
             "type": "field",
@@ -6210,7 +6182,6 @@
         ]
       }
     },
-    
     {
       "name": "media-list-view",
       "displayName": "Solid Media Model",
@@ -8673,6 +8644,5 @@
     }
   ],
   "checksums": [],
-  "listOfValues": [
-  ]
+  "listOfValues": []
 }

package/src/services/authentication.service.ts

@@ -41,6 +41,7 @@ import {
 } from "../constants";
 import { SettingService } from './setting.service';
 import { CreateUserDto } from 'src/dtos/create-user.dto';
+import { RoleMetadataService } from './role-metadata.service';
 
 enum LoginProvider {
     LOCAL = 'local',
@@ -73,6 +74,8 @@ export class AuthenticationService {
         private readonly smsService: Msg91OTPService,
         private readonly eventEmitter: EventEmitter2,
         private readonly settingService: SettingService,
+        private readonly roleMetadataService: RoleMetadataService
+
     ) { }
 
     async resolveUser(username: string, email: string) {
@@ -145,7 +148,7 @@ export class AuthenticationService {
             var { user, pwd, autoGeneratedPwd } = await this.populateForSignup<T>(extensionUser, signUpDto);
             const savedUser = await extensionUserRepo.save(user);
 
-            await this.handlePostSignup(savedUser, signUpDto.roles,  pwd, autoGeneratedPwd);
+            await this.handlePostSignup(savedUser, signUpDto.roles, pwd, autoGeneratedPwd);
 
             return savedUser;
         }
@@ -158,15 +161,23 @@ export class AuthenticationService {
         }
     }
 
-  
+
     private async populateForSignup<T extends User>(user: T, signUpDto: SignUpDto, isUserActive: boolean = true) {
         // const user = new User();
+
+        if (signUpDto.roles && signUpDto.roles.length > 0) {
+            for (let i = 0; i < signUpDto.roles.length; i++) {
+                const roleName = signUpDto.roles[i];
+                await this.roleMetadataService.findRoleByName(roleName);
+            }
+        }
         user.username = signUpDto.username;
         user.email = signUpDto.email;
         user.fullName = signUpDto.fullName;
         if (signUpDto.mobile) {
             user.mobile = signUpDto.mobile;
         }
+
         // If password has been specified by the user, then we simply create & activate the user based on the configuration parameter "activateUserOnRegistration".
         let pwd = '';
         let autoGeneratedPwd = '';
@@ -186,8 +197,9 @@ export class AuthenticationService {
         return { user, pwd, autoGeneratedPwd };
     }
 
-    private async handlePostSignup(user: User, roles: string[]=[], pwd: string, autoGeneratedPwd: string) {
-        this.userService.initializeRolesForNewUser(roles, user);
+
+    private async handlePostSignup(user: User, roles: string[] = [], pwd: string, autoGeneratedPwd: string) {
+        await this.userService.initializeRolesForNewUser(roles, user);
         // Tanay: Adding user password to history table
         const userPasswordHistory = new UserPasswordHistory();
         userPasswordHistory.passwordHash = pwd;

package/src/services/crud.service.ts

@@ -366,7 +366,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 +375,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: {

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 [

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

@@ -184,16 +184,19 @@ export class ModelMetadataService {
         relations: {},
       });
     createDto['module'] = resolvedModule;
+    
+    if (createDto['parentModelId']) {
+      const resolvedParentModel = await this.dataSource
+        .getRepository(ModelMetadata)
+        .findOne({
+          where: {
+            id: createDto['parentModelId'],
+          },
+          relations: {},
+        });
+      createDto['parentModel'] = resolvedParentModel;
+    }
 
-    const resolvedParentModel = await this.dataSource
-      .getRepository(ModelMetadata)
-      .findOne({
-        where: {
-          id: createDto['parentModelId'],
-        },
-        relations: {},
-      });
-    createDto['parentModel'] = resolvedParentModel;
     const { fields: fieldsMetadata, ...modelMetaDataWithoutFields } = createDto;
     const modelMetadata = this.modelMetadataRepo.create(modelMetaDataWithoutFields);
     let model = await manager.save(modelMetadata);
@@ -515,8 +518,8 @@ export class ModelMetadataService {
 
     // Generate the code for models which are linked to fields having an inverse relation
     const coModelSingularNames = model.fields.
-                          filter(field => field.type === SolidFieldType.relation && field.relationCreateInverse === true)
-                          .map(field => field.relationCoModelSingularName);
+      filter(field => field.type === SolidFieldType.relation && field.relationCreateInverse === true)
+      .map(field => field.relationCoModelSingularName);
 
     for (const singularName of coModelSingularNames) {
       const coModel = await this.findOneBySingularName(singularName);
@@ -525,7 +528,7 @@ export class ModelMetadataService {
         dryRun: options.dryRun
       };
       await this.generateCode(inverseOptions);
-    }                      
+    }
 
     await this.generateVAMConfig(model.id);
 

package/src/services/user.service.ts

@@ -34,7 +34,7 @@ export class UserService extends CRUDService<User> {
     readonly moduleRef: ModuleRef,
     @Inject(iamConfig.KEY)
     private readonly iamConfiguration: ConfigType<typeof iamConfig>,
-    
+
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'user', 'solid-core', moduleRef);
   }
@@ -237,20 +237,20 @@ export class UserService extends CRUDService<User> {
     return matchingPermssions
   }
 
-  initializeRolesForNewUser(roles: string[], user: User) {
+  async initializeRolesForNewUser(roles: string[], user: User) {
     if (!user.id) {
-        throw new BadRequestException('User must exist before initializing roles');
+      throw new BadRequestException('User must exist before initializing roles');
     }
     let userRoles = [];
     // Default Internal user role assigned 
     userRoles.push("Internal User");
     if (roles) {
-        userRoles = [...userRoles, ...roles];
+      userRoles = [...userRoles, ...roles];
     }
     userRoles = Array.from(new Set([...userRoles]));
     if (userRoles.length > 0) {
-        this.addRolesToUser(user.username, userRoles);
+      await this.addRolesToUser(user.username, userRoles);
     }
- }
+  }
 
 }