@solidstarters/solid-core 1.2.155 → 1.2.156

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.155",
+  "version": "1.2.156",
   "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-list-of-values.dto.ts

@@ -27,4 +27,11 @@ export class CreateListOfValuesDto {
     @IsInt()
     @ApiProperty()
     sequence: number;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    moduleId: number;
+    @IsString()
+    @IsOptional()
+    moduleUserKey: string;
 }

package/src/dtos/update-list-of-values.dto.ts

@@ -1,4 +1,4 @@
-import { IsInt,IsOptional, IsString, IsNotEmpty, IsBoolean } from 'class-validator';
+import { IsInt, IsOptional, IsString, IsNotEmpty, IsBoolean } from 'class-validator';
 import { ApiProperty } from '@nestjs/swagger';
 
 export class UpdateListOfValuesDto {
@@ -33,4 +33,11 @@ export class UpdateListOfValuesDto {
     @IsInt()
     @ApiProperty()
     sequence: number;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    moduleId: number;
+    @IsString()
+    @IsOptional()
+    moduleUserKey: string;
 }

package/src/entities/list-of-values.entity.ts

@@ -1,5 +1,6 @@
 import { CommonEntity } from 'src/entities/common.entity'
-import {Entity, Column} from 'typeorm'
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm'
+import { ModuleMetadata } from 'src/entities/module-metadata.entity'
 
 @Entity("ss_list_of_values")
 export class ListOfValues extends CommonEntity {
@@ -15,4 +16,7 @@ export class ListOfValues extends CommonEntity {
     default: boolean = false;
     @Column({ type: "int", nullable: true })
     sequence: number;
+    @ManyToOne(() => ModuleMetadata, { onDelete: "CASCADE", nullable: true })
+    @JoinColumn()
+    module: ModuleMetadata;
 }

package/src/mappers/list-of-values-mapper.ts

@@ -0,0 +1,17 @@
+import { Injectable } from "@nestjs/common";
+import { ListOfValues } from "src/entities/list-of-values.entity";
+
+@Injectable()
+export class ListOfValuesMapper {
+    toDto(listOfValue: ListOfValues): any {
+        return {
+            type: listOfValue.type,
+            value: listOfValue.value,
+            display: listOfValue.display,
+            description: listOfValue.description,
+            default: listOfValue.default,
+            sequence: listOfValue.sequence,
+            module: listOfValue.module ? listOfValue.module.id : null
+        };
+    }
+}

package/src/seeders/module-metadata-seeder.service.ts

@@ -584,7 +584,7 @@ export class ModuleMetadataSeederService {
             return;
         }
         for (let j = 0; j < listOfValuesDto.length; j++) {
-            await this.listOfValuesService.upsert(listOfValuesDto);
+            await this.listOfValuesService.upsert(listOfValuesDto[j]);
         }
     }
 

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

@@ -3642,6 +3642,23 @@
             "private": false,
             "encrypt": false,
             "isSystem": false
+          },
+          {
+            "name": "module",
+            "displayName": "Module",
+            "type": "relation",
+            "ormType": "integer",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "relationType": "many-to-one",
+            "relationCreateInverse": false,
+            "relationCoModelSingularName": "moduleMetadata",
+            "relationModelModuleName": "solid-core",
+            "relationCascade": "cascade",
+            "isSystem": true
           }
         ]
       },
@@ -6459,73 +6476,6 @@
         ]
       }
     },
