@solidstarters/solid-core 1.2.192 → 1.2.200

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

@@ -7,7 +7,7 @@ import { ComputedFieldMetadata, SolidRegistry } from 'src/helpers/solid-registry
 import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { DataSource, Repository, SelectQueryBuilder } from 'typeorm';
 import { BasicFilterDto } from '../dtos/basic-filters.dto';
-import { CascadeType, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, PSQLType, RelationType, SelectionValueType, SolidFieldType } from '../dtos/create-field-metadata.dto';
+import { CascadeType, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, MSSQLType, PSQLType, RelationType, SelectionValueType, SolidFieldType } from '../dtos/create-field-metadata.dto';
 import { SelectionDynamicQueryDto } from '../dtos/selection-dynamic-query.dto';
 import { UpdateFieldMetaDataDto } from '../dtos/update-field-metadata.dto';
 import { FieldMetadata } from '../entities/field-metadata.entity';
@@ -16,12 +16,18 @@ import { ISelectionProviderValues } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import qs from 'qs';
+import { ResolveS3UrlDto } from 'src/dtos/resolve-s3-url.dto';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from './file.service';
 
 
 @Injectable()
 export class FieldMetadataService implements OnApplicationBootstrap {
     constructor(
         private readonly fieldMetadataRepo: FieldMetadataRepository,
+        private readonly configService: ConfigService,
+        private readonly fileService: FileService,
+
         @InjectDataSource()
         private readonly dataSource: DataSource,
         private readonly solidRegistry: SolidRegistry,
@@ -35,9 +41,9 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         this.loadAndRegisterComputedFieldsDetails();
     }
 
-   async loadAndRegisterComputedFieldsDetails() {
+    async loadAndRegisterComputedFieldsDetails() {
         // Load all the modules and models and within that load all the computed fields
-        const computedFieldsWithModelAndModule =  await this.fieldMetadataRepo.findComputedFieldsPopulatedWithModelAndModule();
+        const computedFieldsWithModelAndModule = await this.fieldMetadataRepo.findComputedFieldsPopulatedWithModelAndModule();
 
         // Convert the computed fields object above to the ComputedFieldMetadata type
         const computedFieldMetadata: ComputedFieldMetadata[] = computedFieldsWithModelAndModule.map((field) => {
@@ -354,7 +360,71 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         };
 
         // Orm Data type and Solid Dat Type Mapping
-        const ormFieldTypeForSolid = {
+        const ormFieldTypeForSolid = this.getOrmFieldTypes();
+
+        // Fetch Data Source Type 
+        const dataSourceTypes = Object.keys(ormFieldTypeForSolid); // ["psql"]
+
+        const fieldTypes = Object.entries(ormFieldTypeForSolid.postgres).map(([key, value]) => ({
+            type: key,
+            label: key,
+            value: key,
+            fieldType: key,
+            ormTypes: value.ormTypes,
+            fields: this.fetchCurrentFields(key)
+        }));
+
+        const dataSource = this.solidRegistry.getSolidDatabaseModules().map((solidDatabaseModule) => {
+            return {
+                'name': solidDatabaseModule.instance.name(),
+                'type': solidDatabaseModule.instance.type()
+            }
+        });
+
+        // Creating response arrays for each enum
+        // Get all selection providers. 
+        const sps = [];
+        const selectionProviders = this.solidRegistry.getSelectionProviders();
+        for (let i = 0; i < selectionProviders.length; i++) {
+            const selectionProvider = selectionProviders[i];
+            sps.push({
+                provider: selectionProvider.instance.name(),
+                help: selectionProvider.instance.help(),
+            });
+        }
+
+        const cps = [];
+        const computedProviders = this.solidRegistry.getComputedFieldProviders();
+        for (let i = 0; i < computedProviders.length; i++) {
+            const computedProvider = computedProviders[i];
+            cps.push({
+                provider: computedProvider.instance.name(),
+                help: computedProvider.instance.help(),
+            });
+        }
+
+        const r = {
+            // Field Types with ormtypes, available fields  
+            fieldTypes: fieldTypes,
+            encryptionTypes: enumToResponseArray(EncryptionType),
+            ormType: ormFieldTypeForSolid,
+            decryptWhenTypes: enumToResponseArray(DecryptWhenType),
+            mediaTypes: enumToResponseArray(MediaType),
+            relationTypes: enumToResponseArray(RelationType),
+            selectionDynamicProviders: sps,
+            computedProviders: cps,
+            cascadeTypes: enumToResponseArray(CascadeType),
+            selectionValueTypes: enumToResponseArray(SelectionValueType),
+            computedFieldValueTypes: enumToResponseArray(ComputedFieldValueType),
+            dataSourceType: dataSourceTypes,
+            dataSource: dataSource,
+        };
+
+        return r
+    }
+
+    private getOrmFieldTypes() {
+        return {
             "postgres": {
                 // Numeric types
                 "int": {
@@ -379,6 +449,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                 },
                 "json": {
                     "ormTypes": [
+                        // { label: PSQLType.simplejson, description: "Creates DB agnostic column for storing json style data." },
+                        { label: MSSQLType.simplejson, description: "Creates DB agnostic column for storing json style data." },
                         { label: PSQLType.json, description: "Stores JSON data without indexing." },
                         { label: PSQLType.jsonb, description: "Stores JSON data with indexing for faster queries." }
                     ]
@@ -443,69 +515,131 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                 "uuid": {
                     "ormTypes": [{ label: PSQLType.varchar, description: "Stores universally unique identifiers (UUIDs)." }]
                 }
-            }
-        };
+            },
+            "mssql": {
+                // Numeric types
+                "int": {
+                    ormTypes: [
+                        { label: MSSQLType.int, description: "A 4-byte integer for general numeric data." }
+                    ]
+                },
+                "bigint": {
+                    ormTypes: [
+                        { label: MSSQLType.bigint, description: "An 8-byte integer for large numeric values." }
+                    ]
+                },
+                "decimal": {
+                    ormTypes: [
+                        { label: MSSQLType.numeric, description: "A high-precision numeric type for financial or exact values." },
+                        { label: MSSQLType.decimal, description: "A high-precision decimal type for financial or exact values." }
+                    ]
+                },
 
+                // Text types
+                "shortText": {
+                    ormTypes: [
+                        { label: MSSQLType.varchar, description: "A variable-length string for short text." },
+                        { label: MSSQLType.nvarchar, description: "A unicode supported variable-length string for short text." }
+                    ]
+                },
+                "longText": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "A large or unbounded string type." }
+                    ]
+                },
+                "richText": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "A large text field for formatted or long content." }
+                    ]
+                },
+                "json": {
+                    ormTypes: [
+                        { label: MSSQLType.simplejson, description: "Creates DB agnostic column for storing json style data." },
+                        { label: MSSQLType.nvarchar, description: "Stores JSON data as string (MSSQL doesn't have native JSON type)." }
+                    ]
+                },
 
