@solidstarters/solid-core 1.2.17 → 1.2.19

package/m21-12m.definition

@@ -0,0 +1,43 @@
+                // many-to-one field
+                // {
+                //     "name": "module",
+                //     "displayName": "Module",
+                //     "type": "relation",
+                //     "required": true,
+                //     "unique": false,
+                //     "index": true,
+                //     "private": false,
+                //     "encrypt": false,
+                //     "relationType": "many-to-one",
+                //     "relationModelSingularName": "moduleMetadata",
+                //     "relationCreateInverse": true,
+                //     "relationCascade": "set null",
+                //     "relationModelModuleName": "solid-core",
+                //     "isSystem": true
+                //   },
+
+                // one-to-many field
+                // {
+                //    "name": field.relationModelField,
+                // Logic to create a oneToMany field definition
+                // return [
+                //     "name",
+                //     "displayName",
+                //     "description",
+                //     "type",
+                //     "ormType",
+                //     "isSystem",
+                //     "relationType",
+                //     "relationModelFieldName",
+                //     "relationCreateInverse",
+                //     "relationModelSingularName",
+                //     "relationModelModuleName",
+                //     "required",
+                //     "unique",
+                //     "index",
+                //     "private",
+                //     "encrypt",
+                //     "encryptionType",
+                //     "decryptWhen",
+                //     "columnName"
+                // ];

package/package.json

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

@@ -256,8 +256,6 @@ export class CreateFieldMetadataDto {
   @ApiProperty({ description: 'for text fields, this is length. for numeric fields, this is the range of values allowed. Only for type=shortText,longText,richText,json,int,decimal,date,dateTime,time', })
   @IsInt()
   @IsOptional()
-  @Transform(({ obj }) => obj.length ?? undefined) // Automatically sets max = length
-  @ValidateIf((obj) => obj.length !== undefined)  // Only validate if length is provided
   max: number;
 
   @ApiProperty({ description: 'for text fields, this is length. for numeric fields, this is the range of values allowed. Only for type=shortText,longText,richText,json,int,decimal,date,dateTime,time', })
@@ -387,4 +385,19 @@ export class CreateFieldMetadataDto {
   @IsOptional()
   @IsBoolean()
   readonly isUserKey: boolean
+
+  @ApiProperty({ description: 'Relation Join Column Name of Field', })
+  @IsString()
+  @IsOptional()
+  relationJoinColumnName: string
+
+  @ApiProperty({ description: 'Join Column Name of Field', })
+  @IsString()
+  @IsOptional()
+  joinColumnName: string
+
+  @ApiProperty({ description: 'Relation Join Table Name of Field', })
+  @IsString()
+  @IsOptional()
+  relationJoinTableName: string
 }

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

@@ -137,4 +137,13 @@ export class FieldMetadata extends CommonEntity {
 
     @Column({ name: "isUserKey", default: false })
     isUserKey: boolean;
+
+    @Column({ name: 'relation_join_column_name', nullable: true })
+    relationJoinColumnName: string;
+
+    @Column({ name: 'join_column_name', nullable: true })
+    joinColumnName: string;
+
+    @Column({ name: 'relation_join_table_name', nullable: true })
+    relationJoinTableName: string;
 }

package/src/seeders/seed-data/solid-core-metadata.json

@@ -843,6 +843,45 @@
             "encrypt": false,
             "columnName": "required",
             "isSystem": true
+          },
+          {
+            "name": "relationJoinColumnName",
+            "displayName": "Relation Join Column Name",
+            "type": "shortText",
+            "ormType": "varchar",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "columnName": "relation_join_column_name",
+            "isSystem": true
+          },
+          {
+            "name": "joinColumnName",
+            "displayName": "Join Column Name",
+            "type": "shortText",
+            "ormType": "varchar",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "columnName": "join_column_name",
+            "isSystem": true
+          },
+          {
+            "name": "relationJoinTableName",
+            "displayName": "Relation Join Table Name",
+            "type": "shortText",
+            "ormType": "varchar",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "columnName": "relation_join_table_name",
+            "isSystem": true
           }
         ]
       },
@@ -1311,7 +1350,7 @@
             "name": "action",
             "displayName": "Action",
             "type": "relation",
-            "required": true,
+            "required": false,
             "unique": false,
             "index": true,
             "private": false,

package/src/services/crud.service.ts

@@ -311,7 +311,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                         const manyToOneOptions: ManyToOneRelationFieldOptions = {
                             ...commonOptions,
                             relationModelSingularName: fieldMetadata.relationModelSingularName,
-                            modelUserKeyFieldName: fieldMetadata.model.userKeyField.name,
+                            modelUserKeyFieldName: fieldMetadata.model.userKeyField?.name,
                             modelSingularName: fieldMetadata.model.singularName,
                             entityManager,
                         }

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

@@ -583,7 +583,10 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "relationJoinColumnName",
+                    "joinColumnName",
+                    "relationJoinTableName"
                 ];
 
             case SolidFieldType.mediaSingle:

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

@@ -184,8 +184,8 @@ export class ModelMetadataService {
       if (fieldMetadata.isUserKey) {
         userKeyField = affectedField;
       }
-      listViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}`, label: `${affectedField.displayName}`, sortable: true, filterable: true } })
-      formViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}`, label: `${affectedField.displayName}` } })
+      listViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}`, sortable: true, filterable: true } })
+      formViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}` } })
 
     }
 
@@ -324,7 +324,7 @@ export class ModelMetadataService {
         fields: []
       }
 
