@solidxai/core 0.0.2

package/src/services/question-data-providers/prime-react-meter-group-sql-data-provider.service.ts

@@ -0,0 +1,119 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
+import { IDashboardQuestionDataProvider } from "src/interfaces";
+import { EntityManager } from "typeorm";
+import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
+import { Logger } from '@nestjs/common';
+import { SqlExpression } from "./chartjs-sql-data-provider.service";
+import { getKpi } from "./helpers";
+
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+}
+
+@DashboardQuestionDataProvider()
+@Injectable()
+export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
+    private readonly logger = new Logger(PrimeReactMeterGroupSqlDataProvider.name);
+
+    constructor(private readonly entityManager: EntityManager, private readonly sqlExpressionResolver: SqlExpressionResolverService) { }
+
+    help(): string {
+        return "Provides data for dashboard questions using a SQL dataset configuration. Configure your SQL dataset in the admin panel, then reference it in your dashboard question to fetch data.";
+    }
+
+    name(): string {
+        return "PrimeReactMeterGroupSqlDataProvider";
+    }
+
+    hslToHex(h: number, s: number, l: number): string {
+        l /= 100;
+        s /= 100;
+
+        const k = (n: number) => (n + h / 30) % 12;
+        const a = s * Math.min(l, 1 - l);
+        const f = (n: number) =>
+            Math.round(255 * (l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)))));
+
+        return `#${f(0).toString(16).padStart(2, '0')}${f(8).toString(16).padStart(2, '0')}${f(4)
+            .toString(16)
+            .padStart(2, '0')}`;
+    }
+
+    generateDistinctColors(count: number): string[] {
+        const colors: string[] = [];
+
+        const hueStep = 360 / count;
+        const saturation = 65; // keep it vibrant
+        const lightness = 55;  // balanced for both light/dark themes
+
+        for (let i = 0; i < count; i++) {
+            const hue = Math.round(i * hueStep);
+            colors.push(this.hslToHex(hue, saturation, lightness));
+        }
+
+        return colors;
+    }
+
+    async getData(question: DashboardQuestion, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+        // TODO: put some validation to check if the results of each SQL in each dataset returns the same number of rows 
+
+        // This is what we have to return.
+        // const values = [
+        //     { label: 'Apps', color: '#34d399', value: 16 },
+        //     { label: 'Messages', color: '#fbbf24', value: 8 },
+        //     { label: 'Media', color: '#60a5fa', value: 24 },
+        //     { label: 'System', color: '#c084fc', value: 10 }
+        // ];
+
+        // TODO: Load the set of labels by using a separate field on the question entity.
+
+        const kpi: string = await getKpi(question, expressions, this.entityManager, this.sqlExpressionResolver);
+        
+        // Load the chart options as a JSON 
+        const chartOptions = JSON.parse(question.chartOptions || '{}');
+
+        const values = []
+
+        // For meter group we can assume that we only have one sql dataset config.
+        const questionSqlDatasetConfig = question.questionSqlDatasetConfigs[0];
+
+        const sql = questionSqlDatasetConfig.sql;
+        if (!sql) {
+            throw new Error(`SQL dataset ${questionSqlDatasetConfig.datasetName} configuration does not contain a valid SQL query.`);
+        }
+
+        const sqlReplacementResult = this.sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
+        this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is query=[${sqlReplacementResult.rawSql}]`);
+        this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is parameters=[${JSON.stringify(sqlReplacementResult.parameters)}]`);
+        const results = await this.entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
+
+        const colors = this.generateDistinctColors(results.length);
+
+        // Also for each data set we create the dataset object as is expected by ChartJs.
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+
+            const colorFromChartOptions = chartOptions?.colors?.[result[questionSqlDatasetConfig.labelColumnName]];
+            const color = typeof colorFromChartOptions === 'string' ? colorFromChartOptions : colors[i];
+
+            values.push({
+                label: result[questionSqlDatasetConfig.labelColumnName],
+                color: color,
+                value: result[questionSqlDatasetConfig.valueColumnName]
+            })
+        }
+
+        return {
+            kpi,
+            visualizedAs: question.visualisedAs,
+            visualizationData: {
+                dataset: values
+            },
+        };
+
+    }
+}

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())}`);
+    }
+
+    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())}`);
+
+        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);
+        }
+
+    }
+}

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

