@solidstarters/solid-core 1.2.62 → 1.2.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.62",
+  "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/model-metadata.service.ts

@@ -232,105 +232,6 @@ export class ModelMetadataService {
       model = await manager.save(updatedModelMetadataDto);
     }
 
-    // const modelViews = [{
-    //   name: `${model.singularName}-list-view`,
-    //   displayName: `${model.displayName}`,
-    //   type: 'list',
-    //   context: "{}",
-    //   module: resolvedModule,
-    //   model: model,
-    //   layout: JSON.stringify({
-    //     type: "list",
-    //     attrs: {
-    //       pagination: true,
-    //       pageSizeOptions: [
-    //         10,
-    //         25,
-    //         50
-    //       ],
-    //       enableGlobalSearch: true,
-    //       create: true,
-    //       edit: true,
-    //       delete: true
-    //     },
-    //     children: listViewLayout
-    //   }, null, 2)
-    // },
-    // {
-    //   name: `${model.singularName}-form-view`,
-    //   displayName: `${model.displayName}`,
-    //   type: 'form',
-    //   context: "{}",
-    //   module: model.module,
-    //   model: model,
-    //   layout: JSON.stringify(
-    //     {
-    //       type: "form",
-    //       attrs: { name: "form-1", label: `${model.displayName}`, className: "grid" },
-    //       children: [
-    //         {
-    //           type: "sheet",
-    //           attrs: { name: "sheet-1" },
-    //           children: [
-    //             {
-    //               type: "row",
-    //               attrs: { name: "group-1", label: "", className: "" },
-    //               children: [
-    //                 {
-    //                   type: "column",
-    //                   attrs: { name: "group-1", label: "", className: "col-6" },
-    //                   children: formViewLayout
-    //                 }
-    //               ]
-    //             }
-    //           ]
-    //         }
-    //       ]
-    //     }, null, 2)
-    // }
-    // ];
-    // const viewRepo = manager.getRepository(ViewMetadata);
-    // for (let j = 0; j < modelViews.length; j++) {
-    //   const view = modelViews[j];
-    //   const createdView = await viewRepo.create(view);
-    //   await viewRepo.save(createdView);
-    // }
-
-    // const view = await viewRepo.findOneBy({ name: `${model.singularName}-list-view` });
-
-    // const action = {
-    //   displayName: `${model.displayName} List View`,
-    //   name: `${model.singularName}-list-view`,
-    //   type: "solid",
-    //   domain: "",
-    //   context: "",
-    //   customComponent: `/admin/address-master/${model.singularName}/all`,
-    //   customIsModal: true,
-    //   serverEndpoint: "",
-    //   view: view,
-    //   module: resolvedModule,
-    //   model: model
-    // };
-    // const actionRepo = manager.getRepository(ActionMetadata);
-    // const createdAction = await actionRepo.create(action);
-    // const newAction = await actionRepo.save(createdAction);
-
-    // const adminRole = await this.roleService.findRoleByName('Admin');
-
-    // const menu = {
-    //   displayName: `${model.displayName}`,
-    //   name: `${model.singularName}`,
-    //   sequenceNumber: 1,
-    //   action: newAction,
-    //   module: resolvedModule,
-    //   roles: [adminRole],
-    //   parentMenuItemUserKey: ""
-    // };
-
-    // const menuRepo = manager.getRepository(MenuItemMetadata);
-    // const createdMenu = await menuRepo.create(menu);
-    // await menuRepo.save(createdMenu);
-
     return model;
   }
 
@@ -360,122 +261,14 @@ export class ModelMetadataService {
         fields: []
       }
 
-      const listViewLayoutFields = [{ type: "field", attrs: { name: `id`, sortable: true, filterable: true } }];
-      const formViewLayoutFields = [];
-
       for (let i = 0; i < model.fields.length; i++) {
         const field = model.fields[i];
-        if (!field.isSystem) {
-
-          const fieldObject: Record<string, any> = await this.fieldMetadataService.createFieldConfig(field);
-          modelMetaData.fields.push(fieldObject);
-          listViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}`, sortable: true, filterable: true } })
-          formViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}` } })
-
-        }
-      }
-      const column1Fields = [];
-      const column2Fields = [];
-
-      // Distribute fields between two columns
-      for (let i = 0; i < formViewLayoutFields.length; i++) {
-        if (i % 2 === 0) {
-          column1Fields.push(formViewLayoutFields[i]);
-        } else {
-          column2Fields.push(formViewLayoutFields[i]);
-        }
+        if (field.isSystem) continue;
+        const fieldObject: Record<string, any> = await this.fieldMetadataService.createFieldConfig(field);
+        modelMetaData.fields.push(fieldObject);
       }
