@solidxai/core 0.0.2

package/src/jobs/database/trigger-mcp-client-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const TRIGGER_MCP_CLIENT_QUEUE_NAME = 'trigger_mcp_client_queue';
+
+export default {
+    name: 'triggerMcpClientQueue',
+    type: BrokerType.Database,
+    queueName: TRIGGER_MCP_CLIENT_QUEUE_NAME,
+};

package/src/jobs/database/trigger-mcp-client-subscriber-database.service.ts

@@ -0,0 +1,311 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ModelMetadataService } from 'src';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { QueueMessage } from 'src/interfaces/mq';
+import { DashboardRepository } from 'src/repository/dashboard.repository';
+import { AiInteractionService } from 'src/services/ai-interaction.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { PollerService } from 'src/services/poller.service';
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import { Not } from 'typeorm';
+import { McpResponse, QueuesModuleOptions, TriggerMcpClientOptions } from "../../interfaces";
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import triggerMcpClientQueueOptions from "./trigger-mcp-client-queue-options";
+
+@Injectable()
+export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<TriggerMcpClientOptions> {
+    private readonly triggerMcpClientSubscriberLogger = new Logger(TriggerMcpClientSubscriberDatabase.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        readonly aiInteractionService: AiInteractionService,
+        readonly moduleMetadataService: ModuleMetadataService,
+        readonly modelMetadataService: ModelMetadataService,
+        private readonly solidRegistry: SolidRegistry,
+        // private readonly dashboardService: DashboardService
+        private readonly dashboardRepository: DashboardRepository
+
+    ) {
+        super(mqMessageService, mqMessageQueueService, poller);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...triggerMcpClientQueueOptions
+        }
+    }
+
+    cleanNestedResponse(aiResponse: McpResponse) {
+        let nestedResponse: any;
+
+        try {
+            let raw = aiResponse.response;
+
+            if (typeof raw === "string") {
+                raw = raw.trim();
+                try {
+                    // Try to parse as JSON
+                    nestedResponse = JSON.parse(raw);
+                } catch {
+                    // Not JSON, just keep as string
+                    nestedResponse = raw;
+                }
+            } else if (typeof raw === "object" && raw !== null) {
+                // Already JSON
+                nestedResponse = raw;
+            } else {
+                // Fallback
+                nestedResponse = String(raw);
+            }
+        } catch (err) {
+            this.triggerMcpClientSubscriberLogger.error("Error processing AI response:", err);
+            nestedResponse = `Error handling response: ${err?.message || String(err)}`;
+        }
+
+        return nestedResponse;
+    }
+
+    async subscribe(message: QueueMessage<TriggerMcpClientOptions>) {
+        this.triggerMcpClientSubscriberLogger.debug(`Received message: ${JSON.stringify(message)}`);
+
+        const codeGnerationOptions = message.payload;
+
+        const aiInteraction = await this.aiInteractionService.findOne(codeGnerationOptions.aiInteractionId, {
+            populate: ['user']
+        });
+        if (!aiInteraction) {
+            const m = `Unable to identified the aiInteraction entry that triggered this job... using id: ${codeGnerationOptions.aiInteractionId}`
+            this.triggerMcpClientSubscriberLogger.log(m);
+            throw new Error(m);
+        }
+
+        // The message contains the users prompt.
+        const prompt = aiInteraction.message;
+
+        // Use this to invoke our mcp client
+        // TODO: try / catch ... 
+        // Handle the rejection gracefully...
+
+        // We create the aiInteraction entry first 
+        const genAiInteraction = await this.aiInteractionService.create({
+            userId: aiInteraction.user.id,
+            threadId: aiInteraction.threadId,
+            parentInteractionId: aiInteraction.id,
+            role: 'gen-ai',
+            message: '...', // Updated in the tool
+            contentType: '', // Updated in the tool
+            errorMessage: '', // Updated after we receive the response
+            modelUsed: '', // Updated after we receive the response
+            responseTimeMs: 0, // Updated after we receive the response
+            metadata: '', // Updated in the tool
+            isApplied: false, // Updated after we receive the response
+            status: 'pending' // Updated after we receive the response
+        });
+
+        const existingComputationProviders = this.solidRegistry.getComputedFieldProviders();
+
+        const { records: existingModules } = await this.moduleMetadataService.findMany({
+            filters: {
+                name: { $ne: 'solid-core' }
+            },
+            fields: ['id', 'name', 'displayName', 'description'],
+            limit: 1000
+        });
+        const { records: existingModels } = await this.modelMetadataService.findMany({
+            filters: {
+                module: {
+                    name: {
+                        $ne: 'solid-core',
+                    }
+                }
+            },
+            limit: 1000,
+            populate: ['module']
+        });
+
+        // Get the list of dashboards
+        // TODO: Ideally we should fetch dashboard like below, but used below approach to avoid below CLS issues for now.
+        // Cannot set the key "filter". No CLS context available, please make sure that a ClsMiddleware/Guard/Interceptor has set up the context, or wrap any calls that depend on CLS with "ClsService#run"
+        // const { records: existingDashboards } = await this.dashboardService.find({
+        //     fields
+        // })
+        const existingDashboards = await this.dashboardRepository.find(
+            {
+                where: {
+                    module: {
+                        name: Not('solid-core')
+                    }
+                },
+            }
+        );
+
+        const existingControllerAndTheirMethods = this.solidRegistry.getControllers();
+
+
+
+        // Build markdown sections using template interpolation
+        const modulesSection = (existingModules ?? [])
+            .map(m => [
+                `### ${m.displayName}`,
+                `- name: ${m.name}`,
+                `- description: ${m.description ?? ""}`,
+            ].join('\n'))
+            .join('\n\n');
+
+        const modelsSection = (existingModels ?? [])
+            .map(m => [
+                `### ${m.displayName}`,
+                `- singularName: ${m.singularName}`,
+                `- description: ${m.description ?? ""}`,
+                `- moduleName: ${m.module.name}`,
+            ].join('\n'))
+            .join('\n\n');
+
+        const dashboardsSection = (existingDashboards ?? [])
+            .map(d => [
+                `### ${d.displayName}`,
+                `- name: ${d.name}`,
+                `- description: ${d.description ?? ""}`,
+            ].join('\n'))
+            .join('\n\n');
+
+        const computationProvidersSection = (existingComputationProviders ?? [])
+            .map(m => [
+                `### ${m.instance.name()}`,
+                `- name: ${m.instance.name()}`,
+                `- description: ${m.instance.help() ?? ""}`,
+            ].join('\n'))
+            .join('\n\n');
+
+        const controllersAndTheirMethods = (existingControllerAndTheirMethods ?? [])
+            .map(m => [
+                `### ${m.name}`,
+                `- methods: ${m.methods.length ? m.methods.map(m => `- ${m}`).join('\n') : '- No methods found'}`,
+            ].join('\n'))
+            .join('\n\n');
+
+
+
+        const finalPrompt = `
+# User Prompt: 
+${prompt}
+
+# System Instructions:
+- aiInteractionId: ${genAiInteraction.id}
+- You will be invoking tools if needed, hence you will have to choose the applicable tools based on the tool context given to you.
+- If a tool is invoked, you must return **exactly** the raw output from the tool, without any json envelopes, additional formatting, commentary, or text.
+- Do not wrap the result in quotes, JSON, or markdown fences.
+- Do not explain what the result means.
+
+# LISTS FOR REFERENCE AND VALIDATIONS
+
+## LIST OF EXISTING MODULES
+Use the below list of modules to infer which module the user is referring to, .
+
+${modulesSection}
+
+## LIST OF EXISTING MODELS
+Use the below list of models to infer which model the user is referring to.
+You need to pull out the singularName for the model from the user prompt to match against the below list.
+
+${modelsSection}
+
+## LIST OF EXISTING DASHBOARDS
+Use the below list of dashboards to infer which dashboard the user is referring to.
+
+${dashboardsSection}
+
+## LIST OF EXISTING COMPUTED FIELD PROVIDERS
+Use the below list of computed field providers to infer which provider the user is referring to.
+
+${computationProvidersSection}
+`.trim();
+
+        // ## LIST OF EXISTING CONTROLLERS AND THEIR METHODS
+        // Use the below list of controllers and their methods to infer whether the api call being made to a particular controller exists or not.
+
+        // ${controllersAndTheirMethods}
+
+        const aiResponse = await this.aiInteractionService.runMcpPrompt(finalPrompt);
+        this.triggerMcpClientSubscriberLogger.log(`aiResponse: `);
+        this.triggerMcpClientSubscriberLogger.log(JSON.stringify(aiResponse));
+
+        if (!aiResponse.success) {
+            this.triggerMcpClientSubscriberLogger.log(`Gen ai has returned with a false status code`);
+
+            const errorsStr = aiResponse.errors?.join('\n ');
+            const errorTrace = aiResponse.error_trace?.join('\n');
+
+            // await this.aiInteractionService.create({
+            //     userId: aiInteraction.user.id,
+            //     threadId: aiInteraction.threadId,
+            //     parentInteractionId: aiInteraction.id,
+            //     role: 'gen-ai',
+            //     message: '-',
+            //     contentType: aiResponse.content_type,
+            //     errorMessage: `${errorsStr}\n\n${errorTrace}`,
+            //     modelUsed: aiResponse.model,
+            //     responseTimeMs: aiResponse.duration_ms,
+            //     metadata: JSON.stringify(aiResponse, null, 2),
+            //     isApplied: aiInteraction.isApplied,
+            //     status: aiResponse.success ? 'succeeded' : 'failed'
+            // });
+
+            // TODO: Update the previously created genAiInteraction record with the respective error fields and save to DB
+            await this.aiInteractionService.update(genAiInteraction.id, {
+                contentType: aiResponse.content_type,
+                errorMessage: `${errorsStr}\n\n${errorTrace}`,
+                modelUsed: aiResponse.model,
+                responseTimeMs: aiResponse.duration_ms,
+                isApplied: aiInteraction.isApplied,
+                status: aiResponse.success ? 'succeeded' : 'failed'
+            }, [], true);
+
+            // update the job entry with failure... raising an error will lead the job to be marked as failed...
+            throw new Error(errorsStr);
+        }
+        else {
+            let nestedResponse = this.cleanNestedResponse(aiResponse);
+
+            // TODO: Update the previously created genAiInteraction record with the respective success fields and save to DB
+            const errorsStr = nestedResponse?.status == "error" && nestedResponse?.errors.join('\n ');
+            const errorTrace = nestedResponse?.status == "error" && nestedResponse?.error_trace?.join('\n');
+
+            // const genAiInteraction = await this.aiInteractionService.create({
+            //     userId: aiInteraction.user.id,
+            //     threadId: aiInteraction.threadId,
+            //     parentInteractionId: aiInteraction.id,
+            //     role: 'gen-ai',
+            //     message: nestedResponse,
+            //     contentType: aiResponse.content_type,
+            //     errorMessage: `${errorsStr}\n\n${errorTrace}`,
+            //     modelUsed: aiResponse.model,
+            //     responseTimeMs: aiResponse.duration_ms,
+            //     metadata: JSON.stringify(aiResponse, null, 2),
+            //     isApplied: aiInteraction.isApplied,
+            //     status: aiResponse.success ? 'succeeded' : 'failed'
+            // });
+
+            await this.aiInteractionService.update(genAiInteraction.id, {
+                errorMessage: nestedResponse.status == "error" ? `${errorsStr}\n\n${errorTrace}` : "",
+                contentType: aiResponse.content_type,
+                message: JSON.stringify(nestedResponse),
+                modelUsed: aiResponse.model,
+                responseTimeMs: aiResponse.duration_ms,
+                metadata: JSON.stringify(aiResponse, null, 2),
+                isApplied: aiInteraction.isApplied,
+                status: aiResponse.success && nestedResponse.status == "success" ? 'succeeded' : 'failed'
+            }, [], true);
+
+            // If the human interaction was with isAutoApply=true, then we can go ahead and autoApply.
+            if (aiInteraction.isAutoApply) {
+                this.aiInteractionService.applySolidAiInteraction(genAiInteraction.id);
+            }
+        }
+
+        return aiResponse;
+    }
+}