-        // Fetch Data Source Type 
-        const dataSourceTypes = Object.keys(ormFieldTypeForSolid); // ["psql"]
+                // Boolean types
+                "boolean": {
+                    ormTypes: [
+                        { label: MSSQLType.bit, description: "Stores true or false values as 0 or 1." }
+                    ]
+                },
 
-        const fieldTypes = Object.entries(ormFieldTypeForSolid.postgres).map(([key, value]) => ({
-            type: key,
-            label: key,
-            value: key,
-            fieldType: key,
-            ormTypes: value.ormTypes,
-            fields: this.fetchCurrentFields(key)
-        }));
+                // Date and time types
+                "date": {
+                    ormTypes: [
+                        { label: MSSQLType.date, description: "Stores calendar dates (YYYY-MM-DD)." }
+                    ]
+                },
+                "datetime": {
+                    ormTypes: [
+                        { label: MSSQLType.datetime, description: "Stores date and time without timezone." },
+                        { label: MSSQLType.datetime2, description: "High-precision date and time type." }
+                    ]
+                },
+                "time": {
+                    ormTypes: [
+                        { label: MSSQLType.time, description: "Stores time values (HH:MM:SS)." }
+                    ]
+                },
 
-        const dataSource = this.solidRegistry.getSolidDatabaseModules().map((solidDatabaseModule) => {
-            return {
-                'name': solidDatabaseModule.instance.name(),
-                'type': solidDatabaseModule.instance.type()
-            }
-        });
+                // Relation
+                "relation": {
+                    ormTypes: [
+                        { label: MSSQLType.int, description: "Used for foreign keys referencing other entities." }
+                    ]
+                },
 