-      const action = {
-        displayName: `${model.displayName} List View`,
-        name: `${model.singularName}-list-view`,
-        type: "solid",
-        domain: "",
-        context: "",
-        customComponent: `/admin/address-master/${model.singularName}/all`,
-        customIsModal: true,
-        serverEndpoint: "",
-        viewUserKey: `${model.singularName}-list-view`,
-        moduleUserKey: `${model.module.name}`,
-        modelUserKey: `${model.singularName}`
-      };
-
-      const menu = {
-        displayName: `${model.displayName}`,
-        name: `${model.singularName}-menu-item`,
-        sequenceNumber: 1,
-        actionUserKey: `${model.singularName}-list-view`,
-        moduleUserKey: `${model.module.name}`,
-        parentMenuItemUserKey: ""
-      };
-
-      const modelListview = {
-        name: `${model.singularName}-list-view`,
-        displayName: `${model.displayName}`,
-        type: "list",
-        context: "{}",
-        moduleUserKey: `${model.module.name}`,
-        modelUserKey: `${model.singularName}`,
-        layout: {
-          type: "list",
-          attrs: {
-            pagination: true,
-            pageSizeOptions: [
-              10,
-              25,
-              50
-            ],
-            enableGlobalSearch: true,
-            create: true,
-            edit: true,
-            delete: true
-          },
-          children: listViewLayoutFields
-        }
-      };
-
-
-      const modelFormView = {
-        name: `${model.singularName}-form-view`,
-        displayName: `${model.displayName}`,
-        type: "form",
-        context: "{}",
-        moduleUserKey: `${model.module.name}`,
-        modelUserKey: `${model.singularName}`,
-        layout: {
-          type: "form",
-          attrs: { name: "form-1", label: `${model.displayName}`, className: "grid" },
-          children: [
-            {
-              type: "sheet",
-              attrs: { name: "sheet-1" },
-              children: [
-                {
-                  type: "row",
-                  attrs: { name: "sheet-1" },
-                  children: [
-                    {
-                      type: "column",
-                      attrs: { name: "group-1", label: "", className: "col-6" },
-                      children: column1Fields
-                    },
-                    {
-                      type: "column",
-                      attrs: { name: "group-2", label: "", className: "col-6" },
-                      children: column2Fields
-                    }]
-                },
-              ]
-            }
-          ]
-        }
-      };
       // Update the `models` array
       metaData.moduleMetadata.models.push(modelMetaData);
-      metaData.menus.push(menu);
-      metaData.actions.push(action);
-      metaData.views.push(modelListview);
-      metaData.views.push(modelFormView);
-
 
       // Write the updated object back to the file
       const updatedContent = JSON.stringify(metaData, null, 2);
@@ -734,6 +527,163 @@ export class ModelMetadataService {
       await this.generateCode(inverseOptions);
     }                      
 