-    {
-      "name": "listOfValues-list-view",
-      "displayName": "List of Values list view",
-      "type": "list",
-      "context": "{}",
-      "moduleUserKey": "solid-core",
-      "modelUserKey": "listOfValues",
-      "layout": {
-        "type": "list",
-        "attrs": {
-          "pagination": true,
-          "pageSizeOptions": [
-            10,
-            25,
-            50
-          ],
-          "enableGlobalSearch": true,
-          "create": true,
-          "edit": true,
-          "delete": true
-        },
-        "children": [
-          {
-            "type": "field",
-            "attrs": {
-              "name": "type",
-              "isSearchable": true
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "value",
-              "isSearchable": true
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "display",
-              "isSearchable": true
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "description",
-              "isSearchable": true
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "default",
-              "isSearchable": true
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "sequence",
-              "isSearchable": true
-            }
-          }
-        ]
-      }
-    },
     {
       "name": "listOfValues-form-view",
       "displayName": "List of Values form view",
@@ -6590,6 +6540,12 @@
                     "attrs": {
                       "name": "sequence"
                     }
+                  },
+                  {
+                    "type": "field",
+                    "attrs": {
+                      "name": "module"
+                    }
                   }
                 ]
               }
@@ -6899,78 +6855,12 @@
               "name": "sequence",
               "isSearchable": true
             }
-          }
-        ]
-      }
-    },
-    {
-      "name": "listOfValues-form-view",
-      "displayName": "List of Values form view",
-      "type": "form",
-      "context": "{}",
-      "moduleUserKey": "solid-core",
-      "modelUserKey": "listOfValues",
-      "layout": {
-        "type": "form",
-        "attrs": {
-          "name": "form-1",
-          "label": "Solid List of Values Model",
-          "className": "grid"
-        },
-        "children": [
+          },
           {
-            "type": "sheet",
+            "type": "field",
             "attrs": {
-              "name": "sheet-1"
-            },
-            "children": [
-              {
-                "type": "group",
-                "attrs": {
-                  "name": "group-1",
-                  "label": "",
-                  "className": "col-6"
-                },
-                "children": [
-                  {
-                    "type": "field",
-                    "attrs": {
-                      "name": "type"
-                    }
-                  },
-                  {
-                    "type": "field",
-                    "attrs": {
-                      "name": "value"
-                    }
-                  },
-                  {
-                    "type": "field",
-                    "attrs": {
-                      "name": "display"
-                    }
-                  },
-                  {
-                    "type": "field",
-                    "attrs": {
-                      "name": "description"
-                    }
-                  },
-                  {
-                    "type": "field",
-                    "attrs": {
-                      "name": "default"
-                    }
-                  },
-                  {
-                    "type": "field",
-                    "attrs": {
-                      "name": "sequence"
-                    }
-                  }
-                ]
-              }
-            ]
+              "name": "module"
+            }
           }
         ]
       }

package/src/services/list-of-values-metadata.service.ts

