@solidstarters/solid-core 1.2.111 → 1.2.112

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

@@ -156,16 +156,13 @@ export class FieldMetadataService {
     private async saveInverseField(fieldRepository: Repository<FieldMetadata>, relationModel: ModelMetadata, inverseField: FieldMetadata): Promise<FieldMetadata> {
         const existingInverseField = await fieldRepository.findOne({
             where: {
-                model: relationModel,
+                model: { id: relationModel.id },
                 name: inverseField.name
             }
         });
 
         if (existingInverseField) {
-            // const updatedField = fieldRepository.merge(existingInverseField, inverseField);
-            // const savedField = await fieldRepository.save(updatedField);
-            // return savedField;
-            return existingInverseField;
+            return existingInverseField; // No need to update if it already exists
         }
         else {
             const savedField = await fieldRepository.save(fieldRepository.create(inverseField));
@@ -1100,6 +1097,9 @@ export class FieldMetadataService {
                 fieldObject.mediaStorageProviderUserKey = field.mediaStorageProvider.name
             }
         }
+        if (field.isMarkedForRemoval) {
+            fieldObject.isMarkedForRemoval = field.isMarkedForRemoval;
+        }
 
         return fieldObject;
     }

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

@@ -1,7 +1,7 @@
 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 { DataSource, EntityManager, Repository, SelectQueryBuilder } from 'typeorm';
+import { DataSource, EntityManager, In, 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';
@@ -24,6 +24,9 @@ import { CrudHelperService } from './crud-helper.service';
 import { FieldMetadataService } from './field-metadata.service';
 import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
 import { RoleMetadataService } from './role-metadata.service';
+import { GenerateCodePublisher } from 'src/jobs/database/generate-code-publisher.service';
+import { PermissionMetadata } from 'src/entities/permission-metadata.entity';
+import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
 
 @Injectable()
 export class ModelMetadataService {
@@ -41,6 +44,7 @@ export class ModelMetadataService {
     private readonly fieldMetadataService: FieldMetadataService,
     private readonly roleService: RoleMetadataService,
     private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+    private readonly generateCodePublihser: GenerateCodePublisher,
   ) { }
 
   async findMany(basicFilterDto: BasicFilterDto) {
@@ -262,6 +266,9 @@ export class ModelMetadataService {
         isChild: model?.isChild,
         parentModelUserKey: model?.parentModel?.singularName,
         enableAuditTracking: model?.enableAuditTracking,
+        enableSoftDelete: model?.enableSoftDelete,
+        draftPublishWorkflow: model?.draftPublishWorkflow,
+        internationalisation: model?.internationalisation,
         fields: []
       }
 
@@ -285,7 +292,6 @@ export class ModelMetadataService {
     }
   }
 
-
   async updateInDb(manager: EntityManager, id: number, updateModelMetaDataDto: UpdateModelMetaDataDto) {
 
     const { fields: fieldsMetadata, ...modelMetaDataWithoutFields } = updateModelMetaDataDto;
@@ -395,8 +401,6 @@ export class ModelMetadataService {
 
   }
 
-
-
   async updateInFile(modelId: any, repo: Repository<ModelMetadata>) {
     try {
 
@@ -405,6 +409,11 @@ export class ModelMetadataService {
           id: modelId,
         },
         relations: ["fields", "fields.mediaStorageProvider", "module", "parentModel"], //FIXME: Check with jenender and change to relations to avoid confusion
+        order: {
+          fields: {
+            id: "ASC",
+          },
+        },
       });
 
       const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(model.module.name);
@@ -422,14 +431,20 @@ export class ModelMetadataService {
         isChild: model?.isChild,
         parentModelUserKey: model?.parentModel?.singularName,
         enableAuditTracking: model?.enableAuditTracking,
+        enableSoftDelete: model?.enableSoftDelete,
+        draftPublishWorkflow: model?.draftPublishWorkflow,
+        internationalisation: model?.internationalisation,
         fields: []
       }
 
       for (let i = 0; i < model.fields.length; i++) {
         const field = model.fields[i];
-        if (!field.isSystem && !field.isMarkedForRemoval) {
+        if (!field.isSystem) {
 
           const fieldObject: Record<string, any> = await this.fieldMetadataService.createFieldConfig(field);
+          if (field.isMarkedForRemoval) {
+            fieldObject.isMarkedForRemoval = true;
+          }
           modelMetaData.fields.push(fieldObject);
         }
       }
@@ -482,7 +497,9 @@ export class ModelMetadataService {
   async removeBySingularName(singularName: string) {
     try {
       const entity = await this.findOneBySingularName(singularName);
-      return this.modelMetadataRepo.remove(entity);
+      await this.cleanupOnDelete(entity.id);
+      const r = await this.modelMetadataRepo.remove(entity);
+      return r;
     } catch (error) {
     }
   }
@@ -503,19 +520,218 @@ export class ModelMetadataService {
       // if (!entity) {
       //   throw new Error(`Entity with id ${ id } not found`);
       // }
-      removedEntities.push(await this.modelMetadataRepo.remove(entity));
+      await this.cleanupOnDelete(entity.id);
+      const r = await this.modelMetadataRepo.remove(entity);
+      removedEntities.push(r);
     }
 
     return removedEntities
   }
 
-
   async remove(id: number) {
     const entity = await this.findOne(id);
-    return this.modelMetadataRepo.remove(entity);
+    await this.cleanupOnDelete(entity.id);
+    const r = await this.modelMetadataRepo.remove(entity);
+    return r
   }
 
-  async handleGenerateCode(options: CodeGenerationOptions): Promise<string> {
+  async cleanupOnDelete(modelEntityId: number) {
+    const modelEntity = await this.modelMetadataRepo.findOne({
+      where: {
+        // @ts-ignore
+        id: modelEntityId,
+      },
+      relations: ['module']
+    });
+
+    if (!modelEntity) {
+      this.logger.log(`Invalid modelEntityId: ${modelEntityId} unable to resolve model metadata`);
+      return;
+    }
+    if (modelEntity.id !== modelEntityId) {
+      this.logger.log(`Invalid modelEntityId: ${modelEntityId} unable to resolve model metadata id ${modelEntity.id} not matching with the one passed as argument ${modelEntityId}`);
+      return;
+    }
+
+    this.logger.log(`Cleaning up for model: ${modelEntity.singularName} belonging to module: ${modelEntity.module.name}`);
+
+    const modulePath = await this.moduleMetadataHelperService.getModulePath(modelEntity.module.name);
+    // /Users/harishpatel/Code/javascript/school-fees-portal/solid-api/src/solid-core
+    this.logger.log(`Module path: ${modulePath}`);
+
+    const filesToDelete = [];
+    // <singularName>.entity.ts | The TypeORM model that needs to be deleted. | Automatic
+    const entityFilePath = `${modulePath}/entities/${dasherize(modelEntity.singularName)}.entity.ts`;
+    filesToDelete.push(entityFilePath);
+    this.logger.log(`About to delete entity file path: ${entityFilePath}`);
+
+    // <singularName>.create.dto.ts | The TypeORM model that needs to be deleted. | Automatic
+    const createDtoFilePath = `${modulePath}/dtos/create-${dasherize(modelEntity.singularName)}.dto.ts`;
+    filesToDelete.push(createDtoFilePath);
+    this.logger.log(`About to delete create DTO file path: ${createDtoFilePath}`);
+
+    // <singularName>.update.dto.ts | The TypeORM model that needs to be deleted. | Automatic
+    const updateDtoFilePath = `${modulePath}/dtos/update-${dasherize(modelEntity.singularName)}.dto.ts`;
+    filesToDelete.push(updateDtoFilePath);
+    this.logger.log(`About to delete update DTO file path: ${updateDtoFilePath}`);
+
+    // <singularName>.repository.ts | The TypeORM model that needs to be deleted. | Automatic
+    const repositoryFilePath = `${modulePath}/repositories/${dasherize(modelEntity.singularName)}.repository.ts`;
+    filesToDelete.push(repositoryFilePath);
+    this.logger.log(`About to delete repository file path: ${repositoryFilePath}`);
+
+    // <singularName>.service.ts | The TypeORM model that needs to be deleted. | Automatic
+    const serviceFilePath = `${modulePath}/services/${dasherize(modelEntity.singularName)}.service.ts`;
+    filesToDelete.push(serviceFilePath);
+    this.logger.log(`About to delete service file path: ${serviceFilePath}`);
+
+    // <singularName>.controller.ts | The TypeORM model that needs to be deleted. | Automatic
+    const controllerFilePath = `${modulePath}/controllers/${dasherize(modelEntity.singularName)}.controller.ts`;
+    filesToDelete.push(controllerFilePath);
+    this.logger.log(`About to delete controller file path: ${controllerFilePath}`);
+
+    for (let i = 0; i < filesToDelete.length; i++) {
+      const fileToDelete = filesToDelete[i];
+      try {
+        await fs.unlink(fileToDelete);
+        this.logger.log(`Deleted file: ${fileToDelete}`);
+      } catch (error) {
+        this.logger.error(`Error deleting file: ${fileToDelete}`, error);
+      }
+    }
+
+    // Delete the permissions, menu, actions & views related to this model.
+    const controllerName = `${classify(modelEntity.singularName)}Controller`;
+    const permissionNames = [
+      `${controllerName}.delete`,
+      `${controllerName}.deleteMany`,
+      `${controllerName}.findOne`,
+      `${controllerName}.findMany`,
+      `${controllerName}.recover`,
+      `${controllerName}.recoverMany`,
+      `${controllerName}.partialUpdate`,
+      `${controllerName}.update`,
+      `${controllerName}.insertMany`,
+      `${controllerName}.create`,
+    ];
+    const permissionsRepo = this.dataSource.getRepository(PermissionMetadata);
+    const permissionsToDelete = await permissionsRepo.find({
+      where: { name: In(permissionNames) },
+      relations: ['roles'],
+    });
+
+    // Remove role associations first
+    for (const permission of permissionsToDelete) {
+      if (permission.roles?.length) {
+        await this.dataSource
+          .createQueryBuilder()
+          .relation(PermissionMetadata, 'roles')
+          .of(permission) // permission instance or its ID
+          .remove(permission.roles); // remove all linked roles
+      }
+    }
+
+    await permissionsRepo.remove(permissionsToDelete);
+
+    // Delete actions
+    const actionRepo = this.dataSource.getRepository(ActionMetadata);
+    const action = await actionRepo.findOne({ where: { model: { id: modelEntity.id } } });
+    await actionRepo.delete({ model: { id: modelEntity.id } });
+
+    // Delete menu items
+    const menuItemRepo = this.dataSource.getRepository(MenuItemMetadata);
+    if (action) {
+      const menuItems = await menuItemRepo.find({ where: { action: { id: action.id } } });
+      for (let i = 0; i < menuItems.length; i++) {
+        const menuItem = menuItems[i];
+        await menuItemRepo.remove(menuItem);
+      }
+    }
+
+    // Delete view 
+    const viewRepo = this.dataSource.getRepository(ViewMetadata);
+    await viewRepo.delete({ model: { id: modelEntity.id } })
+
+    // <moduleName>-metadata.json | Remove references to this model in the model metadata, menu, action & view sections. | Automatic
+    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(modelEntity.module.name);
+    const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
+    const existingModelIndex = metaData.moduleMetadata.models.findIndex(
+      (existingModel: any) => existingModel.singularName === modelEntity.singularName
+    );
+    if (existingModelIndex !== -1) {
+      metaData.moduleMetadata.models.splice(existingModelIndex, 1);
+    }
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+
+    // <moduleName>.module.ts | Remove all references and imports of the above files. | Manual (X)
+    // const moduleFilePath = path.resolve(modulePath, `${dasherize(modelEntity.module.name)}.module.ts`);
+
+    // this.logger.log(`Working on module file ${moduleFilePath}`);
+    // const project = new Project();
+    // const sourceFile = project.addSourceFileAtPath(moduleFilePath);
+
+    // // Remove import declarations related to deleted files
+    // sourceFile.getImportDeclarations().forEach(importDecl => {
+    //   const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    //   const resolvedPath = importDecl.getModuleSpecifierSourceFile()?.getFilePath() || '';
+    //   if (filesToDelete.some(file => resolvedPath.endsWith(file))) {
+    //     importDecl.remove();
+    //   }
+    // });
+
+    // // Remove identifiers from `@Module` metadata (imports, providers, controllers)
+    // const moduleDecorator = sourceFile.getFirstDescendantByKind(SyntaxKind.Decorator);
+    // const objectLiteral = moduleDecorator?.getCallExpression()?.getArguments()?.[0];
+
+    // if (objectLiteral && objectLiteral.getKind() === SyntaxKind.ObjectLiteralExpression) {
+    //   const objectLiteralExpr = objectLiteral.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+
+    //   for (const propName of ['imports', 'providers', 'controllers', 'exports']) {
+    //     const prop = objectLiteralExpr.getProperty(propName);
+    //     if (prop && prop.getKind() === SyntaxKind.PropertyAssignment) {
+    //       const elements = prop.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression);
+    //       elements?.getElements().forEach(el => {
+    //         const text = el.getText();
+    //         if (filesToDelete.some(file => text.toLowerCase().includes(file.split('.')[0]))) {
+    //           // @ts-ignore
+    //           el.remove();
+    //         }
+    //       });
+    //     }
+    //   }
+    // }
+
+    // // Save changes
+    // sourceFile.saveSync();
+
+    // Run seeder to reflect the removal. 
+
+    // - | Drop database table | Removes the database table from the DB, this is a very risky step. Best to review all relations to other models etc and then do this manually | Manual (X)
+
+  }
+
+  async handleGenerateCode(options: CodeGenerationOptions): Promise<any> {
+    // // see if the model record exists. 
+    // const model = await this.modelMetadataRepo.findOne({
+    //   where: {
+    //     id: options.modelId,
+    //   },
+    // });
+    // if (!model) {
+    //   throw new NotFoundException(`Model record with #${options.modelId} not found`);
+    // }
+
+    // const m = {
+    //   payload: options,
+    //   parentEntity: model.singularName,
+    //   parentEntityId: options.modelId,
+    // };
+
+    // const messageId = await this.generateCodePublihser.publish(m);
+
+    // return { messageId: messageId };
+
     const { model, removeFieldCodeOuput, refreshModelCodeOutput } = await this.generateCode(options);
 
     // Generate the code for models which are linked to fields having an inverse relation
@@ -531,14 +747,13 @@ export class ModelMetadataService {
       };
       await this.generateCode(inverseOptions);
     }
-
     await this.generateVAMConfig(model.id);
 
     return `${removeFieldCodeOuput} \n ${refreshModelCodeOutput}`;
   }
 
   // Generate the View, Action and Menu configuration for the model
-  private async generateVAMConfig(modelId: number) {
+  async generateVAMConfig(modelId: number) {
     try {
       return await this.dataSource.transaction(async (manager: EntityManager) => {
         const modelRepository = manager.getRepository(ModelMetadata);
@@ -852,7 +1067,7 @@ export class ModelMetadataService {
     }
   }
 
-  private async generateCode(options: CodeGenerationOptions) {
+  async generateCode(options: CodeGenerationOptions) {
     const query = {
       populate: ["module", "fields"]
     };
@@ -894,6 +1109,34 @@ export class ModelMetadataService {
         this.fieldMetadataService.delete(field.id);
       }
     });
+
+    // Remove the fields from metadata json file 
+
+    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(model.module.name);
+    const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
+
+    // Check if the model already exists in `models`
+    const existingModelIndex = metaData.moduleMetadata.models.findIndex(
+      (existingModel: any) => existingModel.singularName === model.singularName
+    );
+
+    const modelMetaData = metaData.moduleMetadata.models[existingModelIndex];
+
+    // Remove fields marked for removal from modelMetaData.fields
+    modelMetaData.fields = modelMetaData.fields.filter((field: any) => field.isMarkedForRemoval !== true);
+
+    if (existingModelIndex !== -1) {
+      // Update the existing model
+      metaData.moduleMetadata.models[existingModelIndex] = modelMetaData;
+    } else {
+      // Add the new model
+      metaData.moduleMetadata.models.push(modelMetaData);
+    }
+
+    // Write the updated object back to the file
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+
     return removeOutput;
   }
 

package/src/services/mq-message-queue.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { EntityManager, Repository } from 'typeorm';
@@ -15,6 +15,7 @@ import { MqMessageQueue } from '../entities/mq-message-queue.entity';
 @Injectable()
 export class MqMessageQueueService extends CRUDService<MqMessageQueue> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/mq-message.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { EntityManager, Repository } from 'typeorm';
@@ -8,25 +8,64 @@ import { ModuleMetadataService } from 'src/services/module-metadata.service';
 import { ConfigService } from '@nestjs/config';
 import { FileService } from "src/services/file.service";
 import { CrudHelperService } from "src/services/crud-helper.service";
-
-
 import { MqMessage } from '../entities/mq-message.entity';
+import { Logger } from '@nestjs/common';
 
 @Injectable()
-export class MqMessageService extends CRUDService<MqMessage>{
+export class MqMessageService extends CRUDService<MqMessage> {
+  private readonly logger = new Logger(MqMessageService.name);
+
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
     readonly fileService: FileService,
-   readonly discoveryService: DiscoveryService,
+    readonly discoveryService: DiscoveryService,
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     @InjectRepository(MqMessage)
     readonly repo: Repository<MqMessage>,
-     readonly moduleRef: ModuleRef
+    readonly moduleRef: ModuleRef
   ) {
-   super(modelMetadataService, moduleMetadataService,  configService, fileService, discoveryService, crudHelperService,entityManager, repo, 'mqMessage', 'queues',moduleRef);
- }
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'mqMessage', 'queues', moduleRef);
+  }
+
+  async lockNextPendingMessage(queueName: string): Promise<MqMessage | null> {
+    // this.logger.debug(`Locking next pending message for queue: ${queueName}`);
+
+    return await this.entityManager.transaction(async manager => {
+      // Use raw SQL to skip locked rows (FOR UPDATE SKIP LOCKED)
+      const rawJob = await manager.query(`
+          SELECT ss_mq_message.id
+            FROM ss_mq_message
+            left join ss_mq_message_queue on ss_mq_message.mq_message_queue_id = ss_mq_message_queue.id
+           WHERE ss_mq_message_queue."name" = $1
+             AND ss_mq_message.stage = 'pending'
+           ORDER BY ss_mq_message.created_at ASC
+             FOR UPDATE SKIP LOCKED
+           LIMIT 1`,
+        [queueName]
+      );
+
+      // this.logger.debug(`Raw job fetched: ${JSON.stringify(rawJob)}`);
+      if (!rawJob || rawJob.length === 0) {
+        // this.logger.debug(`No pending job found for queue: ${queueName}`);
+        return null;
+      }
+      const job = await manager.getRepository(MqMessage).findOne({ where: { id: rawJob[0].id }, relations: ['mqMessageQueue'] });
+      if (job) {
+        // this.logger.debug(`Locked job id: ${job.id}, queue: ${job.mqMessageQueue.name}, stage: ${job.stage}`);
+
+        job.stage = 'scheduled';
+        await manager.save(job);
+
+        return job;
+      }
+
+      return null;
+    });
+  }
+
 }

package/src/services/queues/database-publisher.service.ts

@@ -0,0 +1,79 @@
+import { Logger } from '@nestjs/common';
+import { v4 as uuidv4 } from 'uuid';
+import { QueuesModuleOptions } from "../../interfaces";
+import { QueueMessage, QueuePublisher } from '../../interfaces/mq';
+import { MqMessageQueueService } from '../mq-message-queue.service';
+import { MqMessageService } from '../mq-message.service';
+
+export abstract class DatabasePublisher<T> implements QueuePublisher<T> {
+    private readonly logger = new Logger(DatabasePublisher.name);
+    private readonly url: string;
+    private readonly serviceRole: string;
+
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        this.serviceRole = process.env.QUEUES_SERVICE_ROLE;
+        if (!this.serviceRole) {
+            this.logger.debug('Queue service Role is not defined in the environment variables');
+        }
+        this.logger.debug(`DatabasePublisher instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
+    }
+
+    abstract options(): QueuesModuleOptions;
+
+    async publish(message: QueueMessage<T>): Promise<string> {
+        if (!this.serviceRole) {
+            this.logger.error('Queue service Role is not defined in the environment variables');
+            throw new Error('Queue service Role is not defined in the environment variables');
+        }
+        if (this.serviceRole === 'subscriber') {
+            this.logger.error('Queue service Role is subscriber, cannot publish messages');
+            throw new Error('Queue service Role is subscriber, cannot publish messages');
+        }
+
+        this.logger.debug(`DatabasePublisher publishing with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
+
+        const options = this.options();
+
+        const queueName = options.queueName;
+        if (!message.retryCount) message.retryCount = 0;
+        if (!message.retryInterval) message.retryInterval = 1000;
+
+        // generate a new message id 
+        message.messageId = uuidv4();
+
+        // Save the message to the DB so that we can then change its status in the subscriber...
+        await this.persistToDatabase(queueName, message);
+
+        // return the newly created message id.
+        return message.messageId;
+    }
+
+    private async persistToDatabase(queueName: string, message: QueueMessage<T>) {
+        // make an entry in the relevant database table, generate a unique id earlier.
+        try {
+            // 1. resolve the queue first
+            const mqMessageQueue = await this.mqMessageQueueService.resolveQueue(queueName);
+
+            // 2. Next create an entry in the mqMessage table. 
+            await this.mqMessageService.create({
+                messageBroker: this.options().type,
+                messageId: message.messageId,
+                retryCount: message.retryCount,
+                retryInterval: message.retryInterval,
+                stage: 'pending',
+                startedAt: new Date(),
+                input: JSON.stringify(message, null, 2),
+                parentEntityId: message.parentEntityId,
+                parentEntity: message.parentEntity,
+                mqMessageQueueId: mqMessageQueue.id,
+            });
+        }
+        catch (error) {
+            this.logger.error(error.message, error.stack);
+        }
+
+    }
+}