-        // Creating response arrays for each enum
-        // Get all selection providers. 
-        const sps = [];
-        const selectionProviders = this.solidRegistry.getSelectionProviders();
-        for (let i = 0; i < selectionProviders.length; i++) {
-            const selectionProvider = selectionProviders[i];
-            sps.push({
-                provider: selectionProvider.instance.name(),
-                help: selectionProvider.instance.help(),
-            });
-        }
+                // Media types
+                "mediaSingle": {
+                    ormTypes: [
+                        { label: MSSQLType.varchar, description: "Stores file paths or URLs for single media files." }
+                    ]
+                },
+                "mediaMultiple": {
+                    ormTypes: [
+                        { label: MSSQLType.varchar, description: "Stores file paths or URLs for multiple media files." }
+                    ]
+                },
 
-        const cps = [];
-        const computedProviders = this.solidRegistry.getComputedFieldProviders();
-        for (let i = 0; i < computedProviders.length; i++) {
-            const computedProvider = computedProviders[i];
-            cps.push({
-                provider: computedProvider.instance.name(),
-                help: computedProvider.instance.help(),
-            });
-        }
+                // Email and password
+                "email": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Stores email addresses." }
+                    ]
+                },
+                "password": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Stores hashed or plain-text passwords." }
+                    ]
+                },
 
-        const r = {
-            // Field Types with ormtypes, available fields  
-            fieldTypes: fieldTypes,
-            encryptionTypes: enumToResponseArray(EncryptionType),
-            ormType: ormFieldTypeForSolid,
-            decryptWhenTypes: enumToResponseArray(DecryptWhenType),
-            mediaTypes: enumToResponseArray(MediaType),
-            relationTypes: enumToResponseArray(RelationType),
-            selectionDynamicProviders: sps,
-            computedProviders: cps,
-            cascadeTypes: enumToResponseArray(CascadeType),
-            selectionValueTypes: enumToResponseArray(SelectionValueType),
-            computedFieldValueTypes: enumToResponseArray(ComputedFieldValueType),
-            dataSourceType: dataSourceTypes,
-            dataSource: dataSource,
-        };
+                // Selection types
+                "selectionStatic": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Used for predefined selection options." }
+                    ]
+                },
+                "selectionDynamic": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Used for dynamic selection options." }
+                    ]
+                },
 
-        return r
+                // Computed and external ID
+                "computed": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Represents computed or derived fields." }
+                    ]
+                },
+                "uuid": {
+                    ormTypes: [
+                        { label: MSSQLType.uniqueidentifier, description: "Stores universally unique identifiers (UUIDs)." }
+                    ]
+                }
+            }
+        };
     }
 
     async fetchCurrentFieldsBasedOnType(type: string) {
@@ -533,7 +667,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isPrimaryKey"
                 ];
 
             case SolidFieldType.bigint:
@@ -553,7 +688,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isPrimaryKey"
                 ];
 
             // case SolidFieldType.float:
@@ -616,7 +752,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "decryptWhen",
                     "columnName",
                     "isUserKey",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isPrimaryKey"
                 ];
 
             case SolidFieldType.longtext:
@@ -852,7 +989,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isPrimaryKey"
                 ];
 
             case SolidFieldType.password:
@@ -964,10 +1102,6 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "decryptWhen",
                     "columnName"
                 ];
