@solidxai/core 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidxai/core",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/helpers/schematic.service.ts

@@ -73,7 +73,7 @@ export class SchematicService {
       })
       .map((fieldName) => {
         // Using argument array eliminates the need for shell-specific quoting
-        return `--fieldNamesForRemoval=${fieldName}`;
+        return `--field-names-for-removal=${fieldName}`;
       });
   }
 

package/src/seeders/module-metadata-seeder.service.ts

@@ -654,7 +654,8 @@ export class ModuleMetadataSeederService {
                     action,
                     module,
                     parentMenuItem,
-                    sequenceNumber: m.sequenceNumber
+                    sequenceNumber: m.sequenceNumber,
+                    iconName: m.iconName,
                 };
 
                 // If existing, set its id so save() will perform an update, otherwise insert

package/src/seeders/seed-data/solid-core-metadata.json

@@ -5899,7 +5899,8 @@
       "sequenceNumber": 1,
       "actionUserKey": "appBuilder-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName" : "app_registration"
     },
     {
       "displayName": "Module",
@@ -5931,7 +5932,8 @@
       "sequenceNumber": 2,
       "actionUserKey": "layoutBuilder-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName": "space_dashboard"
     },
     {
       "displayName": "Menu Item",
@@ -5971,7 +5973,8 @@
       "sequenceNumber": 3,
       "actionUserKey": "media-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName":"perm_media"
     },
     {
       "displayName": "Media",
@@ -5995,7 +5998,8 @@
       "sequenceNumber": 4,
       "actionUserKey": "iam-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName": "person_shield"
     },
     {
       "displayName": "User",
@@ -6043,7 +6047,8 @@
       "sequenceNumber": 5,
       "actionUserKey": "queues-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName":"low_priority"
     },
     {
       "displayName": "Messages",
@@ -6067,7 +6072,8 @@
       "sequenceNumber": 6,
       "actionUserKey": "notification-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName":"notification_settings"
     },
     {
       "displayName": "Email",
@@ -6091,7 +6097,8 @@
       "sequenceNumber": 7,
       "actionUserKey": "other-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName":"other_admission"
     },
     {
       "displayName": "List of Values",
@@ -6171,7 +6178,8 @@
       "sequenceNumber": 8,
       "actionUserKey": "dasbhoard-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName" : "dashboard_customize"
     },
     {
       "displayName": "Dashboard",
@@ -6195,7 +6203,8 @@
       "sequenceNumber": 9,
       "actionUserKey": "settings-root",
       "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": ""
+      "parentMenuItemUserKey": "",
+      "iconName":"settings"
     },
     {
       "displayName": "App Settings",
@@ -11146,6 +11155,22 @@
               "sortable": true,
               "filterable": true
             }
+          },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "userAgent",
+              "sortable": true,
+              "filterable": true
+            }
+          },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "createdAt",
+              "sortable": true,
+              "filterable": true
+            }
           }
         ]
       }

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/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,6 +49,7 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
             username: url.username,
             password: decodeURIComponent(url.password),
             frameMax: 131072,
+            heartbeat: 30,
         });
 
         return connection
@@ -76,86 +80,235 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
                 }
             }
 
-            // this.logger.debug(`RabbitMqSubscriber instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
-            // const connection = await amqp.connect(this.url);
-
-            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 exchangeName = `${queueName}.exchange`;
-            const routingKey = `${queueName}.routing-key`;
+        const consumeResult = await channel.consume(
+            queueName,
+            async (rawMessage) => {
+                if (!rawMessage) {
+                    return;
+                }
 
-            await channel.assertExchange(exchangeName, 'direct', {});
-            // this.logger.debug(`RabbitMqSubscriber channel asserted: ${JSON.stringify(this.options())} and url: ${url}`);
+                const messageContentString = rawMessage.content.toString();
+                let message: QueueMessage<T> = null;
 
-            const queue = await channel.assertQueue(queueName, {});
-            // this.logger.debug(`RabbitMqSubscriber queue asserted: ${JSON.stringify(this.options())} and url: ${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;
+                }
 
-            await channel.bindQueue(queue.queue, exchangeName, routingKey);
-            // this.logger.debug(`RabbitMqSubscriber queue bound: ${JSON.stringify(this.options())} and url: ${url}`);
+                if (!message.retryCount) message.retryCount = 0;
+                if (!message.retryInterval) message.retryInterval = 1000;
+                if (!message.currentRetry) message.currentRetry = 0;
 
-            // 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}`);
+                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 },
+        );
 
-                        let message: QueueMessage<T> = null;
+        this.consumerTag = consumeResult.consumerTag;
+    }
 
-                        try {
-                            message = JSON.parse(messageContentString) as QueueMessage<T>;
+    // 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}`);
 
-                            // 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;
+        if (message.currentRetry < message.retryCount) {
+            await this.updateStatusInDatabase('retrying', message);
 
-                            await this.processMessage(message, rawMessage, channel);
-                        }
-                        catch (error) {
-                            this.logger.error(`Error processing message: ${error.message}`);
+            message.currentRetry++;
+            const retryQueue = `${queueName}.retry`;
+            const payload = Buffer.from(JSON.stringify(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);
+            // 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,
+                }
+            });
 
-                                    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, '');
+            channel.ack(rawMessage);
+            this.logger.warn(`Retrying message (${message.currentRetry}/${message.retryCount}) after ${message.retryInterval}ms on queue ${queueName}`);
+            return;
+        }
 
-                                    this.logger.error(`Message failed after ${message.retryCount} attempts: ${error.message}`);
-                                    channel.ack(rawMessage); // Discard the message after max retries
-                                }
-                            }
+        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}`);
+    }
 
-                        }
-                    }
-                },
-                // { noAck: true },
-                {},
-            );
+    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 || '');
 
-            this.logger.log(`RabbitMqSubscriber ready to consume messages: ${JSON.stringify(this.options())} and url: ${this.url}`);
+        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.
      */
@@ -168,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({