@solidstarters/solid-core 1.2.20 → 1.2.22

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

@@ -1,16 +1,19 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-import { FieldMetadata } from '../entities/field-metadata.entity';
-import { DataSource, Repository, SelectQueryBuilder } from 'typeorm';
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
-import { CascadeType, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, PSQLType, RelationType, SelectionValueType } from '../dtos/create-field-metadata.dto';
-import { ModelMetadata } from '../entities/model-metadata.entity';
-import { SolidFieldType } from '../dtos/create-field-metadata.dto'
+import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
+import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
 import { SolidRegistry } from 'src/helpers/solid-registry';
+import { DataSource, Repository, SelectQueryBuilder } from 'typeorm';
 import { BasicFilterDto } from '../dtos/basic-filters.dto';
-import { CrudHelperService } from './crud-helper.service';
-import { UpdateFieldMetaDataDto } from '../dtos/update-field-metadata.dto';
+import { CascadeType, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, 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';
+import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ISelectionProviderValues } from '../interfaces';
+import { CrudHelperService } from './crud-helper.service';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+
 
 @Injectable()
 export class FieldMetadataService {
@@ -20,9 +23,174 @@ export class FieldMetadataService {
         @InjectDataSource()
         private readonly dataSource: DataSource,
         private readonly solidRegistry: SolidRegistry,
-        private readonly crudHelperService: CrudHelperService
+        private readonly crudHelperService: CrudHelperService,
+        private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
     ) { }
 
+    private logger = new Logger(FieldMetadataService.name);
+
+    async updateInverseField(field: FieldMetadata, fieldRepository: Repository<FieldMetadata>, modelRepository: Repository<ModelMetadata>) {
+        if (!field.model || !field.model.module) {
+            throw new Error('Model and module are required to update inverse field');
+        }
+        // Update the inverse field in the db
+        const savedInverseField = await this.updateInverseFieldInDb(field, fieldRepository, modelRepository);
+        // Update the inverse field in the file
+        this.updateRelationInverseFieldInFile(savedInverseField, field.relationModelSingularName, field.model.module.name);
+    }
+
+    private async updateInverseFieldInDb(field: FieldMetadata, fieldRepository: Repository<FieldMetadata>, modelRepository: Repository<ModelMetadata>): Promise<FieldMetadata> {
+        const { moduleName, modelName } = this.validateForInverseField(field);
+
+        // Get the relation model reference
+        const relationModel = await this.getRelationModel(modelRepository, field, moduleName);
+
+        // const {id, createdAt, updatedAt, deletedAt, ...fieldKeys} = field;
+        switch (field.relationType) {
+            case RelationType.manyToOne: {
+                const fieldName = field.relationModelFieldName || `${modelName}s`;
+                const inverseField: FieldMetadata = {
+                    ...field,
+                    name: fieldName,
+                    displayName: classify(fieldName),
+                    description: classify(fieldName),
+                    type: SolidFieldType.relation,
+                    isSystem: field.isSystem,
+                    relationType: RelationType.oneToMany,
+                    relationModelSingularName: modelName,
+                    relationCreateInverse: true,
+                    relationCascade: field.relationCascade,
+                    relationModelModuleName: moduleName,
+                    relationModelFieldName: field.name,
+                    required: false,
+                    unique: false,
+                    index: false,
+                    private: false,
+                    encrypt: false,
+                    model: relationModel,
+                    columnName:null,
+                    relationJoinTableName: null,
+                    relationJoinColumnName: null,
+                    joinColumnName: null,
+                    id : null,
+                }
+
+                // Load the inverse field, 
+                const savedField = await this.saveInverseField(fieldRepository, relationModel, inverseField);
+                return savedField;
+            }
+            case RelationType.oneToMany: {
+                const fieldName = field.relationModelFieldName || `${modelName}`;
+                const inverseField: FieldMetadata = {
+                    ...field,
+                    name: fieldName,
+                    displayName: classify(fieldName),
+                    description: classify(fieldName),
+                    type: SolidFieldType.relation,
+                    isSystem: field.isSystem,
+                    relationType: RelationType.manyToOne,
+                    relationModelSingularName: modelName,
+                    relationCreateInverse: true,
+                    relationCascade: null,
+                    relationModelModuleName: moduleName,
+                    relationModelFieldName: field.name,
+                    required: false,
+                    unique: false,
+                    index: false,
+                    private: false,
+                    encrypt: false,
+                    model: relationModel,
+                    columnName:null,
+                    relationJoinTableName: null,
+                    relationJoinColumnName: null,
+                    joinColumnName: null,
+                    id : null,
+                }
+
+                // Load the inverse field, 
+                const savedField = await this.saveInverseField(fieldRepository, relationModel, inverseField);
+                return savedField;
+            }
+            case RelationType.manyTomany: {
+                const fieldName = field.relationModelFieldName;
+                // Logic to create a manyToMany inverse field definition
+                const inverseFieldManyToMany: FieldMetadata = {
+                    ...field,
+                    name: fieldName,
+                    displayName: classify(fieldName),
+                    description: classify(fieldName),
+                    type: SolidFieldType.relation,
+                    isSystem: field.isSystem,
+                    relationType: RelationType.manyTomany,
+                    relationModelSingularName: modelName,
+                    relationCreateInverse: true,
+                    relationCascade: null,
+                    relationModelModuleName: moduleName,
+                    relationModelFieldName: field.name,
+                    required: false,
+                    unique: false,
+                    index: false,
+                    private: false,
+                    encrypt: false,
+                    model: relationModel,
+                    columnName:null,
+                    relationJoinTableName: null,
+                    relationJoinColumnName: null,
+                    joinColumnName: null,
+                    isRelationManyToManyOwner: false,
+                    id : null,
+                }
+                const savedField = await this.saveInverseField(fieldRepository, relationModel, inverseFieldManyToMany);
+                return savedField;
+            }
+            default:
+                throw new Error(`Invalid relation type for field ${field.name} with relation type  ${field.relationType}`);
+        }
+    }
+    
+    private async getRelationModel(modelRepository: Repository<ModelMetadata>, field: FieldMetadata, moduleName: string) {
+        return await modelRepository.findOne({
+            where: {
+                singularName: field.relationModelSingularName,
+                module: {
+                    name: field.relationModelModuleName ?? moduleName
+                }
+            }
+        });
+    }
+
+    private async saveInverseField(fieldRepository: Repository<FieldMetadata>, relationModel: ModelMetadata, inverseField: FieldMetadata): Promise<FieldMetadata> {
+        const existingInverseField = await fieldRepository.findOne({
+            where: {
+                model: relationModel,
+                name: inverseField.name
+            }
+        });
+
+        if (existingInverseField) {
+            const updatedField = fieldRepository.merge(existingInverseField, inverseField);
+            const savedField = await fieldRepository.save(updatedField);
+            return savedField;
+        }
+        else {
+            const savedField = await fieldRepository.save(fieldRepository.create(inverseField));
+            return savedField;
+        }
+    }
+
+    private validateForInverseField(field: FieldMetadata) {
+        if (field.type !== SolidFieldType.relation) {
+            throw new Error('Only relation fields can have inverse fields');
+        }
+        const modelName = field.model.singularName;
+        const moduleName = field.model.module.name;
+
+        if (!modelName || !moduleName) {
+            throw new Error('Model name and module name are required to create inverse field');
+        }
+        return { moduleName, modelName };
+    }
+
     async findMany(basicFilterDto: BasicFilterDto) {
         const alias = 'fieldMetadata';
         // Extract the required keys from the input query
@@ -586,7 +754,8 @@ export class FieldMetadataService {
                     "columnName",
                     "relationJoinColumnName",
                     "joinColumnName",
-                    "relationJoinTableName"
+                    "relationJoinTableName",
+                    "isRelationManyToManyOwner",
                 ];
 
             case SolidFieldType.mediaSingle:
@@ -874,4 +1043,54 @@ export class FieldMetadataService {
         return selectionProviderInstance.value(query.optionValue, selectionDynamicProviderCtxt);
     }
 
+    private async updateRelationInverseFieldInFile(savedInverseField: FieldMetadata, inverseModelName: string, moduleName: string) {
+        try {
+            const filePath = this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+            const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
+
+            // Create the config object for the inverse field
+            const fieldObject: Record<string, any> = await this.createFieldConfig(savedInverseField);
+
+            // Find the field config object in the json file
+            const model = metaData.moduleMetadata.models.find((model: any) => model.singularName === inverseModelName);
+
+            // Replace the current field object with the above field object
+            const fieldIndex = model.fields.findIndex((field: any) => field.name === savedInverseField.name);
+            if (fieldIndex === -1) {
+                model.fields.push(fieldObject);
+            }
+            else {
+                model.fields[fieldIndex] = fieldObject;
+            }
+
+            // Write the updated object back to the file
+            const updatedContent = JSON.stringify(metaData, null, 2);
+            await fs.writeFile(filePath, updatedContent);
+        } catch (error) {
+            this.logger.error('File creation failed:', error);
+            throw new Error('File creation failed, rolling back transaction'); // Trigger rollback
+        }
+    }
+
+    //Moved existing reusable logic to a separate function
+    async createFieldConfig(field: FieldMetadata) {
+        const fieldsRequiredBasedOnType = await this.fetchCurrentFieldsBasedOnType(field.type);
+        const fieldObject: Record<string, any> = {};
+
+        // Assign default or placeholder values for required fields
+        fieldsRequiredBasedOnType.forEach((requiredField) => {
+            fieldObject[requiredField] = field[requiredField];
+        });
+        
+        if (field.type == "mediaSingle" || field.type == "mediaMultiple") {
+            if (field.mediaStorageProvider) {
+                delete fieldObject.mediaStorageProviderId
+                fieldObject.mediaStorageProviderUserKey = field.mediaStorageProvider.name
+            }
+        }
+
+        return fieldObject;
+    }
 }
+
+

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

@@ -1,15 +1,19 @@
 import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
-import * as path from 'path'; // To handle file paths
 import { DataSource, EntityManager, Repository, SelectQueryBuilder } from 'typeorm';
 import { CreateModelMetadataDto } from '../dtos/create-model-metadata.dto';
 import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 
+import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
+import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
 import { BasicFilterDto } from '../dtos/basic-filters.dto';
 import { UpdateModelMetaDataDto } from '../dtos/update-model-metadata.dto';
+import { ActionMetadata } from '../entities/action-metadata.entity';
 import { FieldMetadata } from '../entities/field-metadata.entity';
+import { MenuItemMetadata } from '../entities/menu-item-metadata.entity';
+import { ViewMetadata } from '../entities/view-metadata.entity';
 import {
   REFRESH_MODEL_COMMAND,
   REMOVE_FIELDS_COMMAND,
@@ -19,11 +23,7 @@ import { CodeGenerationOptions } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
 import { FieldMetadataService } from './field-metadata.service';
 import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
-import { ViewMetadata } from '../entities/view-metadata.entity';
-import { ActionMetadata } from '../entities/action-metadata.entity';
-import { MenuItemMetadata } from '../entities/menu-item-metadata.entity';
 import { RoleMetadataService } from './role-metadata.service';
-import { PermissionMetadataSeederService } from 'src/seeders/permission-metadata-seeder.service';
 
 @Injectable()
 export class ModelMetadataService {
@@ -40,6 +40,7 @@ export class ModelMetadataService {
     private readonly mediaStorageProviderMetadataService: MediaStorageProviderMetadataService,
     private readonly fieldMetadataService: FieldMetadataService,
     private readonly roleService: RoleMetadataService,
+    private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
   ) { }
 
   async findMany(basicFilterDto: BasicFilterDto) {
@@ -118,17 +119,34 @@ export class ModelMetadataService {
 
     try {
       return await this.dataSource.transaction(async (manager: EntityManager) => {
+        const modelRepository = manager.getRepository(ModelMetadata);
+        const fieldRepository = manager.getRepository(FieldMetadata);
+
         // Step 1: Write initial data to the database
         const model = await this.createInDB(manager, createDto);
-        await this.createInFile(model.id, manager.getRepository(ModelMetadata));
+        await this.createInFile(model.id, modelRepository);
+
+        await this.handleInverseRelationFieldsUpdates(model, fieldRepository, modelRepository);
+
         return model
       });
     } catch (error) {
-      console.error('Transaction failed:', error);
+      // console.error('Transaction failed:', error);
+      this.logger.error('Transaction failed:', error);
       throw error;
     }
   }
 
+  // Iterate through the fields in the createDto & get all the relation fields which have create inverse as true
+  private async handleInverseRelationFieldsUpdates(model: ModelMetadata, fieldRepository: Repository<FieldMetadata>, modelRepository: Repository<ModelMetadata>) {
+    const fields: FieldMetadata[] = await this.getRelationInverseFields(model.id, fieldRepository);
+
+    // Call a function which will iterate through each field and create an inverse field entry for the respective model i.e call updateInverseField on the related model
+    for (const field of fields) {
+      await this.fieldMetadataService.updateInverseField(field, fieldRepository, modelRepository);
+    }
+  }
+
   async update(id: number, updateModelMetaDataDto: UpdateModelMetaDataDto) {
     //To DO start the transaction 
     // call create In db
@@ -136,13 +154,20 @@ export class ModelMetadataService {
 
     try {
       return await this.dataSource.transaction(async (manager: EntityManager) => {
+        const modelRepository = manager.getRepository(ModelMetadata);
+        const fieldRepository = manager.getRepository(FieldMetadata);
+
         // Step 1: Write initial data to the database
         const model = await this.updateInDb(manager, id, updateModelMetaDataDto)
-        await this.updateInFile(model.id, manager.getRepository(ModelMetadata));
+        await this.updateInFile(model.id, modelRepository);
+
+        await this.handleInverseRelationFieldsUpdates(model, fieldRepository, modelRepository);
+
         // return model
       });
     } catch (error) {
-      console.error('Transaction failed:', error);
+      // console.error('Transaction failed:', error);
+      this.logger.error('Transaction failed:', error);
       throw error;
     }
   }
@@ -177,6 +202,7 @@ export class ModelMetadataService {
         fieldMetadata['mediaStorageProvider'] = await this.mediaStorageProviderMetadataService.findOne(fieldMetadata.mediaStorageProviderId);
       }
       // console.log(fieldMetadata.displayName);
+      // this.logger.debug(fieldMetadata.displayName);
 
       const fieldMetadataObject = this.fieldMetadataRepo.create(fieldMetadata);
       const affectedField = await manager.save(fieldMetadataObject);
@@ -304,15 +330,11 @@ export class ModelMetadataService {
         where: {
           id: modelId,
         },
-        relations: ["fields", "module"], //FIXME: Check with jenender and change to relations to avoid confusion
+        relations: ["fields", "fields.mediaStorageProvider", "module"], //FIXME: Check with jenender and change to relations to avoid confusion
       });
 
-      const folderPath = path.resolve(process.cwd(), 'module-metadata', model.module.name);
-      const filePath = path.join(folderPath, `${model.module.name}-metadata.json`);
-
-      // Read the existing JSON file
-      const fileContent = await fs.readFile(filePath, 'utf8');
-      const metaData = JSON.parse(fileContent);
+      const filePath = this.moduleMetadataHelperService.getModuleMetadataFilePath(model.module.name);
+      const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
 
       const modelMetaData = {
         singularName: model.singularName,
@@ -331,13 +353,7 @@ export class ModelMetadataService {
         const field = model.fields[i];
         if (!field.isSystem) {
 
-          const fieldsRequiredBasedOnType = await this.fieldMetadataService.fetchCurrentFieldsBasedOnType(field.type);
-          const fieldObject: Record<string, any> = {};
-
-          // Assign default or placeholder values for required fields
-          fieldsRequiredBasedOnType.forEach((requiredField) => {
-            fieldObject[requiredField] = field[requiredField];
-          });
+          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}` } })
@@ -435,7 +451,8 @@ export class ModelMetadataService {
       await fs.writeFile(filePath, updatedContent);
 
     } catch (error) {
-      console.error('File creation failed:', error);
+      // console.error('File creation failed:', error);
+      this.logger.error('File creation failed:', error);
       throw new Error('File creation failed, rolling back transaction'); // Trigger rollback
     }
   }
@@ -476,7 +493,7 @@ export class ModelMetadataService {
         // Existing field
         const existingField = existingFields.find((field) => field.id === fieldMetadata.id);
         if (existingField) {
-          if (fieldMetadata.mediaStorageProviderId) {
+          if (fieldMetadata.mediaStorageProviderId) { 
             fieldMetadata['mediaStorageProvider'] = await this.mediaStorageProviderMetadataService.findOne(fieldMetadata.mediaStorageProviderId);
           }
           Object.assign(existingField, fieldMetadata);
@@ -562,12 +579,8 @@ export class ModelMetadataService {
         relations: ["fields", "fields.mediaStorageProvider", "module"], //FIXME: Check with jenender and change to relations to avoid confusion
       });
 
-      const folderPath = path.resolve(process.cwd(), 'module-metadata', model.module.name);
-      const filePath = path.join(folderPath, `${model.module.name}-metadata.json`);
-
-      // Read the existing JSON file
-      const fileContent = await fs.readFile(filePath, 'utf8');
-      const metaData = JSON.parse(fileContent);
+      const filePath = this.moduleMetadataHelperService.getModuleMetadataFilePath(model.module.name);
+      const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
 
       const modelMetaData = {
         singularName: model.singularName,
@@ -583,18 +596,7 @@ export class ModelMetadataService {
         const field = model.fields[i];
         if (!field.isSystem && !field.isMarkedForRemoval) {
 
-          const fieldsRequiredBasedOnType = await this.fieldMetadataService.fetchCurrentFieldsBasedOnType(field.type);
-          const fieldObject: Record<string, any> = {};
-
-          // Assign default or placeholder values for required fields
-          fieldsRequiredBasedOnType.forEach((requiredField) => {
-            fieldObject[requiredField] = field[requiredField];
-
-          });
-          if (field.type == "mediaSingle" || field.type == "mediaMultiple") {
-            delete fieldObject.mediaStorageProviderId
-            fieldObject.mediaStorageProviderUserKey = field.mediaStorageProvider.name
-          }
+          const fieldObject: Record<string, any> = await this.fieldMetadataService.createFieldConfig(field);
           modelMetaData.fields.push(fieldObject);
         }
       }
@@ -617,7 +619,8 @@ export class ModelMetadataService {
       await fs.writeFile(filePath, updatedContent);
 
     } catch (error) {
-      console.error('File creation failed:', error);
+      // console.error('File creation failed:', error);
+      this.logger.error('File creation failed:', error);
       throw new Error('File creation failed, rolling back transaction'); // Trigger rollback
     }
   }
@@ -907,5 +910,56 @@ export class ModelMetadataService {
     return output;
   }
 
+  async updateUserKey(data: any) {
+    const { modelName, fieldName } = data;
+
+    const model = await this.modelMetadataRepo.findOne({
+        where: { singularName: modelName },
+        relations: ['fields', 'userKeyField'],
+    });
+
+    if (!model) {
+        throw new Error(`Model with name ${modelName} not found`);
+    }
+
+    if (model.userKeyField) {
+      throw new Error(`User key is already set to ${model.userKeyField.name}. No changes were made.`);
+    }
+
+    const fieldToUpdate = model.fields.find(field => field.name === fieldName);
+    if (!fieldToUpdate) {
+        throw new Error(`Field with name ${fieldName} not found in model ${modelName}`);
+    }
+
+    fieldToUpdate.isUserKey = true;
+
+    model.userKeyField = fieldToUpdate;
+
+    await this.modelMetadataRepo.save(model);
+
+    return {
+      message: `User key has been successfully updated to ${fieldName}.`,
+      success: true
+    };
+  }
+
+  private async getRelationInverseFields(modelId: number, repo: Repository<FieldMetadata>): Promise<FieldMetadata[]> {
+    return await repo.find({
+      where: {
+        model : {
+          id: modelId
+        },
+        type: SolidFieldType.relation,
+        relationCreateInverse: true
+      },
+      relations: {
+        model: {
+          module: true
+        }
+      }
+    });
+  }
 
 }
+
+

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

@@ -20,6 +20,7 @@ import { SolidRegistry } from '../helpers/solid-registry';
 import { CodeGenerationOptions, ModuleMetadataConfiguration } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
 import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
 
 @Injectable()
 export class ModuleMetadataService {
@@ -38,6 +39,7 @@ export class ModuleMetadataService {
     @Inject(forwardRef(() => ModelMetadataService))
     private readonly modelMetadataService: ModelMetadataService,
     private readonly solidRegistry: SolidRegistry,
+    private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
   ) { }
 
   async findMany(basicFilterDto: BasicFilterDto) {
@@ -110,7 +112,8 @@ export class ModuleMetadataService {
         return module
       });
     } catch (error) {
-      console.error('Transaction failed:', error);
+      // console.error('Transaction failed:', error);
+      this.logger.error('Transaction failed:', error);
       throw error;
     }
   }
@@ -154,7 +157,7 @@ export class ModuleMetadataService {
 
       // Create the folder path inside 'module-metadata'
       const folderPath = path.resolve(process.cwd(), 'module-metadata', module.name);
-      const filePath = this.getModuleMetadataFilePath(module);
+      const filePath = this.moduleMetadataHelperService.getModuleMetadataFilePath(module.name);
 
       // Ensure the folder exists
       await fs.mkdir(folderPath, { recursive: true });
@@ -163,7 +166,8 @@ export class ModuleMetadataService {
       await fs.writeFile(filePath, metadataJson);
 
     } catch (error) {
-      console.error('File creation failed:', error);
+      // console.error('File creation failed:', error);
+      this.logger.error('File creation failed:', error);
       throw new Error('File creation failed, rolling back transaction'); // Trigger rollback
     }
   }
@@ -177,7 +181,8 @@ export class ModuleMetadataService {
         return module
       });
     } catch (error) {
-      console.error('Transaction failed:', error);
+      // console.error('Transaction failed:', error);
+      this.logger.error('Transaction failed:', error);
       throw error;
     }
   }
@@ -205,12 +210,12 @@ export class ModuleMetadataService {
 
   async updateInFile(module: ModuleMetadata) {
     try {
-      const filePath = this.getModuleMetadataFilePath(module);
+      const filePath = this.moduleMetadataHelperService.getModuleMetadataFilePath(module.name);
 
       // Read the existing JSON file
       let metaData;
       try {
-        metaData = await this.getModuleMetadata(filePath);
+        metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
 
       } catch (error) {
         metaData = {
@@ -249,23 +254,13 @@ export class ModuleMetadataService {
       await fs.writeFile(filePath, updatedContent);
 
     } catch (error) {
-      console.error('File creation failed:', error);
+      // console.error('File creation failed:', error);
+      this.logger.error('File creation failed:', error);
       throw new Error('File creation failed, rolling back transaction'); // Trigger rollback
     }
   }
 
 
-  private async getModuleMetadata(filePath: string): Promise<any> {
-    const fileContent = await fs.readFile(filePath, 'utf8');
-    return JSON.parse(fileContent);
-  }
-
-  private getModuleMetadataFilePath(module: ModuleMetadata) {
-    const folderPath = path.resolve(process.cwd(), 'module-metadata', module.name);
-    const filePath = path.join(folderPath, `${module.name}-metadata.json`);
-    return filePath;
-  }
-
   async upsert(updateModuleMetadataDto: UpdateModuleMetadataDto) {
     this.logger.log(`Module Upsert called for : ${updateModuleMetadataDto.name}`);
     // First check if module already exists using name

package/src/services/solid-introspect.service.ts

@@ -128,21 +128,23 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     return !!isSolidDatabaseModule;
   }
 
-  private isModule(provider: InstanceWrapper) {
-    // Check if the provider is a module
+
+  private isModule(provider: InstanceWrapper): boolean {
     const metatype = provider.metatype;
-    return metatype && Reflect.getMetadata('imports', metatype); 
+    // Check if it's a Static Module (Class-Based)
+    if (metatype && typeof metatype === 'function' && Reflect.getMetadata('imports', metatype)) {
+      return true;
+    }
+  
+    // Ensure provider.instance is an object before checking for 'module'
+    if (provider.instance && typeof provider.instance === 'object') {
+      // Check if it's a Dynamic Module (Object-Based)
+      if ('module' in provider.instance && typeof provider.instance.module === 'function') {
+        return true;
+      }
+    }
+  
+    return false;
   }
-  // This method uses the @SolidSeeder decorator to identify if a provider is a seeder
-  // private isSeeder(provider: InstanceWrapper) {
-  //   const { instance } = provider;
-  //   if (!instance) return false;
-
-  //   const seederMetadata = this.reflector.get(
-  //     'SOLID_SERVICE',
-  //     instance.constructor,
-  //   );
-  //   if (!seederMetadata || !seederMetadata.seeder) return false;
-  //   return true;
-  // }
+
 }

package/src/solid-core.module.ts

@@ -135,6 +135,7 @@ import { UserService } from './services/user.service';
 import { Setting } from './entities/setting.entity';
 import { SettingService } from './services/setting.service';
 import { SettingController } from './controllers/setting.controller';
+import { ModuleMetadataHelperService } from './helpers/module-metadata-helper.service';
 
 
 @Global()
@@ -223,6 +224,7 @@ import { SettingController } from './controllers/setting.controller';
       useClass: PermissionsGuard,
     },
     ModuleMetadataService,
+    ModuleMetadataHelperService,
     ModelMetadataService,
     FieldMetadataService,
     RemoveFieldsCommand,