-
-
-
-
             default:
                 return [
                     "name",
@@ -1145,6 +1279,77 @@ export class FieldMetadataService implements OnApplicationBootstrap {
 
         return fieldObject;
     }
+
+    async resolveS3Url(resolveS3UrlDto: ResolveS3UrlDto) {
+
+        const { modelName, fieldName, fieldValue, s3KeyFieldName } = resolveS3UrlDto;
+
+        // ------------------------------------------------
+        // 1. Load model metadata
+        // ------------------------------------------------
+        const modelRepo = this.dataSource.getRepository(ModelMetadata);
+        const model = await modelRepo.findOne({
+            where: { singularName: modelName },
+            relations: ['fields']
+        });
+
+        if (!model) {
+            throw new NotFoundException(`Model ${modelName} not found`);
+        }
+
+        // ------------------------------------------------
+        // 2. Validate the field we are filtering by
+        // ------------------------------------------------
+        const filterFieldMeta = model.fields.find(f => f.name === fieldName);
+        if (!filterFieldMeta) {
+            throw new NotFoundException(
+                `Field ${fieldName} not found in model ${modelName}`
+            );
+        }
+
+        // ------------------------------------------------
+        // 3. Load the actual entity repository
+        // ------------------------------------------------
+        const entityRepo = this.dataSource.getRepository(model.singularName);
+
+        // ------------------------------------------------
+        // 4. Query using fieldName = fieldValue
+        // ------------------------------------------------
+        const record = await entityRepo.findOne({
+            where: { [fieldName]: fieldValue }
+        });
+
+        if (!record) {
+            throw new NotFoundException(
+                `${modelName} record not found for ${fieldName}="${fieldValue}"`
+            );
+        }
+
+        // ------------------------------------------------
+        // 5. Extract S3 key from s3KeyFieldName
+        // ------------------------------------------------
+        const s3Key = record[s3KeyFieldName];
+
+        if (!s3Key) {
+            throw new NotFoundException(
+                `Field "${s3KeyFieldName}" has no value in ${modelName}.${fieldName}="${fieldValue}"`
+            );
+        }
+
+        // ------------------------------------------------
+        // 6. Generate signed or public URL
+        // ------------------------------------------------
+        let url = "";
+
+        // TODO  - get 
+        if (resolveS3UrlDto.isPrivate == "true") {
+            const expiryInSeconds = 60 * 60;
+            url = await this.fileService.getSignedUrl(s3Key, expiryInSeconds, resolveS3UrlDto.bucketName);
+        } else {
+            url = `https://${resolveS3UrlDto.bucketName}.s3.${this.configService.get('S3_AWS_REGION_NAME')}.amazonaws.com/${s3Key}`;
+        }
+        return { url: url }
+    }
 }
 
 

package/src/services/menu-item-metadata.service.ts

@@ -16,6 +16,7 @@ import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 import { dasherize } from '@angular-devkit/core/src/utils/strings';
 import { MenuItemMetadataRepository } from 'src/repository/menu-item-metadata.repository';
+import { SavedFiltersRepository } from 'src/repository/saved-filters.repository';
 
 @Injectable()
 export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
@@ -31,6 +32,7 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
     // @InjectRepository(MenuItemMetadata, 'default')
     // readonly repo: Repository<MenuItemMetadata>,
     readonly repo: MenuItemMetadataRepository,
+    readonly savedFiltersRepo: SavedFiltersRepository,
     readonly moduleRef: ModuleRef
 
   ) {
@@ -92,7 +94,7 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
       .leftJoinAndSelect('menuItem.parentMenuItem', 'parentMenuItem')
       .leftJoinAndSelect('menuItem.action', 'action')
       .leftJoinAndSelect('action.model', 'model') // Join the model relation of action
-      .leftJoinAndSelect('action.view', 'view') // Join the model relation of action
+      .leftJoinAndSelect('action.view', 'view') // Join the view relation of action
       .leftJoinAndSelect('menuItem.roles', 'roles')
       .where('roles.name IN (:...roleNames)', { roleNames: activeUser.roles })
       .addOrderBy('module.menuSequenceNumber', 'ASC')
@@ -120,73 +122,102 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
     // 3. Then for each module, do a recursive compilation of children based on parentMenuItem, while doing this use the relation - action to get hold of the path. 
     const menu: any[] = [];
 
-    modulesToMenuItemsMap.forEach((menuItems, moduleName) => {
-      const rootMenuItems = menuItems.filter(item => !item.parentMenuItem);
+    // modulesToMenuItemsMap.forEach((menuItems, moduleName) => {
+    //   const rootMenuItems = menuItems.filter(item => !item.parentMenuItem);
+    //   const moduleMetadata = modulesMap.get(moduleName);
+
+    //   const moduleMenu = {
+    //     title: moduleMetadata.displayName,
+    //     // No need for path the module level.
+    //     // path: ``,
+    //     key: moduleName.toLowerCase().replace(/\s+/g, '-'),
+    //     // TODO: We need to add the module icon as part of the metadata so it can be brought here. 
+    //     // icon: `/images/menu/${moduleName.toLowerCase().replace(/\s+/g, '-')}.svg`,
+    //     children: this.buildMenuTree(rootMenuItems, menuItems, activeUser),
+    //     icon: moduleMetadata.menuIconUrl,
+    //   };
+
+    //   menu.push(moduleMenu);
+    // });
+    for (const [moduleName, menuItemsForModule] of modulesToMenuItemsMap.entries()) {
+      const rootMenuItems = menuItemsForModule.filter(item => !item.parentMenuItem);
       const moduleMetadata = modulesMap.get(moduleName);
 
       const moduleMenu = {
         title: moduleMetadata.displayName,
-        // No need for path the module level.
-        // path: ``,
         key: moduleName.toLowerCase().replace(/\s+/g, '-'),
-        // TODO: We need to add the module icon as part of the metadata so it can be brought here. 
-        // icon: `/images/menu/${moduleName.toLowerCase().replace(/\s+/g, '-')}.svg`,
-        children: this.buildMenuTree(rootMenuItems, menuItems, activeUser),
+        children: await this.buildMenuTree(rootMenuItems, menuItemsForModule, activeUser), // ✅ await here
         icon: moduleMetadata.menuIconUrl,
       };
 
       menu.push(moduleMenu);
-    });
+    }
+
 
     return menu.filter(m => m.children.length > 0);
   }
 
   // Recursive function to build the tree