-      const listViewLayoutFields = [{ type: "field", attrs: { name: `id`, label: `Id`, sortable: true, filterable: true } }];
+      const listViewLayoutFields = [{ type: "field", attrs: { name: `id`, sortable: true, filterable: true } }];
       const formViewLayoutFields = [];
 
       for (let i = 0; i < model.fields.length; i++) {
@@ -339,8 +339,8 @@ export class ModelMetadataService {
             fieldObject[requiredField] = field[requiredField];
           });
           modelMetaData.fields.push(fieldObject);
-          listViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}`, label: `${field.displayName}`, sortable: true, filterable: true } })
-          formViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}`, label: `${field.displayName}` } })
+          listViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}`, sortable: true, filterable: true } })
+          formViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}` } })
 
         }
       }
@@ -681,20 +681,24 @@ export class ModelMetadataService {
 
   async generateCode(options: CodeGenerationOptions): Promise<string> {
     const query = {
-      populate: ["module", "fields"]
+        populate: ["module", "fields"]
     };
-    const model = options.modelId ? await this.findOne(options.modelId, query) : await this.findOneByUserKey(options.modelUserKey, query.populate);
-    options.fieldIdsForRemoval = model.fields.filter((field) => field.isMarkedForRemoval).map((field) => field.id);
+
+    const model = options.modelId 
+        ? await this.findOne(options.modelId, query) 
+        : await this.findOneByUserKey(options.modelUserKey, query.populate);
+
+    options.fieldIdsForRemoval = model.fields
+        .filter(field => field.isMarkedForRemoval)
+        .map(field => field.id);
 
     const refreshModelCodeOutput = await this.generateModelCode(options);
     const removeFieldCodeOuput = await this.generateRemoveFieldsCode(options);
 
-    // Extract listViewLayout and formViewLayout from model fields
     const listViewLayout = model.fields.map(field => ({
         type: "field",
         attrs: { 
             name: `${field.name}`, 
-            label: `${field.displayName}`, 
             sortable: true, 
             filterable: true 
         }
@@ -703,17 +707,18 @@ export class ModelMetadataService {
     const formViewLayout = model.fields.map(field => ({
         type: "field",
         attrs: { 
-            name: `${field.name}`, 
-            label: `${field.displayName}` 
+            name: `${field.name}`
         }
     }));
 
-    // Fetch module data
     const resolvedModule = await this.dataSource.getRepository(ModuleMetadata).findOne({
         where: { id: model.module.id }
     });
 
-    // Generate model views
+    const viewRepo = this.dataSource.getRepository(ViewMetadata);
+    const actionRepo = this.dataSource.getRepository(ActionMetadata);
+    const menuRepo = this.dataSource.getRepository(MenuItemMetadata);
+
     const modelViews = [
         {
             name: `${model.singularName}-list-view`,
@@ -733,7 +738,7 @@ export class ModelMetadataService {
                     delete: true
                 },
                 children: listViewLayout
-            }, null, 2)
+            }, null, 3)
         },
         {
             name: `${model.singularName}-form-view`,
@@ -764,27 +769,27 @@ export class ModelMetadataService {
                         ]
                     }
                 ]
-            }, null, 2)
+            }, null, 3)
         }
     ];
 
-    // Save views
-    const viewRepo = this.dataSource.getRepository(ViewMetadata);
     for (const view of modelViews) {
-        const createdView = viewRepo.create(view);
-        await viewRepo.save(createdView);
+        const existingView = await viewRepo.findOne({ where: { name: view.name } });
+
+        if (!existingView) {
+          const createdView = viewRepo.create(view);
+          await viewRepo.save(createdView);
+        }
     }
 
-    // Fetch the list view
-    const view = await viewRepo.findOneBy({ name: `${model.singularName}-list-view` });
+    let view = await viewRepo.findOne({ where: { name: `${model.singularName}-list-view` } });
 
-    // Generate action
-    const action = {
+    const actionData = {
         displayName: `${model.displayName} List View`,
         name: `${model.singularName}-list-view`,
         type: "solid",
-        domain: "",
-        context: "",
+        domain: "" as any,
+        context: "" as any,
         customComponent: `/admin/address-master/${model.singularName}/all`,
         customIsModal: true,
         serverEndpoint: "",
@@ -793,33 +798,35 @@ export class ModelMetadataService {
         model: model
     };
 
-    // Save action
-    const actionRepo = this.dataSource.getRepository(ActionMetadata);
-    const createdAction = actionRepo.create(action);
-    const newAction = await actionRepo.save(createdAction);
+    let existingAction = await actionRepo.findOne({ where: { name: actionData.name } });
+
+    if (!existingAction) {
+      const createdAction = actionRepo.create(actionData);
+      existingAction = await actionRepo.save(createdAction);
+    }
 
-    // Fetch Admin Role
     const adminRole = await this.roleService.findRoleByName('Admin');
 
-    // Generate menu
-    const menu = {
+    const menuData = {
         displayName: `${model.displayName}`,
-        name: `${model.singularName}`,
+        name: `${model.singularName}-menu-item`,
         sequenceNumber: 1,
-        action: newAction,
+        action: existingAction,
         module: resolvedModule,
         roles: [adminRole],
         parentMenuItemUserKey: ""
     };
 
-    // Save menu
-    const menuRepo = this.dataSource.getRepository(MenuItemMetadata);
-    const createdMenu = menuRepo.create(menu);
-    await menuRepo.save(createdMenu);
+    let existingMenu = await menuRepo.findOne({ where: { name: menuData.name } });
+
+    if (!existingMenu) {
+      const createdMenu = menuRepo.create(menuData);
+      await menuRepo.save(createdMenu);
+    }
+
     return `${removeFieldCodeOuput} \n ${refreshModelCodeOutput}`;
   }
 
-
   async generateRemoveFieldsCode(options: CodeGenerationOptions): Promise<string> {
     if (!options.modelId && !options.modelUserKey) {
       throw new BadRequestException('Model ID or Model Name is required for generating code');