@@ -0,0 +1,219 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { EntityManager, Repository } from 'typeorm';
+
+import { ConfigService } from '@nestjs/config';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { CRUDService } from 'src/services/crud.service';
+import { FileService } from 'src/services/file.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+
+
+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 { ListOfValues } from 'src/entities/list-of-values.entity';
+import { ListOfValuesMapper } from 'src/mappers/list-of-values-mapper';
+
+
+
+@Injectable()
+export class ListOfValuesMetadataService extends CRUDService<ListOfValues> {
+  private readonly logger = new Logger(this.constructor.name);
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    readonly listOfValuesMapper: ListOfValuesMapper,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ListOfValues, 'default')
+    readonly repo: Repository<ListOfValues>,
+    readonly moduleRef: ModuleRef,
+    readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'listOfValues', 'solid-core', moduleRef);
+  }
+
+  async saveListofValuesToConfig(entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // Write the listofvalue to the config file
+    await this.writeToConfig(metaData, listofvalue, filePath);
+  }
+
+  async updateListofValuesToConfig(oldentity: ListOfValues, entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const oldlistofvalue = oldentity as ListOfValues;
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // Write the listofvalue to the config file
+    await this.updateToConfig(metaData, oldlistofvalue, listofvalue, filePath);
+  }
+
+  async deleteListOfValuesFromConfig(entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // delete the listofvalue to the config file
+    await this.deleteFromConfig(metaData, listofvalue, filePath);
+  }
+
+
+
+  private async getConfigFileDetails(moduleName: string): Promise<{ filePath: string; metaData: any }> {
+    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+    try {
+      await fs.access(filePath);
+    } catch (error) {
+      throw new Error(`Configuration file not found for module: ${moduleName}`);
+    }
+    const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
+    return { filePath, metaData };
+  }
+
+  private async writeToConfig(metaData: any, listofvalues: ListOfValues, filePath: string) {
+    const dto = await this.listOfValuesMapper.toDto(listofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    // Match by type + value + module
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === dto.type &&
+        item.value === dto.value &&
+        item.module === dto.module
+    );
+
+    if (existingIndex !== -1) {
+      // Replace existing entry
+      metaData.listOfValues[existingIndex] = dto;
+    } else {
+      // Insert new entry
+      // metaData.listOfValues.unshift(dto);
+
+      if (metaData.listOfValues.length === 0) {
+        // Case 1: Empty array → add first item
+        metaData.listOfValues.push(dto);
+      } else {
+        // Case 2: Insert new item right after index 0
+        metaData.listOfValues.unshift(dto);
+      }
+
+    }
+
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+  }
+
+  private async updateToConfig(metaData: any, oldlistofvalues: ListOfValues, listofvalues: ListOfValues, filePath: string) {
+    const newvalue = await this.listOfValuesMapper.toDto(listofvalues);
+    const oldvalue = await this.listOfValuesMapper.toDto(oldlistofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    const searchType = oldvalue.type || newvalue.type;
+    const searchValue = oldvalue.value || newvalue.value;
+    const searchModule = oldvalue.module || newvalue.module;
+
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === searchType && item.value === searchValue && item.module === searchModule
+    );
+    if (existingIndex !== -1) {
+      // Replace existing match
+      metaData.listOfValues[existingIndex] = newvalue;
+    }
+
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+  }
+
+
+  private async deleteFromConfig(metaData: any, listofvalues: ListOfValues, filePath: string) {
+    const dto = await this.listOfValuesMapper.toDto(listofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    // Match by type + value + module
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === dto.type &&
+        item.value === dto.value &&
+        item.module === dto.module
+    );
+
+    if (existingIndex !== -1) {
+      // Remove the item
+      metaData.listOfValues.splice(existingIndex, 1);
+      this.logger.debug(`Deleted LOV ${dto.type}:${dto.value} (module ${dto.module}) from config`);
+    } else {
+      this.logger.warn(
+        `LOV ${dto.type}:${dto.value} (module ${dto.module}) not found in config during delete`
+      );
+    }
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+
+  }
+
+
+}

package/src/solid-core.module.ts

@@ -266,6 +266,9 @@ import { NoopsEntityComputedFieldProviderService } from './services/computed-fie
 import { ScheduledJobRepository } from './repository/scheduled-job.repository';
 import { ScheduledJobSubscriber } from './subscribers/scheduled-job.subscriber';
 import { AlphaNumExternalIdComputationProvider } from './services/computed-fields/entity/alpha-num-external-id-computed-field-provider';
+import { ListOfValuesMapper } from './mappers/list-of-values-mapper';
+import { ListOfValuesMetadataSubscriber } from './subscribers/list-of-values-metadata.subscriber';
+import { ListOfValuesMetadataService } from './services/list-of-values-metadata.service';
 import { MailFactory } from './factories/mail.factory';
 import { TwilioSMSService } from './services/sms/TwilioSMSService';
 import { PollerService } from './services/poller.service';
@@ -587,6 +590,9 @@ import { ChatterMessageDetailsRepository } from './repository/chatter-message-de
     ScheduledJobRepository,
     ScheduledJobSubscriber,
     AlphaNumExternalIdComputationProvider,
+    ListOfValuesMetadataService,
+    ListOfValuesMetadataSubscriber,
+    ListOfValuesMapper,
     MailFactory,
     ChatterMessageRepository,
     ChatterMessageDetailsRepository,

package/src/subscribers/list-of-values-metadata.subscriber.ts