-  private buildMenuTree(rootItems: MenuItemMetadata[], allMenuItems: MenuItemMetadata[], activeUser: ActiveUserData): any[] {
-    const menuItemsData = rootItems.map(rootItem => {
-      const allowedMenuItems = allMenuItems.filter(i => {
-        if (!i.parentMenuItem) {
-          return true
-        } else {
-          return this.crudHelperService.hasReadPermissionOnModel(activeUser, i.action.model.singularName)
+  private async buildMenuTree(rootItems: MenuItemMetadata[], allMenuItems: MenuItemMetadata[], activeUser: ActiveUserData): Promise<any[]> {
+    const menuItemsData = await Promise.all(
+      rootItems.map(async rootItem => {
+        const allowedMenuItems = allMenuItems.filter(i => {
+          if (!i.parentMenuItem) {
+            return true
+          } else {
+            return this.crudHelperService.hasReadPermissionOnModel(activeUser, i.action.model.singularName)
+          }
+        });
+        // Get immediate children of the current loop variable menuItem.
+        const children = allowedMenuItems.filter(item => item.parentMenuItem && item.parentMenuItem.id === rootItem.id);
+        const menuItemId = rootItem?.id ?? "";
+        const menuItemName = rootItem?.name ?? "";
+        const actionId = rootItem?.action?.id ?? "";
+        const actionName = rootItem?.action?.name ?? "";
+        // TODO: We should specify path only if there are no more children present. 
+        // For now adding path everywhere. 
+        let path = '';
+
+        const layout = rootItem?.action?.view && rootItem?.action?.view?.layout ? JSON.parse(rootItem?.action?.view?.layout) : null
+        let savedFilterId = null;
+        if (layout && layout?.attrs?.defaultSavedFilter) {
+          const savedFilter = await this.savedFiltersRepo.findOne({
+            where: {
+              name: layout?.attrs?.defaultSavedFilter,
+              isPrivate: false
+            },
+          });
+          if (savedFilter) {
+            savedFilterId = savedFilter.id
+          }
         }
-      });
-      // Get immediate children of the current loop variable menuItem.
-      const children = allowedMenuItems.filter(item => item.parentMenuItem && item.parentMenuItem.id === rootItem.id);
-
-      // TODO: We should specify path only if there are no more children present. 
-      // For now adding path everywhere. 
-      let path = '';
-
-      if (rootItem.action && rootItem.action.type === 'custom') {
-        path = rootItem.action.customComponent;
-      }
-      if (rootItem.action && rootItem.action.type === 'solid') {
-        if (this.crudHelperService.hasReadPermissionOnModel(activeUser, rootItem.action.model.singularName)) {
-
-
-          // TODO: Here we are assuming that we will always take the user to collection view of a model. 
-          // We can make provision to take them other views also in the future. 
-          // path = `/admin/core/${rootItem.module.name}/${rootItem.action.model.singularName}/${rootItem.action.view.name}`;
-          path = `/admin/core/${rootItem.module.name}/${dasherize(rootItem.action?.model?.singularName ?? 'unknown')}/${rootItem.action?.view?.type ?? 'list'}`;
-
+        if (rootItem.action && rootItem.action.type === 'custom') {
+          path = `${rootItem.action.customComponent}?menuItemId=${menuItemId}&menuItemName=${menuItemName}&actionId=${actionId}&actionName=${actionName}${savedFilterId ? `&savedQuery=${savedFilterId}` : ''}`;
+        }
+        if (rootItem.action && rootItem.action.type === 'solid') {
+          if (this.crudHelperService.hasReadPermissionOnModel(activeUser, rootItem.action.model.singularName)) {
+            // TODO: Here we are assuming that we will always take the user to collection view of a model. 
+            // We can make provision to take them other views also in the future. 
+            // path = `/admin/core/${rootItem.module.name}/${rootItem.action.model.singularName}/${rootItem.action.view.name}`;
+            path = `/admin/core/${rootItem.module.name}/${dasherize(rootItem.action?.model?.singularName ?? 'unknown')}/${rootItem.action?.view?.type ?? 'list'}?menuItemId=${menuItemId}&menuItemName=${menuItemName}&actionId=${actionId}&actionName=${actionName}${savedFilterId ? `&savedQuery=${savedFilterId}` : ''}`;
+
+          }
         }
-      }
 
-      // We are not checking for empty path coz, this is required for parent menu items.
-      const data = {
-        title: rootItem.displayName || rootItem.name,
-        path: path,
-        key: rootItem.name.toLowerCase().replace(/\s+/g, '-'),
-        icon: rootItem.iconName,
-        // iconVariant : rootItem.iconVariant
-      }
-      if (children.length > 0) {
-        data["children"] = this.buildMenuTree(children, allMenuItems, activeUser);
-      }
-      return data;
+        // We are not checking for empty path coz, this is required for parent menu items.
+        const data = {
+          title: rootItem.displayName || rootItem.name,
+          path: path,
+          key: rootItem.name.toLowerCase().replace(/\s+/g, '-'),
+          icon: rootItem.iconName,
+          // iconVariant : rootItem.iconVariant
+        }
+        if (children.length > 0) {
+          data["children"] = await this.buildMenuTree(children, allMenuItems, activeUser);
+        }
+        return data;
 
-    });
+      }));
     return menuItemsData.filter(mi => mi && mi)
   }
 

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

@@ -270,6 +270,8 @@ export class ModelMetadataService {
         tableName: model.tableName,
         userKeyFieldUserKey: model.fields.find(field => field.isUserKey)?.name,
         isChild: model?.isChild,
+        isLegacyTable: model?.isLegacyTable,
+        isLegacyTableWithId: model?.isLegacyTableWithId,
         parentModelUserKey: model?.parentModel?.singularName,
         enableAuditTracking: model?.enableAuditTracking,
         enableSoftDelete: model?.enableSoftDelete,
@@ -1174,14 +1176,24 @@ export class ModelMetadataService {
     };
     const model = options.modelId ? await this.findOne(options.modelId, query) : await this.findOneByUserKey(options.modelUserKey, query.populate);
 
+    let fieldsForRefresh = model.fields.filter((field) => !field.isMarkedForRemoval);
+
+    // If a list of field ids or field names is passed for refresh, use these fields only
+    if (options.fieldIdsForRefresh && options.fieldIdsForRefresh.length > 0) {
+      fieldsForRefresh = fieldsForRefresh.filter((field) => options.fieldIdsForRefresh.includes(+field.id));
+    } else if (options.fieldNamesForRefresh && options.fieldNamesForRefresh.length > 0) {
+      fieldsForRefresh = fieldsForRefresh.filter((field) => options.fieldNamesForRefresh.includes(field.name));
+    }
+    // const fieldsForRefresh = model.fields.filter((field) => !field.isMarkedForRemoval);
+
     //Execute the schematic command to refresh the model
-    const refreshOuput = await this.executeRefreshModelCommand(model, options.dryRun);
+    const refreshOuput = await this.executeRefreshModelCommand(model, fieldsForRefresh, options.dryRun);
 
     return `${refreshOuput}`;
   }
 
-  private async executeRefreshModelCommand(model: ModelMetadata, dryRun: boolean = false): Promise<string> {
-    const fieldsForRefresh = model.fields.filter((field) => !field.isMarkedForRemoval);
+  private async executeRefreshModelCommand(model: ModelMetadata, fieldsForRefresh: FieldMetadata[], dryRun: boolean = false): Promise<string> {
+    // const fieldsForRefresh = model.fields.filter((field) => !field.isMarkedForRemoval);
     const output = await this.schematicService.executeSchematicCommand(
       REFRESH_MODEL_COMMAND,
       {
@@ -1195,6 +1207,9 @@ export class ModelMetadataService {
         parentModel: model.parentModel?.singularName,
         parentModule: model.parentModel?.module?.name,
         draftPublishWorkflowEnabled: model.draftPublishWorkflow,
+        isLegacyTable: model.isLegacyTable,
+        isLegacyTableWithId: model.isLegacyTableWithId,
+        dataSourceType: model.dataSourceType,
       },
       dryRun
     );