@solidstarters/solid-core 1.2.20 → 1.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.20",
+  "version": "1.2.21",
   "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

@@ -142,6 +142,7 @@ export enum MediaType {
 export enum RelationType {
   manyToOne = 'many-to-one',
   manyTomany = 'many-to-many',
+  oneToMany = 'one-to-many',
 }
 
 export enum CascadeType {
@@ -320,6 +321,10 @@ export class CreateFieldMetadataDto {
   @IsOptional()
   relationModelFieldName: string;
 
+  @ApiProperty({description: 'Only for type=relation, many-to-many. This field is used to set the owner of the many-to-many relation'})
+  @IsOptional()
+  isRelationManyToManyOwner: boolean;
+
   @ApiProperty({
     description:
       'Dynamic provider for selection. Only for type=selectionDynamic',

package/src/entities/field-metadata.entity.ts

@@ -99,6 +99,9 @@ export class FieldMetadata extends CommonEntity {
     @Column({ name: 'relation_model_field_name', nullable: true })
     relationModelFieldName: string;
 
+    @Column({ name: 'is_relation_many_to_many_owner', nullable: true })
+    isRelationManyToManyOwner: boolean;
+
     @Column({ name: 'selection_dynamic_provider', nullable: true })
     selectionDynamicProvider: string;
 

package/src/helpers/module-metadata-helper.service.ts

@@ -0,0 +1,25 @@
+import { Injectable, ModuleMetadata } from "@nestjs/common";
+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 { ModuleMetadataConfiguration } from "src/interfaces";
+
+@Injectable()
+export class ModuleMetadataHelperService {
+    // async getModuleMetadataConfig(moduleName: string): Promise<ModuleMetadata> {
+    //     const filePath = this.getModuleMetadataFilePath(moduleName);
+    //     const metadata = await this.getModuleMetadata(filePath);
+    //     return metadata;
+    // }
+
+    async getModuleMetadataConfiguration(configFilePath: string): Promise<any> {
+        const fileContent = await fs.readFile(configFilePath, 'utf8');
+        return JSON.parse(fileContent);
+    }
+
+    getModuleMetadataFilePath(moduleName: string): string {
+        const folderPath = path.resolve(process.cwd(), 'module-metadata', moduleName);
+        const filePath = path.join(folderPath, `${moduleName}-metadata.json`);
+        return filePath;
+    }
+
+}

package/src/services/crud.service.ts

@@ -66,8 +66,8 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         let hasMediaFields = false;
 
         const model = await this.loadModel();
-        const inverseRelationFields = await this.loadInverseRelationFields();
-        const fieldsToProcess = [...model.fields, ...inverseRelationFields];
+        // const inverseRelationFields = await this.loadInverseRelationFields();
+        const fieldsToProcess = [...model.fields];
 
         // 2. Loop through the fields with a switch statement
         // 3. Handle the fields based on field type
@@ -185,8 +185,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         let hasMediaFields = false;
 
         const model = await this.loadModel();
-        const inverseRelationFields = await this.loadInverseRelationFields();
-        const fieldsToProcess = [...model.fields, ...inverseRelationFields];
+        const fieldsToProcess = [...model.fields];
 
         // 2. Loop through the fields with a switch statement
         // 3. Handle the fields based on field type
@@ -305,9 +304,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
             }
             case SolidFieldType.relation: {
                 // Identify if the field is for the inverse side or not
-                const inverseSide = (fieldMetadata.model.singularName !== this.modelName) ? true : false;
                 if (fieldMetadata.relationType === RelationType.manyToOne) {
-                    if (!inverseSide) {
                         const manyToOneOptions: ManyToOneRelationFieldOptions = {
                             ...commonOptions,
                             relationModelSingularName: fieldMetadata.relationModelSingularName,
@@ -316,23 +313,20 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                             entityManager,
                         }
                         return new ManyToOneRelationFieldCrudManager(manyToOneOptions);
-                    }
-                    else {
-                        const inverseFieldMetadata = fieldMetadata; //Setting an alias for clarity purpose
+                }
+                else if (fieldMetadata.relationType === RelationType.oneToMany) {
                         const oneToManyOptions: OneToManyRelationFieldOptions = {
                             ...commonOptions,
-                            required: false,
-                            relationModelSingularName: inverseFieldMetadata.model.singularName,
-                            modelSingularName: inverseFieldMetadata.relationModelSingularName,
+                            relationModelSingularName: fieldMetadata.relationModelSingularName,
+                            modelSingularName: fieldMetadata.model.singularName,
                             entityManager,
-                            inverseFieldName: inverseFieldMetadata.name,
-                            inverseRelationModelFieldName: inverseFieldMetadata.relationModelFieldName,
+                            inverseFieldName: fieldMetadata.relationModelFieldName,
+                            inverseRelationModelFieldName: fieldMetadata.name,
                         }
                         return new OneToManyRelationFieldCrudManager(oneToManyOptions);
-                    }
                 }
                 else if (fieldMetadata.relationType === RelationType.manyTomany) {
-                    if (!inverseSide) {
+                    if (fieldMetadata.isRelationManyToManyOwner) {
                         const manyToManyOptions: ManyToManyRelationFieldOptions = {
                             ...commonOptions,
                             relationModelSingularName: fieldMetadata.relationModelSingularName,
@@ -344,16 +338,14 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                         return new ManyToManyRelationFieldCrudManager(manyToManyOptions); 
                     }
                     else {
-                        const inverseFieldMetadata = fieldMetadata; //Setting an alias for clarity purpose
                         const inverseManyToManyOptions: ManyToManyRelationFieldOptions = {
                             ...commonOptions,
-                            required: false,
-                            relationModelSingularName: inverseFieldMetadata.model.singularName,
-                            modelSingularName: inverseFieldMetadata.relationModelSingularName,
+                            relationModelSingularName: fieldMetadata.relationModelSingularName,
+                            modelSingularName: fieldMetadata.model.singularName,
                             isInverseSide: true,
                             entityManager,
-                            fieldName: inverseFieldMetadata.name,
-                            relationModelFieldName: inverseFieldMetadata.relationModelFieldName,
+                            fieldName: fieldMetadata.relationModelFieldName,
+                            relationModelFieldName: fieldMetadata.name,
                         }
                         return new ManyToManyRelationFieldCrudManager(inverseManyToManyOptions);
                     }

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

@@ -1,16 +1,18 @@
-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';
+
 
 @Injectable()
 export class FieldMetadataService {
@@ -20,9 +22,146 @@ 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 inverseField: FieldMetadata = {
+                    ...field,
+                    name: field.relationModelFieldName ?? `${modelName}s`,
+                    displayName: `Inverse ${field.displayName}`,
+                    description: `Inverse field for ${field.displayName}`,
+                    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,
+                    // createdAt: null,
+                    // updatedAt: null,
+                    // deletedAt: null,
+                }
+
+                // Load the inverse field, 
+                const savedField = await this.saveInverseField(fieldRepository, relationModel, inverseField);
+                return savedField;
+            }
+            case RelationType.manyTomany: {
+                // Logic to create a manyToMany inverse field definition
+                const inverseFieldManyToMany: FieldMetadata = {
+                    ...field,
+                    name: field.relationModelFieldName,
+                    displayName: `Inverse ${field.displayName}`,
+                    description: `Inverse field for ${field.displayName}`,
+                    type: SolidFieldType.relation,
+                    isSystem: field.isSystem,
+                    relationType: RelationType.manyTomany,
+                    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,
+                    isRelationManyToManyOwner: false,
+                    id : null,
+                    // createdAt: null,
+                    // updatedAt: null,
+                    // deletedAt: 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 +725,8 @@ export class FieldMetadataService {
                     "columnName",
                     "relationJoinColumnName",
                     "joinColumnName",
-                    "relationJoinTableName"
+                    "relationJoinTableName",
+                    "isRelationManyToManyOwner",
                 ];
 
             case SolidFieldType.mediaSingle:
@@ -874,4 +1014,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,9 +119,15 @@ 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) {
@@ -129,6 +136,16 @@ export class ModelMetadataService {
     }
   }
 
+  // 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,9 +153,15 @@ 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) {
@@ -304,15 +327,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 +350,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}` } })
@@ -476,7 +489,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 +575,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 +592,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);
         }
       }
@@ -908,4 +906,23 @@ export class ModelMetadataService {
   }
 
 
+  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) {
@@ -154,7 +156,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 });
@@ -205,12 +207,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 = {
@@ -255,17 +257,6 @@ export class ModuleMetadataService {
   }
 
 
-  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/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,