package/src/jobs/database/twilio-sms-publisher-database.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import smsQueueOptions from './twilio-sms-queue-database-options';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { DatabasePublisher } from 'src/services/queues/database-publisher.service';
+
+@Injectable()
+export class TwilioSmsQueuePublisherDatabase extends DatabasePublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...smsQueueOptions
+        }
+    }
+}

package/src/jobs/database/twilio-sms-queue-database-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const SMS_QUEUE_NAME = 'twilio_sms_queue_database';
+
+export default {
+    name: 'twilioSmsInstance',
+    type: BrokerType.Database,
+    queueName: SMS_QUEUE_NAME,
+};

package/src/jobs/database/twilio-sms-subscriber-database.service.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@nestjs/common';
+
+import { QueueMessage } from 'src/interfaces/mq';
+import smsQueueOptions from './twilio-sms-queue-database-options';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import { TwilioSMSService } from 'src/services/sms/TwilioSMSService';
+import { PollerService } from 'src/services/poller.service';
+import { SmsFactory } from 'src/factories/sms.factory';
+
+@Injectable()
+export class TwilioSmsQueueSubscriberDatabase extends DatabaseSubscriber<any> {
+    constructor(
+        // private readonly smsService: TwilioSMSService,
+        private readonly smsFactory: SmsFactory,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+    ) {
+        super(mqMessageService, mqMessageQueueService, poller);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...smsQueueOptions
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        const smsService: TwilioSMSService = this.smsFactory.getSmsService(TwilioSMSService.name) as TwilioSMSService;
+        return smsService.sendSMSSynchronously(message);
+    }
+}