@@ -0,0 +1,202 @@
+import { Logger, OnModuleInit } from '@nestjs/common';
+import { QueuesModuleOptions } from "../../interfaces";
+import { QueueMessage, QueueSubscriber } from '../../interfaces/mq';
+import { MqMessageQueueService } from '../mq-message-queue.service';
+import { MqMessageService } from '../mq-message.service';
+import { PollerService } from '../poller.service';
+
+
+export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscriber<T> {
+    private readonly logger = new Logger(DatabaseSubscriber.name);
+    private readonly url: string;
+    private readonly serviceRole: string;
+
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+        protected readonly poller: PollerService,
+    ) {
+        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(`DatabaseSubscriber instance created with options: ${JSON.stringify(this.options())}`);
+    }
+
+    abstract subscribe(message: QueueMessage<T>);
+
+    abstract options(): QueuesModuleOptions;
+
+    private async processNext(queueName: string) {
+        // this.logger.debug(`#### DatabaseSubscriber processing next message from queue: ${queueName}`);
+        const job = await this.mqMessageService.lockNextPendingMessage(queueName);
+        if (!job) {
+            return;
+        }
+
+        const messageContentString = job.input.toString();
+        // this.logger.debug(`DatabaseSubscriber Received raw message: ${messageContentString}`);
+
+        let message: QueueMessage<T> = null;
+
+        try {
+            message = JSON.parse(messageContentString) as QueueMessage<T>;
+
+            // this is the first time we are receiving the message so we set the currentRetry to 0
+            if (!message.retryCount) message.retryCount = 0;
+            if (!message.retryInterval) message.retryInterval = 1000;
+            if (!message.currentRetry) message.currentRetry = 0;
+
+            await this.processMessage(message);
+        }
+        catch (error) {
+            this.logger.error(`Error processing message: ${error.message}`);
+
+            // if an error occurs then if retryCount is set we start retrying. 
+            if (message) {
+                if (message.currentRetry < message.retryCount) {
+                    await this.updateStatusInDatabase('retrying', message);
+
+                    message.currentRetry++;
+                    this.logger.warn(`Retrying message (${message.currentRetry}/${message.retryCount}) after ${message.retryInterval}ms`);
+                    setTimeout(() => {
+                        this.retryMessage(message);
+                    }, message.retryInterval);
+                } else {
+                    // Discard the message after max retries
+                    await this.updateStatusInDatabase('failed', message, error.message, '');
+                    this.logger.error(`Message failed after ${message.retryCount} attempts: ${error.message}`);
+                }
+            }
+        }
+        // this.logger.debug(`#### DatabaseSubscriber finished processing message from queue: ${queueName}`);
+    }
+
+    // async onModuleInit(): Promise<void> {
+    //     // we will start subscriber only if the current service role is subscriber. 
+    //     if (['both', 'subscriber'].includes(this.serviceRole)) {
+
+    //         const options = this.options();
+
+    //         const queueName = options.queueName;
+    //         // setInterval(() => this.processNext(queueName), 1000);
+    //         const poll = async () => {
+    //             try {
+    //                 await this.processNext(queueName);
+    //             } catch (err) {
+    //                 this.logger.error(`Polling error: ${err.message}`);
+    //             } finally {
+    //                 setTimeout(poll, 1000); // Wait 1s *after* processing finishes
+    //             }
+    //         };
+
+    //         // start the loop
+    //         poll();
+
+    //         this.logger.log(`DatabaseSubscriber ready to consume messages: ${JSON.stringify(this.options())}`);
+    //     }
+    // }
+
+    async onModuleInit(): Promise<void> {
+        const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'database';
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+
+        // we will start subscriber only if the current service role is subscriber. 
+        if (['both', 'subscriber'].includes(this.serviceRole) && defaultBroker === 'database' && solidCliRunning === "false") {
+
+            const options = this.options();
+
+            const queueName = options.queueName;
+
+            this.poller.start(queueName, (q) => this.processNext(q), {
+                baseDelayMs: 1000,
+                maxDelayMs: 30_000,
+                timeoutPerIterationMs: 5 * 60_000,
+                jitter: true,
+            });
+
+            this.logger.log(`DatabaseSubscriber ready to consume messages: ${JSON.stringify(this.options())}`);
+        }
+    }
+
+    onModuleDestroy() {
+        const options = this.options();
+        const queueName = options.queueName;
+        this.poller.stop(queueName);
+    }
+
+    /**
+     * Abstract method for message processing logic.
+     */
+    protected async processMessage(message: QueueMessage<T>): Promise<void> {
+        await this.updateStatusInDatabase('started', message);
+
+        // Capture the results of handling the task.
+        const result = await this.subscribe(message);
+
+        // TODO: Update the database to indicate that the task is finished.
+        await this.updateStatusInDatabase('succeeded', message, '', result ? JSON.stringify(result, null, 2) : '');
+    }
+
+    /**
+     * Retry the message by invoking the processing logic again.
+     */
+    private async retryMessage(message: QueueMessage<T>) {
+        try {
+            await this.processMessage(message);
+        } catch (error) {
+            if (message.currentRetry < message.retryCount) {
+                await this.updateStatusInDatabase('retrying', message);
+
+                message.currentRetry++;
+                this.logger.warn(`Retrying message (${message.currentRetry}/${message.retryCount}) after ${message.retryInterval}ms: ${error.message}`);
+                setTimeout(() => {
+                    this.retryMessage(message);
+                }, message.retryInterval);
+            } else {
+                this.logger.error(`Message failed after ${message.retryCount} attempts: ${error.message}`);
+
+                // TODO: Store the error in the database and update the status accordingly.
+                await this.updateStatusInDatabase('failed', message, error.message, '');
+
+            }
+        }
+    }
+
+    private async updateStatusInDatabase(stage: string, message: QueueMessage<T>, error: string = '', result: string = '') {
+        try {
+            this.logger.debug(`Updating message status in database: ${stage} for messageId: ${message.messageId}`);
+
+            // 1. resolve the queue first
+            const mqMessage = await this.mqMessageService.repo.findOne({
+                where: {
+                    messageId: message.messageId,
+                }
+            });
+
+            if (mqMessage) {
+                this.logger.debug(`Found message in database: ${JSON.stringify(mqMessage.messageId)}`);
+                this.logger.debug(`Updating message status in database: ${stage} for messageId: ${mqMessage.id}`);
+
+                const updatedFields = {
+                    stage: stage
+                };
+                if (stage === 'failed' || stage === 'succeeded') {
+                    updatedFields['finishedAt'] = new Date();
+                    updatedFields['elapsedMillis'] = updatedFields['finishedAt'].getTime() - mqMessage.startedAt.getTime();
+                }
+                if (stage === 'succeeded') {
+                    updatedFields['output'] = result;
+                }
+                if (stage === 'failed') {
+                    updatedFields['error'] = error;
+                }
+                await this.mqMessageService.repo.update(mqMessage.id, updatedFields);
+                this.logger.debug(`Message status updated to ${stage} for messageId: ${mqMessage.id}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(error.message, error.stack);
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+import { forwardRef, Inject, Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
+
+import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { SolidIntrospectService } from '../solid-introspect.service';
+
+
+@Injectable()
+export class PublisherFactory<T> {
+    private readonly logger = new Logger(PublisherFactory.name);
+
+    constructor(
+        @Inject(forwardRef(() => SolidIntrospectService))
+        private readonly solidIntrospectionService: SolidIntrospectService
+    ) {
+    }
+
+    async publish(message: QueueMessage<T>, publisherName: string, brokerToUse?: string): Promise<string> {
+        let defaultBrokerToUse = brokerToUse || process.env.QUEUES_DEFAULT_BROKER || "database";
+        let resolvedPublisherName = `${publisherName}${classify(defaultBrokerToUse)}`;
+
+        // Register all ISolidDatabaseModules implementations
+        let actualPublisherToUse = this.solidIntrospectionService.getProvider(resolvedPublisherName);
+        if (!actualPublisherToUse) {
+
+            // Extra check in place to make sure we do not have to refactor old publishers which have been created earlier. 
+            if (defaultBrokerToUse === 'rabbitmq') {
+                actualPublisherToUse = this.solidIntrospectionService.getProvider(publisherName);
+                if (!actualPublisherToUse) {
+                    throw new Error(`Unable to locate publisher with name ${resolvedPublisherName}`);
+                }
+            }
+        }
+
+        // type safe
+        const typedActualPublisher: QueuePublisher<T> = actualPublisherToUse.instance;
+        this.logger.debug(`Resolved publisher with name ${actualPublisherToUse.name}, and with options: ${JSON.stringify(typedActualPublisher.options())}`);
+
+        return typedActualPublisher.publish(message);
+    }
+}

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

@@ -0,0 +1,216 @@
+import { Logger, OnModuleDestroy } from '@nestjs/common';
+import * as amqp from 'amqplib';
+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 RabbitMqPublisher<T> implements OnModuleDestroy, QueuePublisher<T> {
+    private readonly logger = new Logger(RabbitMqPublisher.name);
+    private readonly url: string;
+    private readonly serviceRole: string;
+
+    // Maintain connection...
+    private connection: amqp.Connection | null = null;
+    private channel: amqp.Channel | null = null;
+    private connectingPromise: Promise<void> | null = null;
+
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        this.url = process.env.QUEUES_RABBIT_MQ_URL;
+        this.serviceRole = process.env.QUEUES_SERVICE_ROLE;
+        if (!this.url) {
+            this.logger.debug('RabbitMqPublisher url is not defined in the environment variables');
+        }
+        if (!this.serviceRole) {
+            this.logger.debug('Queue service Role is not defined in the environment variables');
+        }
+        // this.logger.debug(`RabbitMqPublisher instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
+    }
+
+    abstract options(): QueuesModuleOptions;
+
+    private async ensureConnectionAndChannel(): Promise<amqp.Channel> {
+        if (this.channel) {
+            return this.channel;
+        }
+
+        // If another call is already connecting, wait for it
+        if (this.connectingPromise) {
+            await this.connectingPromise;
+            if (this.channel) return this.channel;
+        }
+
+        this.connectingPromise = (async () => {
+            const url = new URL(this.url);
+
+            const conn = await amqp.connect({
+                protocol: url.protocol.replace(':', ''), // "amqps"
+                hostname: url.hostname,
+                port: parseInt(url.port),
+                username: url.username,
+                // Node's URL already decodes percent-encoding; decodeURIComponent is not needed
+                // But without it does not seem to be working...
+                password: decodeURIComponent(url.password),
+                frameMax: 131072,
+            });
+
+            conn.on('error', (err) => {
+                this.logger.error(`RabbitMQ connection error: ${err.message}`, err.stack);
+            });
+
+            conn.on('close', () => {
+                this.logger.warn('RabbitMQ connection closed, resetting');
+                this.connection = null;
+                this.channel = null;
+            });
+
+            const channel = await conn.createChannel();
+
+            const options = this.options();
+            const queueName = options.queueName;
+            const exchangeName = `${queueName}.exchange`;
+            const routingKey = `${queueName}.routing-key`;
+
+            await channel.assertExchange(exchangeName, 'direct', {});
+            const queue = await channel.assertQueue(queueName, {});
+            await channel.bindQueue(queue.queue, exchangeName, routingKey);
+
+            this.connection = conn;
+            this.channel = channel;
+        })();
+
+        try {
+            await this.connectingPromise;
+        } finally {
+            this.connectingPromise = null;
+        }
+
+        if (!this.channel) {
+            throw new Error('Failed to initialize RabbitMQ channel');
+        }
+
+        return this.channel;
+    }
+
+    // Nest will call this for every subclass instance, because they inherit the method
+    async onModuleDestroy(): Promise<void> {
+        await this.closeConnectionAndChannel();
+    }
+
+    private async closeConnectionAndChannel(): Promise<void> {
+        if (this.channel) {
+            try {
+                await this.channel.close();
+            } catch (err) {
+                this.logger.warn(
+                    `RabbitMqPublisher error closing channel: ${(err as Error).message}`,
+                );
+            } finally {
+                this.channel = null;
+            }
+        }
+
+        if (this.connection) {
+            try {
+                await this.connection.close();
+            } catch (err) {
+                this.logger.warn(
+                    `RabbitMqPublisher error closing connection: ${(err as Error).message}`,
+                );
+            } finally {
+                this.connection = null;
+            }
+        }
+    }
+
+
+    async publish(message: QueueMessage<T>): Promise<string> {
+        if (!this.url) {
+            this.logger.error('RabbitMqPublisher url is not defined in the environment variables');
+            throw new Error('RabbitMqPublisher url is not defined in the environment variables');
+        }
+        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');
+        }
+
+        const channel = await this.ensureConnectionAndChannel();
+        // this.logger.debug(`RabbitMqPublisher publisher channel created options: ${JSON.stringify(this.options())} and url: ${url}`);
+
+        const options = this.options();
+
+        const queueName = options.queueName;
+        const exchangeName = `${queueName}.exchange`;
+        const routingKey = `${queueName}.routing-key`;
+
+        // Set default values for retry. 
+        // by default there are no retries.
+        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);
+
+        // wait for the channel to confirm 
+        try {
+            // Publish the message
+            // const publishStatus = channel.publish(exchangeName, routingKey, Buffer.from(JSON.stringify(message)));
+            const publishStatus = channel.publish(exchangeName, routingKey, Buffer.from(JSON.stringify(message)), { mandatory: true });
+            // this.logger.debug(`RabbitMqPublisher publish status: ${JSON.stringify(publishStatus)}`);
+            // if (!publishStatus) {
+            //     this.logger.warn('RabbitMqPublisher Message buffering failed!');
+            // }
+            // await channel.waitForConfirms();
+            // this.logger.debug('RabbitMqPublisher Message published successfully');
+        } catch (err) {
+            this.logger.error(`RabbitMqPublisher Message publish failed: ${JSON.stringify(err)}`);
+            if (err instanceof Error) {
+                this.logger.error(`RabbitMqPublisher Error stack: ${err.stack}`);
+            }
+        }
+        finally {
+        }
+        // this.logger.debug(`Sent message: ${JSON.stringify(message)}`);
+
+        // return the newly created message id.
+        return message.messageId;
+    }
+
+    private async persistToDatabase(queueName: string, message: QueueMessage<T>) {
+
+        // TODO: 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);
+        }
+
+    }
+}