@solidxai/core 0.1.6 → 0.1.8-beta.0

package/src/jobs/redis/api-email-subscriber-redis.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import apiEmailQueueConfig from './api-email-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { ElasticEmailService } from '../../services/mail/elastic-email.service';
+
+@Injectable()
+export class ApiEmailQueueSubscriberRedis extends RedisSubscriber<any> {
+    constructor(
+        private readonly emailService: ElasticEmailService,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...apiEmailQueueConfig
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        this.emailService.sendEmailSynchronously(message);
+    }
+}

package/src/jobs/redis/chatter-queue-options-redis.ts

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

package/src/jobs/redis/chatter-queue-publisher-redis.service.ts

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

package/src/jobs/redis/chatter-queue-subscriber-redis.service.ts

@@ -0,0 +1,46 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import chatterQueueConfig from './chatter-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { AuditQueuePayload } from '../rabbitmq/chatter-queue-publisher.service';
+import { ChatterMessageService } from '../../services/chatter-message.service';
+
+@Injectable()
+export class ChatterQueueSubscriberRedis extends RedisSubscriber<any> {
+    private readonly chatterQueueLogger = new Logger(ChatterQueueSubscriberRedis.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        private readonly chatterMessageService: ChatterMessageService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueConfig
+        }
+    }
+
+    async subscribe(message: QueueMessage<AuditQueuePayload>) {
+        const p = message.payload;
+        this.chatterQueueLogger.debug(`Audit event ${p.eventType} ${p.modelName}#${p.entityId}`);
+
+        switch (p.eventType) {
+            case 'insert':
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, { name: p.modelName } as any);
+                break;
+            case 'update':
+                await this.chatterMessageService.postAuditMessageOnUpdate(p.after, { name: p.modelName } as any, p.before, (p.updatedColumnNames || []).map(n => ({ propertyName: n })));
+                break;
+            case 'delete':
+                await this.chatterMessageService.postAuditMessageOnDelete(p.before, { name: p.modelName } as any, p.before);
+                break;
+        }
+    }
+}

package/src/jobs/redis/computed-field-evaluation-publisher-redis.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import computedFieldEvaluationQueueConfig from './computed-field-evaluation-queue-options-redis';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { ComputedFieldEvaluationPayload } from 'src/subscribers/computed-entity-field.subscriber';
+
+@Injectable()
+export class ComputedFieldEvaluationPublisherRedis extends RedisPublisher<ComputedFieldEvaluationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...computedFieldEvaluationQueueConfig
+        }
+    }
+}

package/src/jobs/redis/computed-field-evaluation-queue-options-redis.ts

@@ -0,0 +1,10 @@
+import { BrokerType } from "../../interfaces";
+
+const QUEUE_NAME = 'solid_computed_field_evaluation_queue_redis';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Redis,
+    queueName: QUEUE_NAME,
+    prefetch: 20
+};

package/src/jobs/redis/computed-field-evaluation-subscriber-redis.service.ts

@@ -0,0 +1,48 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import computedFieldEvaluationQueueConfig from './computed-field-evaluation-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { IEntityPostComputeFieldProvider, QueuesModuleOptions } from "../../interfaces";
+import { ComputedFieldEvaluationPayload } from 'src/subscribers/computed-entity-field.subscriber';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { PollerService } from '../../services/poller.service';
+
+@Injectable()
+export class ComputedFieldEvaluationSubscriberRedis extends RedisSubscriber<ComputedFieldEvaluationPayload> {
+    private readonly _logger = new Logger(ComputedFieldEvaluationSubscriberRedis.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly solidRegistry: SolidRegistry,
+        readonly poller: PollerService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...computedFieldEvaluationQueueConfig
+        }
+    }
+
+    async subscribe(message: QueueMessage<ComputedFieldEvaluationPayload>) {
+        const { databaseEntity, ...computedFieldMetadata } = message.payload;
+        const { computedFieldValueProviderName } = computedFieldMetadata;
+        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldValueProviderName);
+        const providerInstance = provider.instance as IEntityPostComputeFieldProvider<any, any>;
+        if (typeof providerInstance.postComputeAndSaveValue !== 'function') {
+            this._logger.warn(`Provider "${computedFieldValueProviderName}" does not implement postComputeAndSaveValue; skipping post-compute.`);
+            return;
+        }
+        await providerInstance.postComputeAndSaveValue(databaseEntity, {
+            ...computedFieldMetadata,
+            computedFieldValueProviderCtxt: {
+                ...(computedFieldMetadata.computedFieldValueProviderCtxt || {}),
+            },
+        });
+    }
+}

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

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

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

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

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