package/src/jobs/generate-code-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import { CodeGenerationOptions, QueuesModuleOptions } from "../interfaces";
+import { MqMessageQueueService } from '../services/mq-message-queue.service';
+import { MqMessageService } from '../services/mq-message.service';
+import generateCodeQueueOptions from './generate-code-queue-options';
+
+@Injectable()
+export class GenerateCodePublisherRabbitmq extends RabbitMqPublisher<CodeGenerationOptions> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...generateCodeQueueOptions
+        }
+    }
+}

package/src/jobs/generate-code-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "../interfaces";
+
+const QUEUE_NAME = 'generate_code_queue_rabbitmq';
+
+export default {
+    name: 'generateCodeQueueRabbitmq',
+    type: BrokerType.RabbitMQ,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/generate-code-subscriber.service.ts

@@ -0,0 +1,59 @@
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+
+import { QueueMessage } from 'src/interfaces/mq';
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { PollerService } from 'src/services/poller.service';
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import { CodeGenerationOptions, QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import generateCodeQueueOptions from './generate-code-queue-options';
+
+@Injectable()
+export class GenerateCodeSubscriberRabbitmq extends RabbitMqSubscriber<CodeGenerationOptions> {
+    private readonly generateCodeSubscriberLogger = new Logger(GenerateCodeSubscriberRabbitmq.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        @Inject(forwardRef(() => ModelMetadataService))
+        readonly modelMetadataService: ModelMetadataService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...generateCodeQueueOptions
+        }
+    }
+
+    async subscribe(message: QueueMessage<CodeGenerationOptions>) {
+        this.generateCodeSubscriberLogger.debug(`Received message: ${JSON.stringify(message)}`);
+
+        const codeGnerationOptions = message.payload;
+
+        const { model, removeFieldCodeOuput, refreshModelCodeOutput } = await this.modelMetadataService.generateCode(codeGnerationOptions);
+
+        // Generate the code for models which are linked to fields having an inverse relation
+        const coModelSingularNames = model.fields.
+            filter(field => field.type === SolidFieldType.relation && field.relationCreateInverse === true)
+            .map(field => field.relationCoModelSingularName);
+
+        for (const singularName of coModelSingularNames) {
+            const coModel = await this.modelMetadataService.findOneBySingularName(singularName);
+            const inverseOptions: CodeGenerationOptions = {
+                modelId: coModel.id,
+                dryRun: codeGnerationOptions.dryRun
+            };
+            await this.modelMetadataService.generateCode(inverseOptions);
+        }
+
+        await this.modelMetadataService.generateVAMConfig(model.id);
+
+        return `${removeFieldCodeOuput} \n ${refreshModelCodeOutput}`;
+    }
+}

package/src/jobs/msg91-otp-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import otpQueueOptions from './msg91-otp-queue-options';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { QueuesModuleOptions } from "../interfaces";
+
+@Injectable()
+export class Msg91OTPQueuePublisher extends RabbitMqPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...otpQueueOptions
+        }
+    }
+}

