@solidxai/core 0.1.0 → 0.1.2

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

@@ -18,6 +18,7 @@ import { ChatterMessageDetails } from '../entities/chatter-message-details.entit
 import { ChatterMessage } from '../entities/chatter-message.entity';
 import { getMediaStorageProvider } from './mediaStorageProviders';
 import { RequestContextService } from './request-context.service';
+import { take } from 'rxjs';
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage> {
     constructor(
@@ -331,28 +332,28 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         if (field.type === 'relation') {
             if (field.relationType === "many-to-one") {
-            if (value.name) {
-                return value.name;
-            }
-            
-            try {
-                const relatedModel = await this.modelMetadataRepo.findOne({
-                where: { singularName: field.relationCoModelSingularName || field.relation },
-                relations: { userKeyField: true }
-                });
-                
-                if (relatedModel && relatedModel.userKeyField) {
-                const userKeyFieldName = relatedModel.userKeyField.name;
-                return value[userKeyFieldName] ? value[userKeyFieldName].toString() : '';
+                if (value.name) {
+                    return value.name;
                 }
-                
-                if (value.id) {
-                return value.id.toString();
+
+                try {
+                    const relatedModel = await this.modelMetadataRepo.findOne({
+                        where: { singularName: field.relationCoModelSingularName || field.relation },
+                        relations: { userKeyField: true }
+                    });
+
+                    if (relatedModel && relatedModel.userKeyField) {
+                        const userKeyFieldName = relatedModel.userKeyField.name;
+                        return value[userKeyFieldName] ? value[userKeyFieldName].toString() : '';
+                    }
+
+                    if (value.id) {
+                        return value.id.toString();
+                    }
+                } catch (error) {
+                    console.error('Error fetching related model metadata:', error);
+                    return value.id ? value.id.toString() : '';
                 }
-            } catch (error) {
-                console.error('Error fetching related model metadata:', error);
-                return value.id ? value.id.toString() : '';
-            }
             }
 
             if (field.relationType === 'many-to-many') {
@@ -501,11 +502,9 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         return populatedEntity;
     }
 
-    async getChatterMessages(
-        entityId: number,
-        entityName: string,
-        query: any
-    ) {
+    // [2026-02-05T23:31:21.025Z] INFO: [200 OK] 
+    // GET /api/chatter-message/getChatterMessages/216/mswipeBoomboxBulkUpload?populateMedia[0]=messageAttachments&populate[0]=user&populate[1]=chatterMessageDetails&limit=25 22747ms
+    async getChatterMessages(entityId: number, entityName: string, query: any) {
         const { limit = 25, offset = 0, populate = [], populateMedia = [], filters } = query;
 
         const model = await this.modelMetadataRepo.findOne({
@@ -524,6 +523,9 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         const relatedEntitiesMap = new Map<string, number[]>();
 
         for (const field of oneToManyFields) {
+            if (field.enableAuditTracking === false) {
+                continue
+            }
             const coModelName = field.relationCoModelSingularName;
             const coModelFieldName = field.relationCoModelFieldName;
 
@@ -539,7 +541,11 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
                 const relatedEntityRepository = em.getRepository(classify(coModelName));
 
                 const relatedEntities = await relatedEntityRepository.find({
-                    where: { [coModelFieldName]: { id: entityId } }
+                    select: {
+                        id: true,
+                    },
+                    where: { [coModelFieldName]: { id: entityId } },
+                    take: 5,
                 });
 
                 const relatedIds = relatedEntities.map((entity: any) => entity.id);

package/src/services/crud-helper.service.ts

@@ -164,7 +164,7 @@ export class CrudHelperService {
     }
 
     normalize(value: string | string[]): string[] {
-        if (!value) return [];// if the value is nullish, then return an empty array
+        if (!value) return []; // if the value is nullish, then return an empty array
         return Array.isArray(value) ? value : [value];        // if the value is an array, return it as is, otherwise return it as an array
     }
 

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

@@ -876,7 +876,8 @@ export class ModelMetadataService {
       sequenceNumber: 1,
       actionUserKey: actionName,
       moduleUserKey: `${model.module.name}`,
-      parentMenuItemUserKey: ""
+      parentMenuItemUserKey: "",
+      iconName : ""
     };
 
     const modelListview = {

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

@@ -181,7 +181,8 @@ export class ModuleMetadataService {
             sequenceNumber: 1,
             actionUserKey: `${module?.name}-home-action`,
             moduleUserKey: module?.name,
-            parentMenuItemUserKey: ""
+            parentMenuItemUserKey: "",
+            iconName : "home"
           }
         ],
         views: [],

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

@@ -18,7 +18,7 @@ export abstract class DatabasePublisher<T> implements QueuePublisher<T> {
         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())}`);
+        // this.logger.debug(`DatabasePublisher instance created with options: ${JSON.stringify(this.options())}`);
     }
 
     abstract options(): QueuesModuleOptions;

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

@@ -20,7 +20,7 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
         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())}`);
+        // this.logger.debug(`DatabaseSubscriber instance created with options: ${JSON.stringify(this.options())}`);
     }
 
     abstract subscribe(message: QueueMessage<T>);
@@ -72,42 +72,31 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
         // 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> {
+        // Not using SettingService here as that will necessitate all implementors of DatabaseSubscriber to also inject SettingService which is not ideal. 
+        // Instead we directly read the environment variables here.
         const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'database';
         const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+        const queueNameRegex = (process.env.QUEUES_QUEUE_NAME_REGEX_TO_ENABLE || '').trim();
 
         // 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;
 
+            if (queueNameRegex && queueNameRegex !== "all") {
+                try {
+                    const regex = new RegExp(queueNameRegex);
+                    if (!regex.test(queueName)) {
+                        this.logger.log(`DatabaseSubscriber for queue ${queueName} is disabled because it does not match QUEUES_QUEUE_NAME_REGEX_TO_ENABLE=${queueNameRegex}`);
+                        return;
+                    }
+                } catch (error) {
+                    this.logger.error(`Invalid QUEUES_QUEUE_NAME_REGEX_TO_ENABLE regex "${queueNameRegex}". Subscriber for queue ${queueName} will not start.`);
+                    return;
+                }
+            }
+
             this.poller.start(queueName, (q) => this.processNext(q), {
                 baseDelayMs: 1000,
                 maxDelayMs: 30_000,

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

@@ -10,11 +10,14 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
     private readonly logger = new Logger(RabbitMqSubscriber.name);
     private readonly url: string;
     private readonly serviceRole: string;
-
-    constructor(
-        protected readonly mqMessageService: MqMessageService,
-        protected readonly mqMessageQueueService: MqMessageQueueService,
-    ) {
+    private connection: amqp.Connection | null = null;
+    private channel: amqp.Channel | null = null;
+    private consumerTag: string | null = null;
+    private reconnectPromise: Promise<void> | null = null;
+    private reconnectAttempt = 0;
+    private stopping = false;
+
+    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) {
@@ -46,100 +49,266 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
             username: url.username,
             password: decodeURIComponent(url.password),
             frameMax: 131072,
+            heartbeat: 30,
         });
 
         return connection
     }
 
     async onModuleInit(): Promise<void> {
+        // Not using SettingService here as that will necessitate all implementors of RabbitMqSubscriber to also inject SettingService which is not ideal. 
+        // Instead we directly read the environment variables here.
+        const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'rabbitmq';
         const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+        const queueNameRegex = (process.env.QUEUES_QUEUE_NAME_REGEX_TO_ENABLE || '').trim();
 
         // we will start subscriber only if the current service role is subscriber. 
-        if (this.url && ['both', 'subscriber'].includes(this.serviceRole) && solidCliRunning === "false") {
+        if (this.url && ['both', 'subscriber'].includes(this.serviceRole) && solidCliRunning === "false" && defaultBroker === 'rabbitmq') {
+            const options = this.options();
+            const queueName = options.queueName;
 
-            // this.logger.debug(`RabbitMqSubscriber instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
-            // const connection = await amqp.connect(this.url);
+            if (queueNameRegex && queueNameRegex !== "all") {
+                try {
+                    const regex = new RegExp(queueNameRegex);
+                    if (!regex.test(queueName)) {
+                        this.logger.log(`RabbitMqSubscriber for queue ${queueName} is disabled because it does not match QUEUES_QUEUE_NAME_REGEX_TO_ENABLE=${queueNameRegex}`);
+                        return;
+                    }
+                } catch (error) {
+                    this.logger.error(`Invalid QUEUES_QUEUE_NAME_REGEX_TO_ENABLE regex "${queueNameRegex}". Subscriber for queue ${queueName} will not start.`);
+                    return;
+                }
+            }
 
-            let connection;
             try {
-                connection = await this.establishConnection();
-                // this.logger.debug(`RabbitMqSubscriber connection established: ${JSON.stringify(this.options())} and url: ${this.url}`);
+                await this.connectAndConsume(queueName);
+            } catch (err) {
+                this.logger.error(`Failed to connect to RabbitMQ for queue ${queueName}: ${(err as Error).message}`, (err as Error).stack);
+                this.triggerReconnect(queueName, 'initial connection failure');
             }
-            catch (err) {
-                this.logger.error(`Failed to connect to RabbitMQ: ${(err as Error).message}`, (err as Error).stack);
-                throw err;
+
+            this.logger.log(`RabbitMqSubscriber ready to consume messages: ${JSON.stringify(this.options())} and url: ${this.url}`);
+        }
+    }
+
+    private async connectAndConsume(queueName: string): Promise<void> {
+        await this.cleanup();
+
+        let connection: amqp.Connection;
+        try {
+            connection = await this.establishConnection();
+        } catch (err) {
+            this.logger.error(`Failed to connect to RabbitMQ for queue ${queueName}: ${(err as Error).message}`, (err as Error).stack);
+            throw err;
+        }
+
+        this.connection = connection;
+
+        connection.on('error', (err) => {
+            if (connection !== this.connection) return;
+            this.logger.error(`RabbitMqSubscriber connection error for queue ${queueName}: ${(err as Error).message}`);
+        });
+
+        connection.on('close', () => {
+            if (connection !== this.connection) return;
+            this.logger.warn(`RabbitMqSubscriber connection closed for queue ${queueName}`);
+            this.triggerReconnect(queueName, 'connection closed');
+        });
+
+        const channel = await connection.createChannel();
+        this.channel = channel;
+
+        channel.on('error', (err) => {
+            if (channel !== this.channel) return;
+            this.logger.error(`RabbitMqSubscriber channel error for queue ${queueName}: ${(err as Error).message}`);
+        });
+
+        channel.on('close', () => {
+            if (channel !== this.channel) return;
+            this.logger.warn(`RabbitMqSubscriber channel closed for queue ${queueName}`);
+            this.triggerReconnect(queueName, 'channel closed');
+        });
+
+        // Process one message at a time per consumer to avoid parallel work on the same subscriber instance.
+        await channel.prefetch(1);
+
+        // Use a direct exchange with a stable routing key so retry DLX can route back to the main queue.
+        const exchangeName = `${queueName}.exchange`;
+        const routingKey = `${queueName}.routing-key`;
+        const retryQueue = `${queueName}.retry`;
+        const failedQueue = `${queueName}.failed`;
+
+        await channel.assertExchange(exchangeName, 'direct', {});
+        await channel.assertQueue(queueName, {});
+        await channel.bindQueue(queueName, exchangeName, routingKey);
+
+        // Retry queue uses DLX to route expired messages back to the main exchange/routing key.
+        await channel.assertQueue(retryQueue, {
+            arguments: {
+                'x-dead-letter-exchange': exchangeName,
+                'x-dead-letter-routing-key': routingKey,
             }
+        });
 
-            const channel = await connection.createChannel();
-            // this.logger.debug(`RabbitMqSubscriber channel created: ${JSON.stringify(this.options())} and url: ${url}`);
+        await channel.assertQueue(failedQueue, {});
 
-            const options = this.options();
+        const consumeResult = await channel.consume(
+            queueName,
+            async (rawMessage) => {
+                if (!rawMessage) {
+                    return;
+                }
 
-            const queueName = options.queueName;
-            const exchangeName = `${queueName}.exchange`;
-            const routingKey = `${queueName}.routing-key`;
-
-            await channel.assertExchange(exchangeName, 'direct', {});
-            // this.logger.debug(`RabbitMqSubscriber channel asserted: ${JSON.stringify(this.options())} and url: ${url}`);
-
-            const queue = await channel.assertQueue(queueName, {});
-            // this.logger.debug(`RabbitMqSubscriber queue asserted: ${JSON.stringify(this.options())} and url: ${url}`);
-
-            await channel.bindQueue(queue.queue, exchangeName, routingKey);
-            // this.logger.debug(`RabbitMqSubscriber queue bound: ${JSON.stringify(this.options())} and url: ${url}`);
-
-            // Consume messages from the queue
-            channel.consume(
-                queue.queue,
-                async (rawMessage) => {
-                    if (rawMessage) {
-                        const messageContentString = rawMessage.content.toString();
-                        // this.logger.debug(`RabbitMqSubscriber 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, rawMessage, channel);
-                        }
-                        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, rawMessage, channel);
-                                    }, message.retryInterval);
-                                } else {
-                                    await this.updateStatusInDatabase('failed', message, error.message, '');
-
-                                    this.logger.error(`Message failed after ${message.retryCount} attempts: ${error.message}`);
-                                    channel.ack(rawMessage); // Discard the message after max retries
-                                }
-                            }
-
-                        }
-                    }
-                },
-                // { noAck: true },
-                {},
-            );
+                const messageContentString = rawMessage.content.toString();
+                let message: QueueMessage<T> = null;
 
-            this.logger.log(`RabbitMqSubscriber ready to consume messages: ${JSON.stringify(this.options())} and url: ${this.url}`);
+                try {
+                    message = JSON.parse(messageContentString) as QueueMessage<T>;
+                } catch (error) {
+                    this.logger.error(`Invalid JSON message on queue ${queueName}: ${(error as Error).message}`);
+                    await this.publishToFailedQueue(queueName, rawMessage.content, channel, error);
+                    channel.ack(rawMessage);
+                    return;
+                }
+
+                if (!message.retryCount) message.retryCount = 0;
+                if (!message.retryInterval) message.retryInterval = 1000;
+                if (!message.currentRetry) message.currentRetry = 0;
+
+                try {
+                    await this.processMessage(message, rawMessage, channel);
+                } catch (error) {
+                    await this.handleProcessingError(message, rawMessage, channel, error, queueName);
+                }
+            },
+            // Explicit ack enables reliable processing and retry routing.
+            { noAck: false },
+        );
+
+        this.consumerTag = consumeResult.consumerTag;
+    }
+
+    // Retry flow: update DB -> increment retry -> send to retry queue with per-message expiration -> ack original.
+    private async handleProcessingError(message: QueueMessage<T>, rawMessage: amqp.ConsumeMessage, channel: amqp.Channel, error: any, queueName: string): Promise<void> {
+        const errorMessage = (error as Error)?.message || String(error);
+        this.logger.error(`Error processing message on queue ${queueName}: ${errorMessage}`);
+
+        if (message.currentRetry < message.retryCount) {
+            await this.updateStatusInDatabase('retrying', message);
+
+            message.currentRetry++;
+            const retryQueue = `${queueName}.retry`;
+            const payload = Buffer.from(JSON.stringify(message));
+
+            // Per-message expiration keeps the message in the retry queue until TTL, then DLX routes it back.
+            channel.sendToQueue(retryQueue, payload, {
+                expiration: String(message.retryInterval || 1000),
+                headers: {
+                    'x-error': errorMessage,
+                }
+            });
+
+            channel.ack(rawMessage);
+            this.logger.warn(`Retrying message (${message.currentRetry}/${message.retryCount}) after ${message.retryInterval}ms on queue ${queueName}`);
+            return;
+        }
+
+        await this.updateStatusInDatabase('failed', message, errorMessage, '');
+        channel.ack(rawMessage);
+        await this.publishToFailedQueue(queueName, Buffer.from(JSON.stringify(message)), channel, error);
+        this.logger.error(`Message failed after ${message.retryCount} attempts on queue ${queueName}: ${errorMessage}`);
+    }
+
+    private async publishToFailedQueue(queueName: string, payload: Buffer | string, channel: amqp.Channel, error?: any): Promise<void> {
+        const failedQueue = `${queueName}.failed`;
+        const body = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+        const errorMessage = (error as Error)?.message || String(error || '');
+
+        try {
+            channel.sendToQueue(failedQueue, body, errorMessage ? {
+                headers: { 'x-error': errorMessage }
+            } : undefined);
+        } catch (err) {
+            this.logger.error(`Failed to publish to failed queue ${failedQueue}: ${(err as Error).message}`);
+        }
+    }
+
+    private triggerReconnect(queueName: string, reason: string) {
+        if (this.stopping) return;
+        if (this.reconnectPromise) return;
+
+        this.reconnectPromise = this.reconnectLoop(queueName, reason)
+            .finally(() => {
+                this.reconnectPromise = null;
+            });
+    }
+
+    // Reconnect with backoff to avoid hammering the broker during outages.
+    private async reconnectLoop(queueName: string, reason: string): Promise<void> {
+        this.logger.warn(`RabbitMqSubscriber reconnecting for queue ${queueName}: ${reason}`);
+
+        while (!this.stopping) {
+            try {
+                await this.connectAndConsume(queueName);
+                this.reconnectAttempt = 0;
+                this.logger.log(`RabbitMqSubscriber reconnected for queue ${queueName}`);
+                return;
+            } catch (err) {
+                this.reconnectAttempt += 1;
+                const delay = this.backoff();
+                this.logger.warn(`RabbitMqSubscriber reconnect failed for queue ${queueName}; retrying in ${delay}ms`);
+                await this.sleep(delay);
+            }
         }
     }
 
+    private async cleanup(): Promise<void> {
+        const channel = this.channel;
+        const connection = this.connection;
+        const consumerTag = this.consumerTag;
+
+        this.channel = null;
+        this.connection = null;
+        this.consumerTag = null;
+
+        if (channel) {
+            try {
+                if (consumerTag) {
+                    await channel.cancel(consumerTag);
+                }
+            } catch (_) {
+                // ignore
+            }
+
+            try {
+                await channel.close();
+            } catch (_) {
+                // ignore
+            }
+        }
+
+        if (connection) {
+            try {
+                await connection.close();
+            } catch (_) {
+                // ignore
+            }
+        }
+    }
+
+    private sleep(ms: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    // Exponential backoff with jitter, capped to 30s.
+    private backoff(): number {
+        const baseMs = 1000;
+        const maxMs = 30_000;
+        const exp = Math.min(maxMs, baseMs * Math.pow(2, this.reconnectAttempt));
+        const jitter = Math.floor(Math.random() * (exp * 0.2));
+        return Math.min(maxMs, exp + jitter);
+    }
+
     /**
      * Abstract method for message processing logic.
      */
@@ -152,43 +321,14 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         // Ack the message. 
         channel.ack(rawMessage);
 
-        // TODO: Update the database to indicate that the task is finished.
+        // Persist success output and timing.
         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>, rawMessage, channel) {
-        try {
-            await this.processMessage(message, rawMessage, channel);
-        } 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, rawMessage, channel);
-                }, message.retryInterval);
-            } else {
-
-                this.logger.error(`Message failed after ${message.retryCount} attempts: ${error.message}`);
-
-                // Discard the message after max retries
-                channel.ack(rawMessage);
-
-                // 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 = '') {
 
-        // TODO: make an entry in the relevant database table, generate a unique id earlier.
+        // Update the existing message record by messageId; creation happens upstream.
         try {
             // 1. resolve the queue first
             const mqMessage = await this.mqMessageService.repo.findOne({
@@ -220,4 +360,4 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
 
     }
 
-}
+}