@@ -0,0 +1,57 @@
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import generateCodeQueueConfig from './generate-code-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { CodeGenerationOptions, QueuesModuleOptions } from "../../interfaces";
+import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { PollerService } from '../../services/poller.service';
+
+@Injectable()
+export class GenerateCodeSubscriberRedis extends RedisSubscriber<CodeGenerationOptions> {
+    private readonly generateCodeSubscriberLogger = new Logger(GenerateCodeSubscriberRedis.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        @Inject(forwardRef(() => ModelMetadataService))
+        readonly modelMetadataService: ModelMetadataService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...generateCodeQueueConfig
+        }
+    }
+
+    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);
+
+        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/redis/msg91-otp-publisher-redis.service.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/jobs/redis/msg91-whatsapp-queue-options-redis.ts

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

package/src/jobs/redis/msg91-whatsapp-subscriber-redis.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import whatsappQueueConfig from './msg91-whatsapp-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { Msg91WhatsappService } from '../../services/whatsapp/Msg91WhatsappService';
+
+@Injectable()
+export class Msg91WhatsappQueueSubscriberRedis extends RedisSubscriber<any> {
+    constructor(
+        private readonly whatsappService: Msg91WhatsappService,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...whatsappQueueConfig
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        this.whatsappService.sendWhatsAppMessageSynchronously(message);
+    }
+}

package/src/jobs/redis/smtp-email-publisher-redis.service.ts

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

package/src/jobs/redis/smtp-email-queue-options-redis.ts

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

package/src/jobs/redis/smtp-email-subscriber-redis.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import smtpEmailQueueConfig from './smtp-email-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { SMTPEMailService } from '../../services/mail/smtp-email.service';
+
+@Injectable()
+export class SmtpEmailQueueSubscriberRedis extends RedisSubscriber<any> {
+    constructor(
+        private readonly emailService: SMTPEMailService,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...smtpEmailQueueConfig
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        return this.emailService.sendEmailSynchronously(message);
+    }
+}

package/src/jobs/redis/test-queue-options-redis.ts

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

package/src/jobs/redis/test-queue-publisher-redis.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import testQueueConfig from './test-queue-options-redis';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { QueuesModuleOptions } from "../../interfaces";
+
+
+@Injectable()
+export class TestQueuePublisherRedis extends RedisPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...testQueueConfig
+        }
+    }
+}

package/src/jobs/redis/test-queue-subscriber-redis.service.ts

@@ -0,0 +1,44 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import testQueueConfig from './test-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+
+@Injectable()
+export class TestQueueSubscriberRedis extends RedisSubscriber<any> {
+    private readonly testQueueLogger = new Logger(TestQueueSubscriberRedis.name);
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...testQueueConfig
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        this.testQueueLogger.debug(`Received message: ${JSON.stringify(message)}`);
+
+        let timeoutSecondsParsed = 10;
+        const timeoutSeconds = message?.payload?.timeoutSeconds;
+        if (timeoutSeconds) {
+            timeoutSecondsParsed = +timeoutSeconds;
+        }
+
+        this.testQueueLogger.debug(`Processing message with timeout: ${timeoutSecondsParsed}`);
+
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                this.testQueueLogger.debug(`Processed message: ${JSON.stringify(message)}`);
+                resolve({ status: 'success', messageId: message.messageId, message: `Processed message` });
+            }, timeoutSecondsParsed * 1000);
+        });
+    }
+}