package/src/jobs/msg91-otp-queue-options.ts

@@ -0,0 +1,14 @@
+import { QueueMessage } from 'src/interfaces/mq';
+
+import { BrokerType } from "../interfaces";
+
+const OTP_QUEUE_NAME = 'otp_queue';
+export default {
+    name: 'otpInstance',
+    type: BrokerType.RabbitMQ,
+    queueName: OTP_QUEUE_NAME,
+    // receive: async (message: QueueMessage<any>) => { // Default receive handler
+    //     console.log(`Received message: ${JSON.stringify(message)} from queue ${SMS_QUEUE_NAME}`);
+    //     return 'Received';
+    // },
+};

package/src/jobs/msg91-otp-subscriber.service.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@nestjs/common';
+
+import { QueueMessage } from 'src/interfaces/mq';
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import { Msg91OTPService } from '../services/sms/Msg91OTPService';
+import otpQueueOptions from './msg91-otp-queue-options';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../interfaces";
+import { SmsFactory } from 'src/factories/sms.factory';
+
+@Injectable()
+export class Msg91OTPQueueSubscriber extends RabbitMqSubscriber<any> {
+    constructor(
+        // private readonly otpService: Msg91OTPService,
+        private readonly smsFactory: SmsFactory,
+
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...otpQueueOptions
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        const otpService: Msg91OTPService = this.smsFactory.getSmsService(Msg91OTPService.name) as Msg91OTPService;
+        return otpService.sendSMSSynchronously(message);
+
+        // this.otpService.sendSMSSynchronously(message);
+    }
+}

