@solidstarters/solid-core 1.2.146 → 1.2.148

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 ?? 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: 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 };

package/src/services/sms/TwilioSMSService.ts

@@ -0,0 +1,118 @@
+import Handlebars from "handlebars";
+import { Inject, Injectable, Logger } from "@nestjs/common";
+import { ConfigType } from "@nestjs/config";
+import commonConfig from "src/config/common.config";
+import { SmsTemplateService } from "../sms-template.service";
+import { ISMS } from "../../interfaces";
+import { PublisherFactory } from "../queues/publisher-factory.service";
+import twilio from 'twilio';
+import { QueueMessage } from "src/interfaces/mq";
+
+
+@Injectable()
+export class TwilioSMSService implements ISMS {
+    private readonly logger = new Logger(TwilioSMSService.name);
+
+    constructor(
+        @Inject(commonConfig.KEY)
+        private commonConfiguration: ConfigType<typeof commonConfig>,
+        private publisherFactory: PublisherFactory<any>,
+        private smsTemplateService: SmsTemplateService,
+    ) {
+        // super(commonConfiguration, 'OTPQueuePublisher', publisherFactory, smsTemplateService);
+    }
+
+    async sendSMS(to: string, body: string, shouldQueueSms: boolean): Promise<any> {
+        const accountSid = this.commonConfiguration.twilio.accountSid;
+        const authToken = this.commonConfiguration.twilio.authToken;
+        const twilioNumber = this.commonConfiguration.twilio.number;
+        if (!accountSid || !authToken || !twilioNumber) {
+            throw new Error("Missing COMMON_TWILIO_ACCOUNT_SID or COMMON_TWILIO_AUTH_TOKEN or COMMON_TWILIO_NUMBER in env.");
+        }
+
+        const message = {
+            payload: {
+                body: body,
+                to: to,
+            },
+        };
+
+        // Send using queue if the developer has explicitly invoked with true.
+        if (shouldQueueSms === true) {
+            await this.sendSMSAsynchronously(message);
+        }
+        // If developer has not, however system config mandates that we send using queue, still we send.
+        else if (shouldQueueSms === false && this.commonConfiguration.shouldQueueSms === true) {
+            await this.sendSMSAsynchronously(message);
+        }
+        // Else we send synch
+        else {
+            await this.sendSMSSynchronously(message);
+        }
+
+        return message;
+    }
+
+    async sendSMSUsingTemplate(to: string, templateName: string, templateParams: any, shouldQueueSms: boolean): Promise<any> {
+        // Load template and evaluate it.
+        const smsTemplate = await this.smsTemplateService.findOneByName(templateName);
+        if (!smsTemplate) {
+            throw new Error(`Invalid template name ${templateName}`);
+        }
+
+        // Evaluate the body template.
+        let body = '';
+        try {
+            const bodyTemplate = Handlebars.compile(smsTemplate.body);
+            body = bodyTemplate(templateParams);
+        } catch (error) {
+            throw new Error('Unable to compile sms template body');
+        }
+        // Finally send the email.
+        return await this.sendSMS(to, body, shouldQueueSms);
+
+    }
+
+    async sendSMSAsynchronously(message) {
+        const { to } = message.payload;
+        this.publisherFactory.publish(message, 'TwilioSmsQueuePublisher');
+        this.logger.debug(`Queueing SMS to ${to} with message ${JSON.stringify(message)}`);
+    }
+
+    async sendSMSSynchronously(message: QueueMessage<any>): Promise<any> {
+        const accountSid = this.commonConfiguration.twilio.accountSid;
+        const authToken = this.commonConfiguration.twilio.authToken;
+        const twilioNumber = this.commonConfiguration.twilio.number;
+        if (!accountSid || !authToken || !twilioNumber) {
+            throw new Error("Missing COMMON_TWILIO_ACCOUNT_SID or COMMON_TWILIO_AUTH_TOKEN or COMMON_TWILIO_NUMBER in env.");
+        }
+
+        const { to, body } = message.payload;
+
+        const client = twilio(accountSid, authToken);
+        try {
+            const toSplit = to.split(',');
+
+            const r = [];
+
+            for (let i = 0; i < toSplit.length; i++) {
+                const actualTo = toSplit[i];
+                const twilioResponseMsg = await client.messages.create({
+                    body: body,
+                    from: twilioNumber,
+                    to: actualTo,
+                });
+
+                this.logger.debug(`Sending SMS to ${actualTo} using Twilio`);
+                this.logger.debug(`Twilio response: `);
+                this.logger.debug(JSON.stringify(twilioResponseMsg))
+
+                r.push(twilioResponseMsg);
+            }
+
+            return r;
+        } catch (error) {
+            throw new Error(error);
+        }
+    }
+}