@@ -0,0 +1,115 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectDataSource } from "@nestjs/typeorm";
+import { ListOfValues } from 'src/entities/list-of-values.entity';
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { ListOfValuesMetadataService } from 'src/services/list-of-values-metadata.service';
+import { DataSource, EntityManager, EntitySubscriberInterface, InsertEvent, RemoveEvent, UpdateEvent } from "typeorm";
+
+@Injectable()
+export class ListOfValuesMetadataSubscriber implements EntitySubscriberInterface<ListOfValues> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly listOfValuesMetadataService: ListOfValuesMetadataService,
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return ListOfValues;
+    }
+
+    async afterInsert(event: InsertEvent<ListOfValues>) {
+        if (!event.entity) {
+            this.logger.debug('No listofvalue entity found in the ListofValueSubscriber afterInsert method');
+            return;
+        }
+        await this.saveListOfValuesToConfig(event.entity, event.queryRunner.manager);
+    }
+
+    async afterUpdate(event: UpdateEvent<ListOfValues>) {
+        if (!event.entity) {
+            this.logger.debug('No listofvalue entity found in the ListofValueSubscriber afterInsert method');
+            return;
+        }
+
+        //@ts-ignore
+        await this.updateListOfValuesToConfig(event.databaseEntity, event.entity, event.queryRunner.manager);
+    }
+
+    // async beforeRemove(event: RemoveEvent<ListOfValues>) {
+    //     if (!event.entity) {
+    //         this.logger.debug('No listofvalue entity found in the ListofValueSubscriber beforeRemove method');
+    //         return;
+    //     }
+
+    //     await this.deleteListOfValuesFromConfig(event.entity, event.queryRunner.manager);
+    // }
+
+
+    private async saveListOfValuesToConfig(listOfValues: ListOfValues, entityManager: EntityManager): Promise<void> {
+        if (!listOfValues || !listOfValues.id) {
+            this.logger.debug('on save Listofvalue id is undefined');
+            return;
+        }
+
+        // Load the Listofvalue with module relation populated
+        const populatedLov = await entityManager.findOne(ListOfValues, {
+            where: { id: listOfValues.id },
+            relations: ['module'],
+        });
+
+        if (!populatedLov) {
+            this.logger.error(`Listofvalue not found for id ${listOfValues.id}`);
+            return;
+        }
+
+        // Call the saveListofValuesToConfig method from the ListOfValuesMetadataService
+        await this.listOfValuesMetadataService.saveListofValuesToConfig(populatedLov);
+    }
+
+    private async updateListOfValuesToConfig(oldlistOfValues: ListOfValues, listOfValues: ListOfValues, entityManager: EntityManager): Promise<void> {
+        if (!listOfValues || !listOfValues.id) {
+            this.logger.debug('on update Listofvalue id is undefined');
+            return;
+        }
+
+        // Load the Listofvalue with module relation populated
+        const populatedLov = await entityManager.findOne(ListOfValues, {
+            where: { id: listOfValues.id },
+            relations: ['module'],
+        });
+
+        if (!populatedLov) {
+            this.logger.error(`Listofvalue not found for id ${listOfValues.id}`);
+            return;
+        }
+
+        // Call the updateListofValuesToConfig method from the ListOfValuesMetadataService
+        await this.listOfValuesMetadataService.updateListofValuesToConfig(oldlistOfValues, populatedLov);
+    }
+
+    private async deleteListOfValuesFromConfig(listOfValues: ListOfValues, entityManager: EntityManager): Promise<void> {
+        if (!listOfValues || !listOfValues.id) {
+            this.logger.debug('on delete Listofvalue id is undefined');
+            return;
+        }
+
+        // Load the Listofvalue with module relation populated
+        const populatedLov = await entityManager.findOne(ListOfValues, {
+            where: { id: listOfValues.id },
+            relations: ['module'],
+        });
+
+        if (!populatedLov) {
+            this.logger.error(`Listofvalue not found for id ${listOfValues.id}`);
+            return;
+        }
+
+        // Call the deleteListOfValuesFromConfig method from the ListOfValuesMetadataService
+        await this.listOfValuesMetadataService.deleteListOfValuesFromConfig(populatedLov);
+    }
+
+}