package/src/jobs/msg91-sms-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import smsQueueOptions from './msg91-sms-queue-options';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { QueuesModuleOptions } from "../interfaces";
+
+@Injectable()
+export class Msg91SmsQueuePublisher extends RabbitMqPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...smsQueueOptions
+        }
+    }
+}

package/src/jobs/msg91-sms-queue-options.ts

@@ -0,0 +1,14 @@
+import { QueueMessage } from 'src/interfaces/mq';
+
+import { BrokerType } from "../interfaces";
+
+const SMS_QUEUE_NAME = 'sms_queue';
+export default {
+    name: 'smsInstance',
+    type: BrokerType.RabbitMQ,
+    queueName: SMS_QUEUE_NAME,
+    // receive: async (message: QueueMessage<any>) => { // Default receive handler
+    //     console.log(`Received message: ${JSON.stringify(message)} from queue ${SMS_QUEUE_NAME}`);
+    //     return 'Received';
+    // },
+};

package/src/jobs/msg91-sms-subscriber.service.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import smsQueueOptions from './msg91-sms-queue-options';
+import { Msg91SMSService } from '../services/sms/Msg91SMSService';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../interfaces";
+import { SmsFactory } from 'src/factories/sms.factory';
+
+@Injectable()
+export class Msg91SmsQueueSubscriber extends RabbitMqSubscriber<any> {
+    constructor(
+        // private readonly smsService: Msg91SMSService,
+        private readonly smsFactory: SmsFactory,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...smsQueueOptions
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        const smsService: Msg91SMSService = this.smsFactory.getSmsService(Msg91SMSService.name) as Msg91SMSService;
+        return smsService.sendSMSSynchronously(message);
+
+        // return this.smsService.sendSMSSynchronously(message);
+    }
+}

package/src/jobs/msg91-whatsapp-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import whatsappQueueOptions from './msg91-whatsapp-queue-options';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../interfaces";
+
+@Injectable()
+export class Msg91WhatsappQueuePublisher extends RabbitMqPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...whatsappQueueOptions
+        }
+    }
+}