package/src/solid-core.module.ts

@@ -186,6 +186,11 @@ import { OTPQueuePublisherDatabase } from './jobs/database/otp-publisher-databas
 import { OTPQueueSubscriberDatabase } from './jobs/database/otp-subscriber-database.service';
 import { SmsQueuePublisherDatabase } from './jobs/database/sms-publisher-database.service';
 import { SmsQueueSubscriberDatabase } from './jobs/database/sms-subscriber-database.service';
+
+import { TwilioSmsQueuePublisherDatabase } from './jobs/database/twilio-sms-publisher-database.service';
+import { TwilioSmsQueueSubscriberDatabase } from './jobs/database/twilio-sms-subscriber-database.service';
+
+
 import { TriggerMcpClientPublisherDatabase } from './jobs/database/trigger-mcp-client-publisher-database.service';
 import { TriggerMcpClientSubscriberDatabase } from './jobs/database/trigger-mcp-client-subscriber-database.service';
 import { WhatsappQueuePublisherDatabase } from './jobs/database/whatsapp-publisher-database.service';
@@ -260,6 +265,8 @@ import { SolidCreateModelLayoutMcpToolResponseHandler } from './services/mcp-too
 import { NoopsEntityComputedFieldProviderService } from './services/computed-fields/entity/noops-entity-computed-field-provider.service';
 import { AlphaNumExternalIdComputationProvider } from './services/computed-fields/entity/alpha-num-external-id-computed-field-provider';
 import { MailFactory } from './factories/mail.factory';
+import { TwilioSMSService } from './services/sms/TwilioSMSService';
+import { PollerService } from './services/poller.service';
 
 
 @Global()
@@ -427,9 +434,11 @@ import { MailFactory } from './factories/mail.factory';
     Msg91SMSService,
     Msg91OTPService,
     Msg91WhatsappService,
+    TwilioSMSService,
     SmsTemplateService,
     EmailTemplateService,
     PublisherFactory,
+    PollerService,
 
     McpToolResponseHandlerFactory,
     SolidCreateModuleMcpToolResponseHandler,
@@ -449,6 +458,8 @@ import { MailFactory } from './factories/mail.factory';
     SmsQueueSubscriber,
     SmsQueuePublisherDatabase,
     SmsQueueSubscriberDatabase,
+    TwilioSmsQueuePublisherDatabase,
+    TwilioSmsQueueSubscriberDatabase,
     OTPQueuePublisher,
     OTPQueueSubscriber,
     OTPQueuePublisherDatabase,
@@ -567,6 +578,7 @@ import { MailFactory } from './factories/mail.factory';
     ElasticEmailService,
     Msg91SMSService,
     Msg91OTPService,
+    TwilioSMSService,
     Msg91WhatsappService,
     TinyUrlService,
     PdfService,
@@ -592,6 +604,7 @@ import { MailFactory } from './factories/mail.factory';
     ConfigModule,
     PublisherFactory,
     MailFactory,
+    PollerService
   ],
 })
 export class SolidCoreModule { }