@solidstarters/solid-core 1.2.146 → 1.2.149

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

@@ -4919,7 +4919,7 @@
         "tableName": "ss_ai_interactions",
         "dataSource": "default",
         "dataSourceType": "postgres",
-        "userKeyFieldUserKey": "message",
+        "userKeyFieldUserKey": "externalId",
         "isSystem": false,
         "fields": [
           {
@@ -4938,6 +4938,35 @@
             "relationModelModuleName": "solid-core",
             "isSystem": true
           },
+          {
+            "name": "externalId",
+            "displayName": "External ID",
+            "description": "Used to track using a reference number of each ai interaction.",
+            "type": "computed",
+            "ormType": "varchar",
+            "isSystem": false,
+            "computedFieldValueType": "string",
+            "computedFieldTriggerConfig": [
+              {
+                "modelName": "aiInteraction",
+                "moduleName": "solid-core",
+                "operations": [
+                  "before-insert"
+                ]
+              }
+            ],
+            "computedFieldValueProvider": "AlphaNumExternalIdComputationProvider",
+            "computedFieldValueProviderCtxt": "{\n  \"prefix\": \"AI\",\n  \"length\": \"10\"\n}",
+            "required": true,
+            "unique": true,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "encryptionType": null,
+            "decryptWhen": null,
+            "columnName": null,
+            "isUserKey": true
+          },
           {
             "name": "threadId",
             "displayName": "Thread ID",
@@ -4950,6 +4979,22 @@
             "private": false,
             "encrypt": false
           },
+          {
+            "name": "parentInteraction",
+            "displayName": "Parent Interaction",
+            "type": "relation",
+            "required": false,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "relationType": "many-to-one",
+            "relationCoModelSingularName": "aiInteraction",
+            "relationCreateInverse": false,
+            "relationCascade": "set null",
+            "relationModelModuleName": "solid-core",
+            "isSystem": true
+          },
           {
             "name": "role",
             "displayName": "Role",
@@ -5057,6 +5102,17 @@
             "index": false,
             "private": false,
             "encrypt": false
+          },
+          {
+            "name": "isAutoApply",
+            "displayName": "Is Auto Apply",
+            "type": "boolean",
+            "ormType": "boolean",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false
           }
         ]
       }
@@ -11867,7 +11923,7 @@
       }
     },
     {
-      "name": "ai-interaction-list-view",
+      "name": "aiInteraction-list-view",
       "displayName": "AI Interaction",
       "type": "list",
       "context": "{}",
@@ -11900,6 +11956,18 @@
               "name": "threadId"
             }
           },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "externalId"
+            }
+          },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "parentInteraction"
+            }
+          },
           {
             "type": "field",
             "attrs": {
@@ -11934,7 +12002,7 @@
       }
     },
     {
-      "name": "ai-interaction-form-view",
+      "name": "aiInteraction-form-view",
       "displayName": "AI Interaction",
       "type": "form",
       "context": "{}",
@@ -11987,6 +12055,12 @@
                                   "name": "user"
                                 }
                               },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "externalId"
+                                }
+                              },
                               {
                                 "type": "field",
                                 "attrs": {
@@ -12034,6 +12108,12 @@
                                 "attrs": {
                                   "name": "responseTimeMs"
                                 }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "parentInteraction"
+                                }
                               }
                             ]
                           }

package/src/services/ai-interaction.service.ts

@@ -43,7 +43,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
   }
 