+    await this.generateVAMConfig(model.id);
+
+    return `${removeFieldCodeOuput} \n ${refreshModelCodeOutput}`;
+  }
+
+  // Generate the View, Action and Menu configuration for the model
+  private async generateVAMConfig(modelId: number) {
+    try {
+      return await this.dataSource.transaction(async (manager: EntityManager) => {
+        const modelRepository = manager.getRepository(ModelMetadata);
+        const model = await modelRepository.findOne({
+          where: {
+            id: modelId
+          },
+          relations: ["fields", "module"]
+        });
+        await this.populateVAMConfigInDb(model);
+        await this.populateVAMConfigInFile(model);
+      });
+    } catch (error) {
+      this.logger.error('generateVAMConfig Transaction failed:', error);
+      throw error;
+    }
+  }
+
+  private async populateVAMConfigInFile(model: ModelMetadata) {
+    try {
+      const filePath = this.moduleMetadataHelperService.getModuleMetadataFilePath(model.module.name);
+      const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
+
+      const listViewLayoutFields = [{ type: "field", attrs: { name: `id`, sortable: true, filterable: true } }];
+      const formViewLayoutFields = [];
+
+      for (let i = 0; i < model.fields.length; i++) {
+        const field = model.fields[i];
+        if (field.isSystem) continue;
+        listViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}`, sortable: true, filterable: true } })
+        formViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}` } })
+      }
+      this.populateVAMConfigInFileInternal(formViewLayoutFields, model, listViewLayoutFields, metaData);
+      // Write the updated object back to the file
+      const updatedContent = JSON.stringify(metaData, null, 2);
+      await fs.writeFile(filePath, updatedContent);
+
+    } catch (error) {
+      // console.error('File creation failed:', error);
+      this.logger.error('File updation failed for View, action, menus config:', error);
+      throw new Error('File updation failed for View, action, menus config'); // Trigger rollback
+    }
+  }
+
+  // Populate the View, Actions and Menus in the config file
+  private populateVAMConfigInFileInternal(formViewLayoutFields: any[], model: ModelMetadata, listViewLayoutFields: { type: string; attrs: { name: string; sortable: boolean; filterable: boolean; }; }[], metaData: any) {
+    const column1Fields = [];
+    const column2Fields = [];
+
+    // Distribute fields between two columns
+    for (let i = 0; i < formViewLayoutFields.length; i++) {
+      if (i % 2 === 0) {
+        column1Fields.push(formViewLayoutFields[i]);
+      } else {
+        column2Fields.push(formViewLayoutFields[i]);
+      }
+    }
+    const action = {
+      displayName: `${model.displayName} List View`,
+      name: `${model.singularName}-list-view`,
+      type: "solid",
+      domain: "",
+      context: "",
+      customComponent: `/admin/address-master/${model.singularName}/all`,
+      customIsModal: true,
+      serverEndpoint: "",
+      viewUserKey: `${model.singularName}-list-view`,
+      moduleUserKey: `${model.module.name}`,
+      modelUserKey: `${model.singularName}`
+    };
+
+    const menu = {
+      displayName: `${model.displayName}`,
+      name: `${model.singularName}-menu-item`,
+      sequenceNumber: 1,
+      actionUserKey: `${model.singularName}-list-view`,
+      moduleUserKey: `${model.module.name}`,
+      parentMenuItemUserKey: ""
+    };
+
+    const modelListview = {
+      name: `${model.singularName}-list-view`,
+      displayName: `${model.displayName}`,
+      type: "list",
+      context: "{}",
+      moduleUserKey: `${model.module.name}`,
+      modelUserKey: `${model.singularName}`,
+      layout: {
+        type: "list",
+        attrs: {
+          pagination: true,
+          pageSizeOptions: [
+            10,
+            25,
+            50
+          ],
+          enableGlobalSearch: true,
+          create: true,
+          edit: true,
+          delete: true
+        },
+        children: listViewLayoutFields
+      }
+    };
+
+
+    const modelFormView = {
+      name: `${model.singularName}-form-view`,
+      displayName: `${model.displayName}`,
+      type: "form",
+      context: "{}",
+      moduleUserKey: `${model.module.name}`,
+      modelUserKey: `${model.singularName}`,
+      layout: {
+        type: "form",
+        attrs: { name: "form-1", label: `${model.displayName}`, className: "grid" },
+        children: [
+          {
+            type: "sheet",
+            attrs: { name: "sheet-1" },
+            children: [
+              {
+                type: "row",
+                attrs: { name: "sheet-1" },
+                children: [
+                  {
+                    type: "column",
+                    attrs: { name: "group-1", label: "", className: "col-6" },
+                    children: column1Fields
+                  },
+                  {
+                    type: "column",
+                    attrs: { name: "group-2", label: "", className: "col-6" },
+                    children: column2Fields
+                  }
+                ]
+              },
+            ]
+          }
+        ]
+      }
+    };
+    metaData.menus.push(menu);
+    metaData.actions.push(action);
+    metaData.views.push(modelListview);
+    metaData.views.push(modelFormView);
+  }
+
+  //Populate the View, Actions and Menus in the database
+  private async populateVAMConfigInDb(model: ModelMetadata) {
     const jsonFieldsList = model.fields.filter((field: FieldMetadata) => field.isSystem !== true);
 
     const listViewLayout = jsonFieldsList.map(field => ({
@@ -872,8 +822,6 @@ export class ModelMetadataService {
       const createdMenu = menuRepo.create(menuData);
       await menuRepo.save(createdMenu);
     }
-
-    return `${removeFieldCodeOuput} \n ${refreshModelCodeOutput}`;
   }
 
   private async generateCode(options: CodeGenerationOptions) {