-  async triggerMcpClientJob(prompt: string): Promise<string> {
+  async triggerMcpClientJob(prompt: string): Promise<any> {
     const activeUser: ActiveUserData = this.requestContextService.getActiveUser();
 
     const aiInteraction = await this.create({
@@ -65,7 +65,12 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
       parentEntityId: aiInteraction.id,
     };
 
-    return await this.publisherFactory.publish(m, 'TriggerMcpClientPublisher');
+    const queueMessageId = await this.publisherFactory.publish(m, 'TriggerMcpClientPublisher');
+
+    return {
+      queueMessageId: queueMessageId,
+      aiInteractionId: aiInteraction.id
+    }
   }
 
   /**
@@ -206,7 +211,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
 
     // TODO: This provider to implement an interface - IMcpToolResponseHandler ... apply(aiInteraction: AiInteraction)
     // throw new Error('Method not implemented.');
-    
+
     // Mark the interaction as applied
     await this.update(aiInteraction.id, { isApplied: true }, [], true);
 

package/src/services/mail/smtp-email.service.ts

@@ -47,7 +47,7 @@ export class SMTPEMailService implements IMail {
         cc?: string[],
         bcc?: string[],
         from?: string
-    ): Promise<void> {
+    ) {
         // Load template and evaluate it.
         const emailTemplate = await this.emailTemplateService.findOneByName(templateName);
         if (!emailTemplate) {
@@ -63,7 +63,7 @@ export class SMTPEMailService implements IMail {
         const subject = subjectTemplate(templateParams);
 
         // Finally send the email.
-        await this.sendEmail(to, subject, body, shouldQueueEmails, wrapperAttachments, attachments, parentEntity, parentEntityId, cc, bcc, from);
+        return await this.sendEmail(to, subject, body, shouldQueueEmails, wrapperAttachments, attachments, parentEntity, parentEntityId, cc, bcc, from);
     }
 
     async sendEmail(
@@ -78,7 +78,7 @@ export class SMTPEMailService implements IMail {
         cc?: string[],
         bcc?: string[],
         from?: string
-    ): Promise<void> {
+    ) {
         const message = {
             payload: {
                 from: from || this.commonConfiguration.smtpMail.from,
@@ -95,33 +95,34 @@ export class SMTPEMailService implements IMail {
 
         // Send using queue if the developer has explicitly invoked with true.
         if (shouldQueueEmails === true) {
-            this.sendEmailAsynchronously(message);
+            return this.sendEmailAsynchronously(message);
         }
         // If developer has not, however system config mandates that we send using queue, still we send.
         else if (shouldQueueEmails == false && this.commonConfiguration.shouldQueueEmails === true) {
-            this.sendEmailAsynchronously(message);
+            return this.sendEmailAsynchronously(message);
         }
-        // Else we send synch
+        // Else we send synchronously
         else {
-            await this.sendEmailSynchronously(message);
+            return await this.sendEmailSynchronously(message);
         }
     }
 
     async sendEmailAsynchronously(message) {
         const { to, subject, body } = message.payload;
-        // this.notificationPublisherService.publish(message);
-        // this.emailPublisher.publish(message);
-        // this.emailDbPublisher.publish(message);
-
-        this.publisherFactory.publish(message, 'SmtpEmailQueuePublisher');
-
         this.logger.debug(`Queueing email to ${to} with subject ${subject} and body ${body}`);
+        return this.publisherFactory.publish(message, 'SmtpEmailQueuePublisher');
     }
 
-    async sendEmailSynchronously(message: QueueMessage<any>): Promise<void> {
-        const { from, to, subject, body, attachments, cc, bcc } = message.payload;
+    async sendEmailSynchronously(message: QueueMessage<any>) {
+        const { from, to, subject, body, attachments = [], cc, bcc } = message.payload;
 
-        const attachmentsList = attachments.map((attachment: MailAttachment) => {
+        // if any of the required fields are missing, throw an error.
+        if (!from || !to || !subject || !body) {
+            this.logger.error(`Required fields are missing in the email message: ${JSON.stringify(message.payload)}`);
+            return;
+        }
+
+        const attachmentsList = attachments?.map((attachment: MailAttachment) => {
             const attachmentEntry = {
                 filename: attachment.filename,
                 contentType: attachment.contentType,
@@ -133,7 +134,7 @@ export class SMTPEMailService implements IMail {
                 attachmentEntry['content'] = attachment.content;
             }
             return attachmentEntry;
-        });
+        }) || [];
 
         // throw new Error('Random error....');
         const r = await this.transporter.sendMail({

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

@@ -68,4 +68,120 @@ export class MqMessageService extends CRUDService<MqMessage> {
     });
   }
 
+/**
+ * Wait until a queue message reaches a terminal status (succeeded/failed).
+ *
+ * @param messageId string – the external message id you store in `ss_mq_message.messageId`
+ * @param opts.timeoutMs total time to wait before giving up (default 60s)
+ * @param opts.intervalMs initial poll interval (default 500ms)
+ * @param opts.maxIntervalMs cap for exponential backoff (default 2000ms)
+ * @param opts.throwOnFailure if true, throws when stage === 'failed' (default false)
+ * @param opts.parseJson try JSON.parse on `output` and `error` (default true)
+ * @returns resolves with the final MqMessage row when terminal, rejects on timeout (or failure if throwOnFailure)
+ */
+  async waitForTerminalStatus(
+    messageId: string,
+    opts?: {
+      timeoutMs?: number;
+      intervalMs?: number;
+      maxIntervalMs?: number;
+      throwOnFailure?: boolean;
+      parseJson?: boolean;
+      logEveryN?: number;
+    },
+  ): Promise<MqMessage> {
+    const {
+      timeoutMs = 60_000,
+      intervalMs = 500,
+      maxIntervalMs = 2_000,
+      throwOnFailure = false,
+      parseJson = true,
+      logEveryN = 10, // log every N polls to avoid noisy logs
+    } = opts || {};
+
+    const start = Date.now();
+    let attempt = 0;
+    let delay = intervalMs;
+
+    // Small helper
+    const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+    while (true) {
+      attempt++;
+
+      // Fetch minimal columns needed for quick polling
+      const rec = await this.repo.findOne({
+        where: { messageId },
+        select: {
+          id: true,
+          messageId: true,
+          stage: true,
+          finishedAt: true,
+          elapsedMillis: true,
+          output: true,
+          error: true,
+          input: true,
+          // add other fields if you need to return them
+        } as any,
+        loadEagerRelations: false,
+      });
+
+      if (attempt % logEveryN === 0) {
+        this.logger.debug(
+          `waitForTerminalStatus(${messageId}) poll #${attempt} -> ${rec?.stage ?? 'not_found'}`
+        );
+      }
+
+      if (!rec) {
+        // Not found yet – keep waiting until timeout
+      } else if (rec.stage === 'succeeded' || rec.stage === 'failed') {
+        // Optionally parse output/error if they contain JSON strings
+        if (parseJson) {
+          rec.output = this.safeJsonParse(rec.output);
+          rec.error = this.safeJsonParse(rec.error);
+        }
+
+        if (rec.stage === 'failed' && throwOnFailure) {
+          throw new Error(
+            `Queue message ${messageId} failed` +
+            (rec.error ? `: ${JSON.stringify(rec.error).slice(0, 500)}` : '')
+          );
+        }
+        return rec;
+      }
+
+      // Timeout?
+      const elapsed = Date.now() - start;
+      if (elapsed >= timeoutMs) {
+        throw new Error(`Timed out after ${timeoutMs}ms waiting for message ${messageId} to reach terminal status`);
+      }
+
+      // Backoff with cap
+      await sleep(delay);
+      delay = Math.min(Math.floor(delay * 1.5), maxIntervalMs);
+    }
+  }
+
+  // /**
+  //  * Optional wrapper: publish and then wait (if your publisher returns the messageId).
+  //  */
+  // async publishAndWait<T>(
+  //   publishFn: () => Promise<string>, // returns messageId
+  //   waitOpts?: Parameters<MqMessageService['waitForTerminalStatus']>[1],
+  // ): Promise<MqMessage> {
+  //   const messageId = await publishFn();
+  //   return this.waitForTerminalStatus(messageId, waitOpts);
+  // }
+
+  private safeJsonParse(value: unknown): unknown {
+    if (value == null) return value;
+    if (typeof value !== 'string') return value;
+    const s = value.trim();
+    if (!s) return s;
+    try {
+      return JSON.parse(s);
+    } catch {
+      return value; // leave as-is if not valid JSON
+    }
+  }
 }

package/src/services/poller.service.ts

@@ -0,0 +1,163 @@
+// src/common/poller/poller.service.ts
+import {
+    Injectable,
+    Logger,
+    OnModuleDestroy,
+    BeforeApplicationShutdown,
+} from '@nestjs/common';
+
+export interface PollOptions {
+    /** Wait after a successful iteration */
+    baseDelayMs?: number;            // default 1000
+    /** Maximum delay after repeated failures */
+    maxDelayMs?: number;             // default 30000
+    /** Per-iteration timeout guard */
+    timeoutPerIterationMs?: number;  // default 60000
+    /** Add jitter to spread load */
+    jitter?: boolean;                // default true
+}
+
+type ProcessNextFn = (queueName: string) => Promise<unknown>;
+
+interface PollerState {
+    queueName: string;
+    processNext: ProcessNextFn;
+    opts: Required<PollOptions>;
+    inFlight: boolean;
+    stopped: boolean;
+    backoff: number;
+    nextTimer?: NodeJS.Timeout;
+}
+
+@Injectable()
+export class PollerService implements OnModuleDestroy, BeforeApplicationShutdown {
+    private readonly logger = new Logger(PollerService.name);
+    private readonly pollers = new Map<string, PollerState>();
+
+    start(queueName: string, processNext: ProcessNextFn, options: PollOptions = {}): void {
+        if (this.pollers.has(queueName)) {
+            this.logger.warn(`Poller "${queueName}" already started; ignoring.`);
+            return;
+        }
+
+        const opts: Required<PollOptions> = {
+            baseDelayMs: options.baseDelayMs ?? 1000,
+            maxDelayMs: options.maxDelayMs ?? 30_000,
+            timeoutPerIterationMs: options.timeoutPerIterationMs ?? 5 * 60_000,
+            jitter: options.jitter ?? true,
+        };
+
+        const state: PollerState = {
+            queueName,
+            processNext,
+            opts,
+            inFlight: false,
+            stopped: false,
+            backoff: opts.baseDelayMs,
+            nextTimer: undefined,
+        };
+
+        this.pollers.set(queueName, state);
+        // kick off on next tick
+        setImmediate(() => this.poll(state).catch(() => { }));
+        this.logger.log(`Started poller "${queueName}"`);
+    }
+
+    stop(queueName: string): void {
+        const state = this.pollers.get(queueName);
+        if (!state) return;
+
+        state.stopped = true;
+        if (state.nextTimer) {
+            clearTimeout(state.nextTimer);
+            state.nextTimer = undefined;
+        }
+        this.pollers.delete(queueName);
+        this.logger.log(`Stopped poller "${queueName}"`);
+    }
+
+    stopAll(): void {
+        for (const name of Array.from(this.pollers.keys())) {
+            this.stop(name);
+        }
+    }
+
+    async onModuleDestroy(): Promise<void> {
+        this.stopAll();
+    }
+
+    async beforeApplicationShutdown(): Promise<void> {
+        this.stopAll();
+    }
+
+    // ---- internals ----
+
+    private async poll(state: PollerState): Promise<void> {
+        if (state.stopped || state.inFlight) return;
+        state.inFlight = true;
+
+        try {
+            await this.withTimeout(
+                state.processNext(state.queueName),
+                state.opts.timeoutPerIterationMs,
+            );
+
+            // success: reset backoff and schedule next run after base delay
+            state.backoff = state.opts.baseDelayMs;
+            // this.logger.debug(`[${state.queueName}] iteration completed`);
+            this.schedule(state, state.opts.baseDelayMs);
+        } catch (err: unknown) {
+            const msg = this.errorToString(err);
+            this.logger.error(`[${state.queueName}] iteration failed: ${msg}`);
+
+            // failure: schedule with backoff + optional jitter, then increase backoff
+            const wait = this.computeWait(state.backoff, state.opts);
+            state.backoff = Math.min(state.backoff * 2, state.opts.maxDelayMs);
+            this.schedule(state, wait);
+        } finally {
+            state.inFlight = false;
+        }
+    }
+
+    private schedule(state: PollerState, delayMs: number) {
+        if (state.stopped) return;
+        if (state.nextTimer) clearTimeout(state.nextTimer);
+
+        state.nextTimer = setTimeout(() => {
+            // clear reference before calling poll to avoid re-entrancy confusion
+            state.nextTimer = undefined;
+            this.poll(state).catch(() => { });
+        }, delayMs);
+    }
+
+    private computeWait(currentBackoff: number, opts: Required<PollOptions>): number {
+        if (!opts.jitter) return currentBackoff;
+        // Full jitter: random in [250ms, currentBackoff * 2], clamped to maxDelayMs
+        const doubled = Math.min(currentBackoff * 2, opts.maxDelayMs);
+        const jittered = Math.floor(Math.random() * doubled);
+        return Math.max(250, jittered);
+    }
+
+    private async withTimeout<T>(p: Promise<T>, ms: number): Promise<T> {
+        let timer: NodeJS.Timeout | undefined;
+        try {
+            return await Promise.race<T>([
+                p,
+                new Promise<never>((_, rej) => {
+                    timer = setTimeout(() => rej(new Error(`Iteration timed out after ${ms} ms`)), ms);
+                }),
+            ]);
+        } finally {
+            if (timer) clearTimeout(timer);
+        }
+    }
+
+    private errorToString(err: unknown): string {
+        if (err instanceof Error) return err.stack ?? err.message;
+        try {
+            return JSON.stringify(err);
+        } catch {
+            return String(err);
+        }
+    }
+}

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

@@ -3,6 +3,7 @@ import { QueuesModuleOptions } from "../../interfaces";
 import { QueueMessage, QueueSubscriber } from '../../interfaces/mq';
 import { MqMessageQueueService } from '../mq-message-queue.service';
 import { MqMessageService } from '../mq-message.service';
+import { PollerService } from '../poller.service';
 
 
 export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscriber<T> {
@@ -13,6 +14,7 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
     constructor(
         protected readonly mqMessageService: MqMessageService,
         protected readonly mqMessageQueueService: MqMessageQueueService,
+        protected readonly poller: PollerService,
     ) {
         this.serviceRole = process.env.QUEUES_SERVICE_ROLE;
         if (!this.serviceRole) {
@@ -70,6 +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> {
         // we will start subscriber only if the current service role is subscriber. 
         if (['both', 'subscriber'].includes(this.serviceRole)) {
@@ -77,24 +104,24 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
             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.poller.start(queueName, (q) => this.processNext(q), {
+                baseDelayMs: 1000,
+                maxDelayMs: 30_000,
+                timeoutPerIterationMs: 5 * 60_000,
+                jitter: true,
+            });
 
             this.logger.log(`DatabaseSubscriber ready to consume messages: ${JSON.stringify(this.options())}`);
         }
     }
 
+    onModuleDestroy() {
+        const options = this.options();
+        const queueName = options.queueName;
+        this.poller.stop(queueName);
+    }
+
     /**
      * Abstract method for message processing logic.
      */

package/src/services/sms/Msg91BaseSMSService.ts

@@ -20,7 +20,7 @@ export abstract class Msg91BaseSMSService implements ISMS {
         throw new Error(`Msg91 does not support sending plain text messages, you need to register a template and use the templateId to send the SMS.`);
     }
 
-    async sendSMSUsingTemplate(to: string, templateName: string, templateParams: any, shouldQueueSms = false): Promise<void> {
+    async sendSMSUsingTemplate(to: string, templateName: string, templateParams: any, shouldQueueSms = false): Promise<any> {
         // Load template and evaluate it. 
         const emailTemplate = await this.smsTemplateService.findOneByName(templateName);
         if (!emailTemplate) {
@@ -76,5 +76,5 @@ export abstract class Msg91BaseSMSService implements ISMS {
         this.logger.debug(`Queueing SMS to ${to} with message ${JSON.stringify(message)}`);
     }
 
-    abstract sendSMSSynchronously(message: QueueMessage<any>): Promise<void>
+    abstract sendSMSSynchronously(message: QueueMessage<any>): Promise<any>
 }

package/src/services/sms/Msg91OTPService.ts

@@ -28,7 +28,7 @@ export class Msg91OTPService extends Msg91BaseSMSService implements ISMS {
         super(commonConfiguration, 'OTPQueuePublisher', publisherFactory, smsTemplateService);
     }
 
-    async sendSMSSynchronously(message: QueueMessage<any>): Promise<void> {
+    async sendSMSSynchronously(message: QueueMessage<any>): Promise<any> {
         const { to, templateId, otp } = message.payload;
         const params = { otp, template_id: templateId, mobile: to, authkey: this.commonConfiguration.msg91Sms.apiKey }
         const otpUrl = `${this.commonConfiguration.msg91Sms.url}/otp?${this.paramsToQueryString(params)}`;

package/src/services/sms/Msg91SMSService.ts

@@ -21,7 +21,7 @@ export class Msg91SMSService extends Msg91BaseSMSService implements ISMS {
         super(commonConfiguration, 'SmsQueuePublisher', publisherFactory, smsTemplateService)
     }
 
-    async sendSMSSynchronously(message: QueueMessage<any>): Promise<void> {
+    async sendSMSSynchronously(message: QueueMessage<any>): Promise<any> {
         const { to, templateId, ...templateParams } = message.payload;
         const body = { template_id: templateId, short_url: "0", recipients: [{ mobiles: to, ...templateParams }] };
         const headers = { "authkey": this.commonConfiguration.msg91Sms.apiKey };